AI-LSC v3.3.0 - fixed catagories, fixed git pulls

CHANGES.md

@@ -1,5 +1,256 @@
 # AI-LSC Changelog
 
+## v3.3 — Registry git-URL sync + bandwidth-aware git-pull + ComfyUI
+
+Patch release over v3.2. No schema changes, no UI reorganisation, no
+wiring-graph churn — only the 10-layer registry's installer URLs are
+touched, plus the git install/update logic in `runtime/installer.py`,
+plus a new ComfyUI registry entry, plus version strings and a per-file
+change log.
+
+### What changed
+
+The 10-layer registry layer files had drifted from the systems-architect
+reference (`ai-stack-guide-v12.md`, "Approaching the Local AI Stack Like
+a Systems Architect" by Jeremy Anderson). 52 installer URLs were either
+pointing at placeholder repos (`github.com/nicely-done/<tool_id>`,
+clearly never intended to ship) or at wrong upstreams (e.g. `airllm`
+pointed at `liguodongiot/llm-airforce`; `llamacpp` pointed at
+`ggerganov/llama.cpp` instead of the current `ggml-org/llama.cpp`).
+Three tools the v12 md lists as `git` / `git_node` (pm_skills, agno,
+openhands) were registered as `uv` package-manager installs — wrong,
+since the user manually tested every entry in the md by cloning the
+github repo.  Four registry-only tools (algory, atlas_os, eagle_eye,
+glassmind) had only placeholder URLs because web search could not
+find their official upstreams; the user provided the URLs directly.
+ComfyUI was referenced in the `ai-image-gen-local.json` stack template
+but had no registry entry.
+
+This release:
+- Brings every git-ish installer into agreement with the v12 reference.
+- Adds `pkg` fields to the 6 script-type installers that reference
+  github release tarballs.
+- Resolves 10 registry-only git tools to their official upstreams via
+  web search.
+- Switches the 3 type-mismatch tools to proper git/git_node installs.
+- Resolves the 4 previously-unresolved registry-only tools to the
+  user-provided official upstreams.
+- Adds a ComfyUI registry entry (Level 10, `git:comfy-org/comfyui`).
+- Hardens the git installer runtime to be bandwidth-aware.
+
+### Five categories of patches (52 total)
+
+- **A (28)** — `git` / `git_node` / `custom` installer `pkg` URL
+  corrected to match the v12 markdown reference. See
+  `docs/REGISTRY-URLS-v3.3.0.md` for the per-file old → new URL table.
+- **B (6)** — `script`-type installers (fabric, grafana_alloy,
+  llamafile, meilisearch, ollama, qdrant) get a new `pkg` field
+  referencing the github repo, while the existing working `cmd`
+  (curl release tarball, etc.) is left untouched.
+- **C (10)** — registry-only git tools with no v12 markdown entry
+  resolved via web search:
+  - `agent_reach` → `Panniantong/Agent-Reach`
+  - `everos_memory` → `EverMind-AI/EverOS`
+  - `headroom` → `headroomlabs-ai/headroom`
+  - `mnemo_cortex` → `GuyMannDude/mnemo-cortex`
+  - `nightshift` → `johndaskovsky/nightshift`
+  - `openbrain` → `NateBJones-Projects/OB1`
+  - `turbovec` → `ryancodrai/turbovec`
+  - `crossplane` → `crossplane/crossplane`
+  - `keycloak` → `keycloak/keycloak`
+  - `dma` → `distcc/distcc` (closest parent project; DMA has no
+    separate public repo)
+- **D (3)** — type-mismatch fixes (md says git / git_node, registry had
+  `uv` with package name):
+  - `pm_skills` → `git:https://github.com/product-on-purpose/pm-skills`
+  - `agno` → `git:https://github.com/agno-agi/agno`
+  - `openhands` → `git_node:https://github.com/All-Hands-AI/OpenHands.git`
+- **E (4)** — user-provided URLs for the 4 previously-unresolved
+  registry-only tools (web search could not find these; the user
+  provided the official upstream URLs directly):
+  - `algory` → `aryaghan-mutum/algory`
+  - `atlas_os` → `atlas-os/atlas`
+  - `eagle_eye` → `thoughtfuldev/eagleeye`
+  - `glassmind` → `khodges42/glassMind`
+
+### New tool entry (1)
+
+- **ComfyUI** (`user_interfaces.py`): ComfyUI was referenced in the
+  `ai-image-gen-local.json` stack template but had no registry entry
+  before.  Added as a Level 10 (Human Interface & System Operations)
+  tool with installer `git:https://github.com/comfy-org/comfyui`,
+  launcher `python main.py --listen 0.0.0.0 --port 8188`, deps
+  `[cuda]`, license GPL-3.0.  Total registry size is now 187 tools
+  (was 186).
+
+### Runtime: bandwidth-aware git-pull-on-update
+
+`runtime/installer.py`'s `install_git` and `install_git_node` already
+ran `git pull --ff-only` if the destination dir existed, but the
+existence check was `os.path.exists(dest)` — True for any dir, not
+just a git working tree.  An empty or non-git dir at the destination
+would cause `git pull` to fail and abort the install.  Hardened:
+
+1. Check `os.path.isdir(dest/.git)` to confirm a real git repo.
+2. On pull failure (diverged branches, network errors, corrupted
+   index, etc.), move the old dir aside to `<dest>.bak.<unix_ts>`
+   and re-clone fresh — so the install always ends in a usable state
+   instead of leaving a half-broken tree.
+3. If the dest dir exists but is not a git repo, back it up and clone
+   fresh.
+4. Log clearly which path was taken (pulled / re-cloned / new clone /
+   non-git-dir backed up).
+
+**Effect:** re-running install on a tool that's already cloned only
+fetches the diff (a few KB / MB), not the entire repo.  This is the
+bandwidth-saving behaviour the user asked for.
+
+### Intentionally NOT touched
+
+- `apex` (md says `pip — https://github.com/NVIDIA/apex`): kept as
+  `uv:apex` (pip-installed).  The md's `pip` installer type is
+  authoritative and the user did not call this one out.
+- 12 git-ish installers that already matched the v12 reference
+  (`anythingllm`, `dify`, `heretic`, `homelab`, `invokeai`,
+  `koboldcpp`, `librechat`, `mcp_drift_state_tracker`, `openjarvis`,
+  `paperlessngx`, `synapscli`, `wayland_ai`) — no change needed.
+- 3 registry-only git tools with real-looking URLs already in place
+  (`goose` → `block/goose`, `nvidia_agent_skills` →
+  `NVIDIA/agent-skills`, `picode` → `jasonjmcghee/picode.git`) — no
+  change needed.
+
+### Versioning & docs
+
+- `pyproject.toml`: 3.2.0 → 3.3.0
+- `src/ai_lsc/constants.py`: `APP_VERSION` 3.2.0 → 3.3.0
+  (`APP_CODENAME` unchanged: `"Decalogue"`)
+- New file: `docs/REGISTRY-URLS-v3.3.0.md` (per-file old → new URL
+  table, also serves as a release audit trail).
+- `gitcommit` rewritten for v3.3.0.
+
+### Verification
+
+- All 94 Python files under `src/` AST-parse cleanly.
+- Registry extractor re-imports every patched layer module and
+  confirms all 52 patches landed + the new ComfyUI entry.  Total
+  registry size: 187 tools (was 186).
+- Each old `pkg` URL string was unique within its file and matched
+  exactly once — no blind global replaces.
+- Each script-type pkg-field injection matched exactly one installer
+  block (Python AST-parses after each injection).
+- `install_git` / `install_git_node` hardened: the new logic branches
+  on `os.path.isdir(.git)`, falls back to re-clone on pull failure,
+  and uses `import time` for backup-dir timestamps.  All confirmed
+  present in `runtime/installer.py`.
+- 0 `nicely-done` placeholder URLs remain in the registry.
+
+---
+
+## v3.2 — 10-Layer Systems Architecture Taxonomy completed
+
+Finishes the taxonomy re-org that was started (but stalled) on top of
+v3.1.1b: the whole codebase now speaks the unified 10-layer taxonomy
+from the systems-architecture review (POSIX/Unix philosophy, bare-metal
+process hierarchy).  The partial migration had already rewritten
+`constants.py` (NAV_LAYER_ORDER) and `db_manager.py` (CATEGORY_MAP); this
+release completes every remaining surface, repairs the damage the
+interim tooling caused, and reconciles the registries.  Validator
+reports 0 errors on both the 108-tool defaults seed and the 186-tool
+merged layer registry; wiring graph validates with 0 errors.
+
+### New layer ladder (11 → 10)
+
+```
+L1  Host Platform & Infrastructure          L6  Multi-Agent Orchestration Runtimes
+L2  Development Runtime & Environment       L7  Agentic Software Engineering & Sandboxes
+L3  GPU Acceleration & Optimization         L8  Decentralized Knowledge & Vector Stores
+L4  Local Inference Engines                 L9  Data Extraction & Pipeline Harvest
+L5  Intelligent API Routers & Proxies       L10 Human Interface & System Operations
+```
+
+The 11-layer model's Security and Observability strata dissolve:
+security *daemons* (keycloak, vault, fail2ban, edge/proxy daemons) are
+host platform infrastructure (L1); scanners/policy/audit tooling
+(trivy, clamav, opa) and telemetry (btop, grafana, prometheus, opik)
+are system operations (L10).  Routing merges into Intelligent API
+Routers & Proxies (L5).  Vector/graph stores and agent memory move out
+of Knowledge Management into L8; document/crawl/transcode pipelines
+become L9; IaC and cluster automation land in L10.
+
+### Registry
+
+- `registry/defaults.py` rebuilt as the 108-tool 10-layer seed from the
+  master-target registry: new `level`/`layer`/`role`/`category` plus the
+  richer descriptions.  Operational metadata (real installer pkgs/URLs
+  and cmds, `post_install`/`update_cmd`/`env_overrides`, launchers with
+  correct binary names and systemd-for-daemons, dependency edges,
+  curated flags, SPDX licenses, `filesystem` blocks) is preserved from
+  the previous registry — the master-target file had systematically
+  replaced installers with placeholder URLs, dropped script cmds
+  (validator errors), wiped all dep edges, and renamed binaries
+  (`rg` → `ripgrep`, systemd → tmux `serve` stubs).  curl|sh installer
+  policy markers are untouched (see whatremains.txt, C-05).
+- 11 modular layer files realigned: 185 tools migrated to the 10-layer
+  taxonomy (107 shared tools take their structural fields from the
+  master registry; the other 78 classified explicitly — see
+  `scripts/apply_10layer_taxonomy.py` for the classification table).
+- `kanban` reconciled: it existed only in `defaults.py` (the canonical
+  source is the layer files), so it is now declared in
+  `layers/user_interfaces.py` as well (L10, Sprints Manager).  Merged
+  registry: 185 → 186 tools.
+- `n8n` keeps its explicit L10 placement (visual flow canvas) and moves
+  to the `Workflow` (Visual Builder) category so the categorisation
+  cascade agrees with the registry.
+- `n8n`/`odysseus` `filesystem` blocks (previously only in the old
+  defaults) are preserved in `layers/orchestrators.py`.
+- The `open_webui`/`openwebui` orphan-flagging gap from the TODO is
+  confirmed moot: only `openwebui` exists and it is wired.
+
+### Stack wiring
+
+- `stack/connections.py`: 92 static `StackWiring(layer=...)` values
+  migrated to the 10-layer names; the 5 loop-based bulk allocations now
+  resolve layers dynamically via `_wiring_layer(_tid)` (DEFAULT_REGISTRY
+  lookup + `_WIRING_LAYER_SUPPLEMENT` for wired tools outside the seed
+  registry), so the wiring graph can never drift from the taxonomy
+  again.  Section header comments map the old L1–L13 sections to their
+  new homes.  Wiring-vs-registry layer mismatches: 0 across 137 wirings.
+
+### UI
+
+- `ui/pages/db_manager.py` **repaired and migrated**: the interim
+  migration had truncated the file from 1300 to 222 lines (syntax error
+  at the CATEGORY_MAP tail; the entire DB-manager dialog/table
+  implementation was lost).  Restored in full from the v3.1.1b routing
+  tarball, then its CATEGORY_MAP was migrated to the 10-layer taxonomy.
+- Categorisation cascade extended to 221 categories: the master map
+  (105) + 43 categories for the classified tools + 73 preserved
+  categories from the v3.1.1b cascade, translated to the 10-layer
+  taxonomy with their curated roles.  Every category used by the 186
+  registry tools is covered; cascade and registry agree on layer for
+  every tool.
+- `ui/pages/db_manager_category_map.py` regenerated to match.
+- `registry/validator.py` now enforces level range 1–10.
+
+### Docs & tooling
+
+- README layer table + tool counts updated to the 10-layer taxonomy
+  (186 tools); quickstart's "13-layer architecture" reference fixed.
+- Layer-file module docstrings note the 10-layer realignment.
+- `scripts/apply_10layer_taxonomy.py` added (the corrected, completed
+  migration utility — supersedes the root `apply_taxonomy_migration.py`,
+  whose regexes could not match multi-word layer names and whose
+  defaults handling was lossy; kept for history).
+
+### Verification
+
+`scripts`-style checks all pass: 100 Python files AST-parse; validator
+0 errors (defaults + merged + wiring graph); level/layer consistency
+holds across defaults, layer files, CATEGORY_MAP, and STACK_WIRINGS;
+NAV_LAYER_ORDER matches the taxonomy; guardrails clean; headless
+package import + `RegistryManager` first-boot/second-run bootstrap
+verified (186 tools seeded to ecosystem.json, structural sync clean).
+
 ## v3.1.1b — taxonomy re-org: Routing restored (11 layers), canonical 24-dir /mnt/AI layout
 
 Restores the Routing layer that was lost when the 13-layer model was

README.md

@@ -26,17 +26,17 @@ AI Local Stack Control (AI-LSC) provides a unified interface to discover, config
 Every tool in the registry is classified within a 10-layer taxonomy, giving you a clear mental model of your entire AI stack. Select tools directly from the sidebar — the sidebar *is* the wizard.
 
 | Layer | Tools | Examples |
-|-------|-------|---------|
+|-------|-------|----------|
-| L1 — Host Platform | 16 | PostgreSQL, MariaDB, Redis, SQLite3, DuckDB, Podman, Docker, Tmux, Git |
+| L1 — Host Platform & Infrastructure | 21 | PostgreSQL, MariaDB, Redis, DuckDB, Podman, Docker, LXC, Firecracker, libvirt, nginx, Tmux, Keycloak, Vault |
-| L2 — Development Environment | 33 | Python Environment, Deno, uv, Node.js, CuPy, ripgrep, fd, tree-sitter, SST, Unsloth |
+| L2 — Development Runtime & Environment | 34 | Python, uv, Node.js, Deno, Go, Rust, GCC, make, ripgrep, fd, tree-sitter, git, gdb, valgrind |
-| L3 — GPU Runtimes | 3 | CUDA Toolkit, NVIDIA Apex, tinygrad |
+| L3 — GPU Acceleration & Optimization | 5 | CUDA, CuPy, Apex, Unsloth, tinygrad |
-| L4 — Engines | 8 | Ollama, llama.cpp, KoboldCPP, Llamafile, TurboLLM, AirLLM, Locally-Uncensored |
+| L4 — Local Inference Engines | 10 | vLLM, SGLang, llama.cpp, KoboldCPP, Llamafile, Ollama, TurboLLM, AirLLM |
-| L5 — Orchestrators | 53 | vLLM, SGLang, LiteLLM Proxy, 9Router Proxy, LangChain, LangFlow, Dify, CrewAI, AutoGen, Letta, OpenCode, Gemini CLI, Qwen Code, goose, Codex, +38 more |
+| L5 — Intelligent API Routers & Proxies | 4 | LiteLLM Proxy, 9Router Proxy, MeshLLM, Fabric |
-| L6 — Security | 6 | Keycloak, HashiCorp Vault, Trivy, Fail2Ban, ClamAV, Open Policy Agent |
+| L6 — Multi-Agent Orchestration Runtimes | 22 | Swarm, AutoGen, CrewAI, Agno, LangChain, Letta, OpenBrain, Ray, Glassmind |
-| L7 — Observability | 8 | Btop, Glances, Prometheus, Grafana, Grafana Alloy, Opik, Pulse AI, Latitude |
+| L7 — Agentic Software Engineering & Sandboxes | 17 | OpenHands, Aider, Claude Code, Codex, Gemini CLI, OpenCode, goose, spec-kit |
-| L8 — User Interfaces | 17 | Open WebUI, AnythingLLM, LibreChat, Flowise, Jan, InvokeAI, Forge (A1111), ComfyUI, Dashy, Obsidian, +7 more |
+| L8 — Decentralized Knowledge & Vector Stores | 11 | ChromaDB, LanceDB, Qdrant, Neo4j, Elasticsearch, Meilisearch, Mem0, TurboVec |
-| L9 — DevOps | 11 | Terraform, Ansible, Puppet, Pulumi, OpenTofu, AWS CDK, Crossplane, Terragrunt |
+| L9 — Data Extraction & Pipeline Harvest | 12 | Crawl4AI, Docling, MarkItDown, Whisper, Parakeet, Airweave, OpenDataloader |
-| L10 — Knowledge Management | 26 | Zotero, Calibre, Paperless-ngx, Logseq, Joplin, Mem0, ChromaDB, LanceDB, Qdrant, LlamaIndex, +16 more |
+| L10 — Human Interface & System Operations | 50 | Open WebUI, AnythingLLM, LibreChat, Flowise, n8n, Dify, Grafana, Prometheus, Terraform, Ansible |
 
 ![Infrastructure Layers](docs/screenshots/infrastructure-layers.png)
 
@@ -147,7 +147,7 @@ ai_lsc/
     validator.py               # Schema validation (8-key flags enforced)
     license_gate.py            # License compliance gating
     licenses.py                # License database
-    layers/                    # 10 per-layer tool files
+    layers/                    # 11 per-layer tool files (10-layer taxonomy)
       host_platform.py         # L1: 9 tools
       development.py           # L2: 7 tools
       gpu.py                   # L3: 3 tools

TODO.md

@@ -1,5 +1,13 @@
 # AI-LSC TODO
 
+## Recent progress (v3.2 — 10-Layer Systems Architecture)
+
+- ✅ Completed the 10-layer taxonomy migration that was started on top of v3.1.1b: `defaults.py` (108-tool seed), all 11 modular layer files (186 tools), `stack/connections.py` (92 static layers + 5 dynamic loop lookups), CATEGORY_MAP cascade (221 categories), validator level range, README/quickstart/docs. See [CHANGES.md](CHANGES.md) → v3.2.
+- ✅ Repaired `ui/pages/db_manager.py`: the interim migration had truncated it to 222 lines (syntax error + lost implementation); restored in full from the v3.1.1b routing tarball and migrated its CATEGORY_MAP.
+- ✅ Reconciled `kanban` into the layer files (was defaults-only) — merged registry is now 186 tools.
+- ✅ Preserved all operational registry metadata (installers, launchers, deps, flags, licenses, filesystem blocks) that the master-target defaults rewrite had stripped; curl|sh policy markers untouched (C-05).
+- ✅ `open_webui` vs `openwebui` orphan gap: confirmed moot — only `openwebui` exists in the registry and it has a STACK_WIRINGS entry.
+
 ## Recent progress (v3.1 — 2026-07-07)
 
 - ✅ Applied the full master code critique: 91 of 93 findings addressed (CRITICAL × 6, HIGH × 24, MEDIUM × 42, LOW × 19). The 2 intentionally skipped items (curl|sh remote installers) are documented in [whatremains.txt](whatremains.txt).
@@ -10,11 +18,26 @@
 
 ## Open work
 
-The 13 layers are likely to stay but the way they're described and labeled may change in the next release. The agentic abilities for classification of software tools are still limited — I have little time to code lately; this was a tool to make my life easier when testing software out. If you're reading this file, first of all thanks for trying it out — help by testing the UI, tools, configs, and pipelines. It's a lot.
+The 10-layer taxonomy is now in place; classification quality is the next
+frontier. The 78 layer-file tools absent from the master registry were
+classified by hand for v3.2 (table in
+`scripts/apply_10layer_taxonomy.py`); review those assignments if any
+feel wrong — `layer`/`level` sync from layer files makes corrections a
+one-file edit. If you're reading this file, first of all thanks for
+trying it out — help by testing the UI, tools, configs, and pipelines.
+It's a lot.
 
-### Known registry inconsistencies to reconcile
+### Follow-ups worth doing
 
-- `open_webui` (with underscore) vs `openwebui` (no underscore) — the Pipeline Ticker surfaces this gap when both are staged: `open_webui` is flagged orphan because it has no `STACK_WIRINGS` entry, while `openwebui` does. Recommend a follow-up pass to either rename one tool_id or merge the wirings.
+- Regroup the 11 legacy layer files (still named after the old taxonomy:
+  `security.py`, `observability.py`, `devops.py`, ...) into 10 files that
+  match the new layer names. The loader merges by tool, not by filename,
+  so this is pure file-shuffling — deferred as churn in v3.2.
+- `llama-swap` and `mesh-llm` are listed as Layer 5 exemplars in the
+  architecture docs but only `meshllm` exists in the registry; consider
+  adding a `llama_swap` entry (VRAM swapper) to complete the story.
+- The 74 preserved-but-unused cascade categories (from the v3.1.1b map)
+  could be pruned if the category combobox feels crowded.
 
 ### Deferred from the critique pass
 
@@ -22,12 +45,12 @@ See [whatremains.txt](whatremains.txt) for the full list. Highlights:
 
 - `curl|sh` remote installers (Ollama, Grafana Alloy, Meilisearch) — left in place per user instruction. Apply the critique's download-first pattern when the remote-code-execution policy is revisited.
 - L-17: `registry/openengineer/parser.py` still has commented-out code blocks — confirm with the OE importer maintainer before deleting.
-- L-18: registry layer files declare tools without `filesystem` blocks; backfilling `install/config/cache/logs` paths across all 123 layer-file tools is a mechanical but sizable job.
+- L-18: registry layer files declare tools without `filesystem` blocks; backfilling `install/config/cache/logs` paths across the layer-file tools is a mechanical but sizable job (v3.2 preserved the 24 defaults.py blocks + n8n/odysseus).
 - M-22 / M-40: `chatbot_console.py` HTML bubble builder + nested ternary — could extract `_render_bubble(msg)` helper, deferred as low-impact polish.
 - M-10 / M-15 / M-16: `registry/openengineer/importer.py` nested-if flattening + dedup — defer to a focused OE-importer cleanup pass.
 
 ### UX polish still on the wishlist
 
 - The Monitor page flow is 80% organized; the layout is still being decided.
-- More `STACK_WIRINGS` entries — the ticker's value scales with how complete the wiring data is. Currently 60 wirings for 124 tools; gaps surface as orphans when staged.
+- More `STACK_WIRINGS` entries — the ticker's value scales with how complete the wiring data is. Currently 137 wirings for 186 tools; gaps surface as orphans when staged.
-- Screenshots: the `docs/screenshots/` directory still reflects v3.0. A refresh pass to capture the new Pipeline Ticker + Workspace Tab is overdue.
+- Screenshots: the `docs/screenshots/` directory still reflects v3.0. A refresh pass to capture the 10-layer sidebar + Pipeline Ticker + Workspace Tab is overdue.

apply_taxonomy_migration.py

@@ -0,0 +1,300 @@
+#!/usr/bin/env python3
+"""
+DCOS.net AI-LSC Codebase Reorganization & 10-Layer Migration Utility
+Author: Jeremy Anderson
+Domain: dcos.net
+Contact: info@dcos.net
+License: CC-BY-SA 4.0 International
+
+This script programmatically upgrades the entire ai_lsc codebase to be
+10-layer compliant. It reorganizes layer order, updates the category map,
+and ensures that all stack wiring loops dynamically look up layer metadata.
+"""
+
+import os
+import re
+from pathlib import Path
+
+# ── 1. Reorganized 10-Layer Taxonomy ───────────────────────────────────────
+NEW_LAYERS = [
+    "Host Platform & Infrastructure",
+    "Development Runtime & Environment",
+    "GPU Acceleration & Optimization",
+    "Local Inference Engines",
+    "Intelligent API Routers & Proxies",
+    "Multi-Agent Orchestration Runtimes",
+    "Agentic Software Engineering & Sandboxes",
+    "Decentralized Knowledge & Vector Stores",
+    "Data Extraction & Pipeline Harvest",
+    "Human Interface & System Operations"
+]
+
+# ── 2. Reorganized CATEGORY_MAP ─────────────────────────────────────────────
+NEW_CATEGORY_MAP = {
+    "Agent Daemon": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Agent Daemon"},
+    "Agent Shell": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Agent Shell"},
+    "Agentless Deployment": {"layer": "Human Interface & System Operations", "level": 10, "role": "Agentless Deployment"},
+    "Alloy Telemetry": {"layer": "Human Interface & System Operations", "level": 10, "role": "Alloy Telemetry"},
+    "Analytical Database": {"layer": "Host Platform & Infrastructure", "level": 1, "role": "Analytical Database"},
+    "Audio Extraction": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "Audio Extraction"},
+    "Auto Recovery Daemon": {"layer": "Human Interface & System Operations", "level": 10, "role": "Auto Recovery Daemon"},
+    "CI/CD Orchestration": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "CI/CD Orchestration"},
+    "CLI Pair Programmer": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "CLI Pair Programmer"},
+    "Cache": {"layer": "Host Platform & Infrastructure", "level": 1, "role": "Cache"},
+    "Cloud Dev Kit": {"layer": "Human Interface & System Operations", "level": 10, "role": "Cloud Dev Kit"},
+    "Cluster Homepage": {"layer": "Human Interface & System Operations", "level": 10, "role": "Cluster Homepage"},
+    "Code Refactoring": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "Code Refactoring"},
+    "Codex Developer": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "Codex Developer"},
+    "Collaborative Chat": {"layer": "Human Interface & System Operations", "level": 10, "role": "Collaborative Chat"},
+    "Context Integrity Core": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "Context Integrity Core"},
+    "Coordination Protocol": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Coordination Protocol"},
+    "Curation Pipeline": {"layer": "Intelligent API Routers & Proxies", "level": 5, "role": "Curation Pipeline"},
+    "Data Ingest": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "Data Ingest"},
+    "Database": {"layer": "Host Platform & Infrastructure", "level": 1, "role": "Database"},
+    "Datacenter Inference": {"layer": "Local Inference Engines", "level": 4, "role": "Datacenter Inference"},
+    "Desktop Agent Core": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Desktop Agent Core"},
+    "Desktop GUI": {"layer": "Human Interface & System Operations", "level": 10, "role": "Desktop GUI"},
+    "Distributed Search": {"layer": "Decentralized Knowledge & Vector Stores", "level": 8, "role": "Distributed Search"},
+    "Document Archiver": {"layer": "Human Interface & System Operations", "level": 10, "role": "Document Archiver"},
+    "Document Comprehension": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "Document Comprehension"},
+    "Document Parser": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "Document Parser"},
+    "ETL Transformation": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "ETL Transformation"},
+    "Ecosystem Launcher": {"layer": "Human Interface & System Operations", "level": 10, "role": "Ecosystem Launcher"},
+    "Enterprise Assistant": {"layer": "Human Interface & System Operations", "level": 10, "role": "Enterprise Assistant"},
+    "Extensible Interface": {"layer": "Human Interface & System Operations", "level": 10, "role": "Extensible Interface"},
+    "File Discovery": {"layer": "Development Runtime & Environment", "level": 2, "role": "File Discovery"},
+    "GGUF Runtime": {"layer": "Local Inference Engines", "level": 4, "role": "GGUF Runtime"},
+    "GPU Computing": {"layer": "GPU Acceleration & Optimization", "level": 3, "role": "GPU Computing"},
+    "Gap Analyzer": {"layer": "Human Interface & System Operations", "level": 10, "role": "Gap Analyzer"},
+    "Graph Database": {"layer": "Decentralized Knowledge & Vector Stores", "level": 8, "role": "Graph Database"},
+    "Hardware Acceleration": {"layer": "GPU Acceleration & Optimization", "level": 3, "role": "Hardware Acceleration"},
+    "High-Performance Vector": {"layer": "Decentralized Knowledge & Vector Stores", "level": 8, "role": "High-Performance Vector"},
+    "IaC DRY Wrapper": {"layer": "Human Interface & System Operations", "level": 10, "role": "IaC DRY Wrapper"},
+    "Image WebUI": {"layer": "Human Interface & System Operations", "level": 10, "role": "Image WebUI"},
+    "Infrastructure Provision": {"layer": "Human Interface & System Operations", "level": 10, "role": "Infrastructure Provision"},
+    "Infrastructure as Code": {"layer": "Development Runtime & Environment", "level": 2, "role": "Infrastructure as Code"},
+    "Integration Library": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Integration Library"},
+    "Isolation": {"layer": "Host Platform & Infrastructure", "level": 1, "role": "Isolation"},
+    "LLM Observability": {"layer": "Human Interface & System Operations", "level": 10, "role": "LLM Observability"},
+    "Layer-wise Inference": {"layer": "Local Inference Engines", "level": 4, "role": "Layer-wise Inference"},
+    "Learning Cards": {"layer": "Human Interface & System Operations", "level": 10, "role": "Learning Cards"},
+    "Lexical Search": {"layer": "Decentralized Knowledge & Vector Stores", "level": 8, "role": "Lexical Search"},
+    "Library Manager": {"layer": "Human Interface & System Operations", "level": 10, "role": "Library Manager"},
+    "Load Balancer": {"layer": "Intelligent API Routers & Proxies", "level": 5, "role": "Load Balancer"},
+    "Local Central Shell": {"layer": "Human Interface & System Operations", "level": 10, "role": "Local Central Shell"},
+    "Local Declarative DSL": {"layer": "Human Interface & System Operations", "level": 10, "role": "Local Declarative DSL"},
+    "Local LLM Runner": {"layer": "Local Inference Engines", "level": 4, "role": "Local LLM Runner"},
+    "Markdown Converter": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "Markdown Converter"},
+    "Metal Provisioner": {"layer": "Human Interface & System Operations", "level": 10, "role": "Metal Provisioner"},
+    "Metric Scraper": {"layer": "Human Interface & System Operations", "level": 10, "role": "Metric Scraper"},
+    "Mixed Precision": {"layer": "GPU Acceleration & Optimization", "level": 3, "role": "Mixed Precision"},
+    "Model Curation": {"layer": "Local Inference Engines", "level": 4, "role": "Model Curation"},
+    "Model Manager GUI": {"layer": "Human Interface & System Operations", "level": 10, "role": "Model Manager GUI"},
+    "Model Optimization": {"layer": "GPU Acceleration & Optimization", "level": 3, "role": "Model Optimization"},
+    "Model Surgery": {"layer": "Local Inference Engines", "level": 4, "role": "Model Surgery"},
+    "Multi-Agent Framework": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Multi-Agent Framework"},
+    "Native Inference": {"layer": "Local Inference Engines", "level": 4, "role": "Native Inference"},
+    "Offline Journal": {"layer": "Human Interface & System Operations", "level": 10, "role": "Offline Journal"},
+    "Open-Source IaC": {"layer": "Human Interface & System Operations", "level": 10, "role": "Open-Source IaC"},
+    "Outliner Graph": {"layer": "Human Interface & System Operations", "level": 10, "role": "Outliner Graph"},
+    "Output Evaluator": {"layer": "Human Interface & System Operations", "level": 10, "role": "Output Evaluator"},
+    "PDF Processing": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "PDF Processing"},
+    "Parsing Engine": {"layer": "Development Runtime & Environment", "level": 2, "role": "Parsing Engine"},
+    "Performance Engine": {"layer": "Local Inference Engines", "level": 4, "role": "Performance Engine"},
+    "Platform Workspace": {"layer": "Human Interface & System Operations", "level": 10, "role": "Platform Workspace"},
+    "Production Multi-Agent": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Production Multi-Agent"},
+    "Programmable IaC": {"layer": "Human Interface & System Operations", "level": 10, "role": "Programmable IaC"},
+    "Prompt Tester": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "Prompt Tester"},
+    "RAG Flow Canvas": {"layer": "Human Interface & System Operations", "level": 10, "role": "RAG Flow Canvas"},
+    "Reference Manager": {"layer": "Human Interface & System Operations", "level": 10, "role": "Reference Manager"},
+    "Requirement Builder": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "Requirement Builder"},
+    "Role-Playing Agent": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Role-Playing Agent"},
+    "Runtime Environment": {"layer": "Development Runtime & Environment", "level": 2, "role": "Runtime Environment"},
+    "Runtime Packaging": {"layer": "Host Platform & Infrastructure", "level": 1, "role": "Runtime Packaging"},
+    "Serverless Database": {"layer": "Decentralized Knowledge & Vector Stores", "level": 8, "role": "Serverless Database"},
+    "Single-File Runtime": {"layer": "Local Inference Engines", "level": 4, "role": "Single-File Runtime"},
+    "Skill Auditor": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "Skill Auditor"},
+    "Sovereign Graph Editor": {"layer": "Human Interface & System Operations", "level": 10, "role": "Sovereign Graph Editor"},
+    "Sovereign Software Agent": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "Sovereign Software Agent"},
+    "Speech Transcriber": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "Speech Transcriber"},
+    "Sprint Planner": {"layer": "Human Interface & System Operations", "level": 10, "role": "Sprint Planner"},
+    "Sprints Manager": {"layer": "Human Interface & System Operations", "level": 10, "role": "Sprints Manager"},
+    "Stateless Orchestration": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Stateless Orchestration"},
+    "Structured Synthesis": {"layer": "Decentralized Knowledge & Vector Stores", "level": 8, "role": "Structured Synthesis"},
+    "Studio Canvas": {"layer": "Human Interface & System Operations", "level": 10, "role": "Studio Canvas"},
+    "Synchronization Layer": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "Synchronization Layer"},
+    "System Auditor": {"layer": "Human Interface & System Operations", "level": 10, "role": "System Auditor"},
+    "System Console": {"layer": "Human Interface & System Operations", "level": 10, "role": "System Console"},
+    "Telemetry Monitor": {"layer": "Human Interface & System Operations", "level": 10, "role": "Telemetry Monitor"},
+    "Telemetry Visualizer": {"layer": "Human Interface & System Operations", "level": 10, "role": "Telemetry Visualizer"},
+    "Terminal Agent": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Terminal Agent"},
+    "Terminal Coding Agent": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "Terminal Coding Agent"},
+    "Text Search": {"layer": "Development Runtime & Environment", "level": 2, "role": "Text Search"},
+    "Unified API Gateway": {"layer": "Intelligent API Routers & Proxies", "level": 5, "role": "Unified API Gateway"},
+    "Vector Engine": {"layer": "Decentralized Knowledge & Vector Stores", "level": 8, "role": "Vector Engine"},
+    "Vision describer": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "Vision describer"},
+    "Visual Agent Canvas": {"layer": "Human Interface & System Operations", "level": 10, "role": "Visual Agent Canvas"},
+    "Voice Synthesis": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "Voice Synthesis"},
+    "Web Scraper": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "Web Scraper"},
+}
+
+def migrate_constants(path: Path):
+    if not path.exists():
+        print(f"[-] constants.py not found at {path}")
+        return
+    content = path.read_text(encoding="utf-8")
+    
+    # Locate NAV_LAYER_ORDER array
+    nav_pattern = re.compile(r'NAV_LAYER_ORDER:\s*list\[str\]\s*=\s*\[[^\]]+\]', re.DOTALL)
+    new_nav_str = "NAV_LAYER_ORDER: list[str] = [\n" + "".join(f'    "{l}",\n' for l in NEW_LAYERS) + "]"
+    
+    if nav_pattern.search(content):
+        content = nav_pattern.sub(new_nav_str, content)
+        path.write_text(content, encoding="utf-8")
+        print(f"[+] Migrated constants.py layers!")
+    else:
+        print(f"[-] NAV_LAYER_ORDER block not matched in constants.py")
+
+def migrate_db_manager(path: Path):
+    if not path.exists():
+        print(f"[-] db_manager.py not found at {path}")
+        return
+    content = path.read_text(encoding="utf-8")
+    
+    # Locate CATEGORY_MAP dict block
+    map_pattern = re.compile(r'CATEGORY_MAP:\s*dict\[str,\s*dict\[str,\s*object\]\]\s*=\s*\{[^}]+(\}[^}]*)*\}', re.DOTALL)
+    
+    # Format CATEGORY_MAP dict
+    new_map_str = "CATEGORY_MAP: dict[str, dict[str, object]] = {\n"
+    for cat in sorted(NEW_CATEGORY_MAP.keys()):
+        val = NEW_CATEGORY_MAP[cat]
+        new_map_str += f'    "{cat}": ' + "{" + f'"layer": "{val["layer"]}", "level": {val["level"]}, "role": "{val["role"]}"' + "},\n"
+    new_map_str += "}"
+    
+    if map_pattern.search(content):
+        content = map_pattern.sub(new_map_str, content)
+        path.write_text(content, encoding="utf-8")
+        print(f"[+] Migrated db_manager.py CATEGORY_MAP!")
+    else:
+        print(f"[-] CATEGORY_MAP block not matched in db_manager.py")
+
+def migrate_connections(path: Path, defaults_path: Path):
+    if not path.exists():
+        print(f"[-] connections.py not found at {path}")
+        return
+    if not defaults_path.exists():
+        print(f"[-] defaults.py not found at {defaults_path} - cannot resolve dynamic tool layers")
+        return
+        
+    # Dynamically read tool_id -> layer from defaults.py
+    sys.path.insert(0, str(defaults_path.parent))
+    import defaults
+    tool_to_layer = {}
+    for tid, tool in defaults.DEFAULT_REGISTRY.items():
+        tool_to_layer[tid] = tool["layer"]
+        
+    content = path.read_text(encoding="utf-8")
+    
+    # Add DEFAULT_REGISTRY import to connections.py if missing
+    import_line = "from ai_lsc.registry.defaults import DEFAULT_REGISTRY"
+    if "import DEFAULT_REGISTRY" not in content and import_line not in content:
+        # Insert after absolute imports
+        content = "from ai_lsc.registry.defaults import DEFAULT_REGISTRY\n" + content
+        print("[+] Added DEFAULT_REGISTRY import to connections.py")
+
+    # Reorganize the StackWiring layer arguments in connections.py
+    blocks = content.split("_reg(StackWiring(")
+    new_blocks = [blocks[0]]
+    updated_count = 0
+    
+    for block in blocks[1:]:
+        tid_match = re.search(r"""tool_id\s*=\s*["']?([a-zA-Z0-9_-]+)["']?""", block)
+        if tid_match:
+            tid = tid_match.group(1)
+            if tid in tool_to_layer:
+                new_layer = tool_to_layer[tid]
+                # Replace layer="..." or layer='...'
+                block, count = re.subn(r"""layer\s*=\s*["|'][^"'\s]+["|']""", f'layer="{new_layer}"', block)
+                if count:
+                    updated_count += 1
+        new_blocks.append(block)
+        
+    content = "_reg(StackWiring(".join(new_blocks)
+    
+    # Convert hardcoded loops to look up the layer from the registry dynamically
+    # Example: layer="DevOps" inside loops -> layer=DEFAULT_REGISTRY[_tid]["layer"]
+    content, loops_updated = re.subn(
+        r"""layer\s*=\s*["'](?:DevOps|User Interfaces|Knowledge Management|Orchestrators|Host Platform|Development Environment|GPU Runtimes|Engines|Routing|Security|Observability)["']""",
+        'layer=DEFAULT_REGISTRY[_tid]["layer"]',
+        content
+    )
+    if loops_updated:
+        print(f"[+] Converted {loops_updated} loop-based StackWiring layers to dynamic lookups!")
+        
+    path.write_text(content, encoding="utf-8")
+    print(f"[+] Migrated connections.py! Rebuilt {updated_count} static tool-layer definitions.")
+
+def migrate_layers(layers_dir: Path, defaults_path: Path):
+    if not layers_dir.is_dir():
+        print(f"[-] Layers directory not found at {layers_dir}")
+        return
+    if not defaults_path.exists():
+        print(f"[-] defaults.py not found - cannot update layer files")
+        return
+        
+    import defaults
+    tool_to_layer = {}
+    tool_to_level = {}
+    for tid, tool in defaults.DEFAULT_REGISTRY.items():
+        tool_to_layer[tid] = tool["layer"]
+        tool_to_level[tid] = tool["level"]
+        
+    updated_files = 0
+    for path in layers_dir.glob("*.py"):
+        if path.name == "__init__.py":
+            continue
+        original = path.read_text(encoding="utf-8")
+        content = original
+        
+        # Replace level and layer for each tool inside the file
+        for tid in tool_to_layer:
+            # Look for block: 'tool_id': { or "tool_id": {
+            # we do a specific match and replace within that dict
+            tool_pattern = re.compile(rf"""["']{tid}["']\s*:\s*\{{[^}}]+}}""", re.DOTALL)
+            match = tool_pattern.search(content)
+            if match:
+                block = match.group(0)
+                # Replace level
+                block = re.sub(r'"level":\s*\d+', f'"level": {tool_to_level[tid]}', block)
+                # Replace layer
+                block = re.sub(r""""layer":\s*["|'][^"'\s]+["|']""", f'"layer": "{tool_to_layer[tid]}"', block)
+                content = content.replace(match.group(0), block)
+                
+        if content != original:
+            path.write_text(content, encoding="utf-8")
+            print(f"[+] Realigned tool layers & levels inside modular layer file: {path.name}")
+            updated_files += 1
+            
+    print(f"[+] Layer files update complete. Modified {updated_files} layer modules.")
+
+def main():
+    import sys
+    root = Path(__file__).resolve().parent
+    src_dir = root / "src"
+    
+    # Setup paths relative to root or src
+    constants_path = src_dir / "ai_lsc" / "constants.py"
+    db_manager_path = src_dir / "ai_lsc" / "ui" / "pages" / "db_manager.py"
+    connections_path = src_dir / "ai_lsc" / "stack" / "connections.py"
+    defaults_path = src_dir / "ai_lsc" / "registry" / "defaults.py"
+    layers_dir = src_dir / "ai_lsc" / "registry" / "layers"
+    
+    print("[*] Starting taxonomy migration sweeps...")
+    migrate_constants(constants_path)
+    migrate_db_manager(db_manager_path)
+    migrate_connections(connections_path, defaults_path)
+    migrate_layers(layers_dir, defaults_path)
+    print("[+] Entire codebase has been successfully upgraded to the 10-Layer Architecture!")
+
+if __name__ == "__main__":
+    main()

docs/REGISTRY-URLS-v3.3.0.md

@@ -0,0 +1,164 @@
+# Registry installer-URL sync — v3.3.0
+
+Source reference: `ai-stack-guide-v12.md` (systems-architect guide).
+Patched files: `src/ai_lsc/registry/layers/*.py`.
+Total installer URL corrections: **51** across 8 layer files.
+
+Five categories of patches:
+- **A** (28): git / git_node / custom installer `pkg` URL corrected to match the v12 markdown reference.
+- **B** (6): script-type installer gets a new `pkg` field added (the github repo), while the existing working `cmd` is left untouched.
+- **C** (10): registry-only git tools with no v12 markdown entry — official upstream repos found via web search.
+- **D** (3): type-mismatch fixes — md says git / git_node, registry had `uv` with a package name. Switched to git / git_node with the github URL from the v12 markdown reference.
+- **E** (4): user-provided URLs for the 4 previously-unresolved registry-only tools (web search could not find these; the user provided the official upstream URLs directly).
+
+Plus 1 new tool entry (ComfyUI) and a runtime hardening of `install_git` / `install_git_node` in `runtime/installer.py`.
+
+## `devops.py` (3 A/B/C patches)
+
+| Tool ID | Cat | Old `pkg` | New `pkg` |
+|---|---|---|---|
+| `opentofu` | A | `https://opentofu.org/docs/intro/install/` | `https://github.com/opentofu/opentofu` |
+| `terragrunt` | A | `https://terragrunt.gruntwork.io/docs/getting-started/install/` | `https://github.com/gruntwork-io/terragrunt` |
+| `crossplane` | C | `https://docs.crossplane.io/v2/getting-started/install/` | `https://github.com/crossplane/crossplane` |
+
+## `inference.py` (6 A/B/C patches)
+
+| Tool ID | Cat | Old `pkg` | New `pkg` |
+|---|---|---|---|
+| `airllm` | A | `https://github.com/liguodongiot/llm-airforce` | `https://github.com/lyogavin/airllm` |
+| `llamacpp` | A | `https://github.com/ggerganov/llama.cpp` | `https://github.com/ggml-org/llama.cpp` |
+| `locally_uncensored` | A | `https://github.com/nicely-done/locally-uncensored` | `https://github.com/PurpleDoubleD/locally-uncensored` |
+| `turbollm` | A | `https://github.com/nicely-done/turbollm` | `https://github.com/mohitsoni48/TurboLLM` |
+| `llamafile` | B | `(none)` | `https://github.com/Mozilla-Ocho/llamafile` |
+| `ollama` | B | `(none)` | `https://github.com/ollama/ollama` |
+
+## `knowledge_management.py` (10 A/B/C patches)
+
+| Tool ID | Cat | Old `pkg` | New `pkg` |
+|---|---|---|---|
+| `airweave` | A | `https://github.com/nicely-done/airweave` | `https://github.com/airweave-ai/airweave` |
+| `mirofish` | A | `https://github.com/nicely-done/mirofish` | `https://github.com/666ghj/MiroFish` |
+| `opendataloader` | A | `https://github.com/nicely-done/opendataloader` | `https://github.com/opendataloader-project/opendataloader-pdf` |
+| `opendataloader_pdf` | A | `https://github.com/nicely-done/opendataloader-pdf` | `https://github.com/opendataloader-project/opendataloader-pdf` |
+| `understand_anything` | A | `https://github.com/nicely-done/understand-anything` | `https://github.com/Egonex-AI/Understand-Anything` |
+| `meilisearch` | B | `(none)` | `https://github.com/meilisearch/meilisearch` |
+| `qdrant` | B | `(none)` | `https://github.com/qdrant/qdrant` |
+| `everos_memory` | C | `https://github.com/nicely-done/everos-memory` | `https://github.com/EverMind-AI/EverOS` |
+| `mnemo_cortex` | C | `https://github.com/nicely-done/mnemo-cortex` | `https://github.com/GuyMannDude/mnemo-cortex` |
+| `turbovec` | C | `https://github.com/nicely-done/turbovec` | `https://github.com/ryancodrai/turbovec` |
+
+## `observability.py` (4 A/B/C patches)
+
+| Tool ID | Cat | Old `pkg` | New `pkg` |
+|---|---|---|---|
+| `latitude` | A | `https://github.com/nicely-done/latitude` | `https://github.com/latitude-dev/latitude-llm` |
+| `pulse_ai` | A | `https://github.com/nicely-done/pulse-ai` | `https://github.com/glieai/pulse-ai` |
+| `grafana_alloy` | B | `(none)` | `https://github.com/grafana/alloy` |
+| `dma` | C | `https://github.com/distcc/dma` | `https://github.com/distcc/distcc` |
+
+## `orchestrators.py` (15 A/B/C patches)
+
+| Tool ID | Cat | Old `pkg` | New `pkg` |
+|---|---|---|---|
+| `agentic_os` | A | `https://github.com/nicely-done/agentic-os` | `https://github.com/aporb/agentic-os` |
+| `career_ops` | A | `https://github.com/nicely-done/career_ops` | `https://github.com/santifer/career-ops` |
+| `container_tool` | A | `https://github.com/nicely-done/container_tool` | `https://github.com/NVIDIA/nvidia-container-toolkit` |
+| `hivemind` | A | `https://github.com/nicely-done/hivemind` | `https://github.com/hivementality-ai/hivemind` |
+| `loop_engineering` | A | `https://github.com/nicely-done/loop_engineering` | `https://github.com/lcajigasm/loop-engineering` |
+| `opensandbox` | A | `https://github.com/nicely-done/opensandbox` | `https://github.com/opensandbox-group/OpenSandbox` |
+| `ponytail` | A | `https://github.com/nicely-done/ponytail` | `https://github.com/DietrichGebert/ponytail` |
+| `promptops` | A | `https://github.com/nicely-done/promptops` | `https://github.com/llmhq-hub/promptops` |
+| `skillspector` | A | `https://github.com/nicely-done/skillspector` | `https://github.com/NVIDIA/skillspector` |
+| `spec_kit` | A | `https://github.com/nicely-done/spec_kit` | `https://github.com/github/spec-kit` |
+| `fabric` | B | `(none)` | `https://github.com/danielmiessler/fabric` |
+| `agent_reach` | C | `https://github.com/nicely-done/agent_reach` | `https://github.com/Panniantong/Agent-Reach` |
+| `headroom` | C | `https://github.com/nicely-done/headroom` | `https://github.com/headroomlabs-ai/headroom` |
+| `nightshift` | C | `https://github.com/nicely-done/nightshift` | `https://github.com/johndaskovsky/nightshift` |
+| `openbrain` | C | `https://github.com/nicely-done/openbrain` | `https://github.com/NateBJones-Projects/OB1` |
+
+## `routing.py` (1 A/B/C patches)
+
+| Tool ID | Cat | Old `pkg` | New `pkg` |
+|---|---|---|---|
+| `9router_proxy` | A | `https://github.com/nicely-done/9router` | `https://github.com/decolua/9router` |
+
+## `security.py` (1 A/B/C patches)
+
+| Tool ID | Cat | Old `pkg` | New `pkg` |
+|---|---|---|---|
+| `keycloak` | C | `keycloak` | `https://github.com/keycloak/keycloak` |
+
+## `user_interfaces.py` (4 A/B/C patches)
+
+| Tool ID | Cat | Old `pkg` | New `pkg` |
+|---|---|---|---|
+| `deep_eye` | A | `https://github.com/nicely-done/deep-eye` | `https://github.com/zakirkun/deep-eye` |
+| `forge` | A | `https://github.com/AUTOMATIC1111/stable-diffusion-webui-forge` | `https://github.com/lllyasviel/stable-diffusion-webui-forge` |
+| `local_llm_launcher` | A | `https://github.com/nicely-done/local-llm-launcher-gui` | `https://github.com/jimdawdy-hub/Local-LLM-Launcher-GUI` |
+| `parakeet` | A | `https://github.com/nicely-done/parakeet.cpp` | `https://github.com/mudler/parakeet.cpp` |
+
+## Category D — type-mismatch fixes (3 patches)
+
+These tools were registered as `uv` package-manager installs but the v12 markdown reference (which the user manually tested) lists them as `git` or `git_node`. Switched to git / git_node type with the github URL.
+
+| Tool ID | Source file | Old type / pkg | New type / pkg |
+|---|---|---|---|
+| `pm_skills` | `orchestrators.py` | `uv` / (package name) | `git` / `https://github.com/product-on-purpose/pm-skills` |
+| `agno` | `orchestrators.py` | `uv` / (package name) | `git` / `https://github.com/agno-agi/agno` |
+| `openhands` | `devops.py` | `uv` / (package name) | `git_node` / `https://github.com/All-Hands-AI/OpenHands.git` |
+
+## Category E — user-provided URLs (4 patches)
+
+These 4 registry-only tools had placeholder `github.com/nicely-done/...` URLs because web search could not find their official upstreams.  The user provided the official URLs directly:
+
+| Tool ID | Source file | Old `pkg` (placeholder) | New `pkg` (user-provided) |
+|---|---|---|---|
+| `algory` | `orchestrators.py` | `https://github.com/nicely-done/algory` | `https://github.com/aryaghan-mutum/algory` |
+| `atlas_os` | `orchestrators.py` | `https://github.com/nicely-done/atlas_os` | `https://github.com/atlas-os/atlas` |
+| `eagle_eye` | `observability.py` | `https://github.com/nicely-done/eagle_eye` | `https://github.com/thoughtfuldev/eagleeye` |
+| `glassmind` | `orchestrators.py` | `https://github.com/nicely-done/glassmind` | `https://github.com/khodges42/glassMind` |
+
+## New tool entry — ComfyUI
+
+ComfyUI was referenced in `registry/stack_templates/ai-image-gen-local.json` but had no registry entry before.  Added as a Level 10 tool in `user_interfaces.py`:
+
+| Field | Value |
+|---|---|
+| `tool_id` | `comfyui` |
+| `name` | `ComfyUI` |
+| `level` | 10 |
+| `layer` | `Human Interface & System Operations` |
+| `role` / `category` | `Node-Based Image Gen` |
+| `installer.type` | `git` |
+| `installer.pkg` | `https://github.com/comfy-org/comfyui` |
+| `launcher.cmd` | `cd {tools_root}/comfyui && python main.py --listen 0.0.0.0 --port {port}` |
+| `launcher.default_port` | `8188` |
+| `deps` | `[cuda]` |
+| `license` | `GPL-3.0` |
+
+Total registry size: 187 tools (was 186).
+
+## Runtime hardening — `runtime/installer.py`
+
+`install_git` and `install_git_node` were hardened so that re-running install on an already-cloned tool fetches only the diff:
+
+1. **Check `.git` dir, not just `dest` dir.** Previously the existence check was `os.path.exists(dest)`, which is True for any dir — including non-git dirs.  Now checks `os.path.isdir(dest/.git)`, so a non-git dir doesn't cause `git pull` to fail.
+2. **Fall back to re-clone on pull failure.** If `git pull --ff-only` fails (diverged branches, network errors, corrupted index, etc.), the old dir is moved aside to `<dest>.bak.<unix_ts>` and a fresh clone is made.  The install always ends in a usable state.
+3. **Back up existing non-git dir.** If `dest` exists but isn't a git repo, it's backed up to `<dest>.bak.<unix_ts>` and a fresh clone is made.
+4. **Log which path was taken.** The return message says whether the tool was pulled, re-cloned (with backup path), or freshly cloned — so the user can see what happened.
+
+Effect: re-running install on a tool that's already cloned only fetches the diff (a few KB / MB), not the entire repo.  This is the bandwidth-saving behaviour the user asked for.
+
+## Verification
+
+All 51 patches applied successfully:
+- 28 git-ish pkg URL replacements (each old `pkg` string was unique within its file and matched exactly once).
+- 6 script-type pkg-field injections (each matched exactly one installer block).
+- 10 missing-repo lookups via web search.
+- 3 type-mismatch fixes (uv → git / git_node).
+- 4 user-provided URLs for previously-unresolved tools.
+- 1 new ComfyUI tool entry added to `user_interfaces.py`.
+
+All 94 Python files under `src/` AST-parse cleanly after the patches. The registry extractor re-imports every layer module and confirms all 51 patches landed + the new ComfyUI entry.  Total registry size: 187 tools (was 186).
+
+0 `nicely-done` placeholder URLs remain in the registry.

gitcommit

@@ -1,114 +1,126 @@
-AI-LSC Release v3.0 -- codename: Ankh of Jah
+AI-LSC Release v3.3.0
 
-Full architectural rewrite from v2.4. This is not an incremental
+Registry git-pull URL sync against the systems-architect reference
-release; the project fundamentally changed structure, scope, and
+(ai-stack-guide-v12.md, "Approaching the Local AI Stack Like a Systems
-design philosophy.
+Architect") + bandwidth-aware git-pull-on-update logic for already-cloned
+tools + new ComfyUI registry entry. 52 patches across 8 layer files plus
+a runtime/installer.py hardening.
 
-v2.4 was a monolithic tool launcher.
+Five categories of installer-URL patches:
-v3.0 is a metadata-driven infrastructure management platform.
 
-What changed:
+A. git / git_node / custom installer `pkg` URLs corrected to match the
+   v12 markdown reference (28 patches). The previous registry was
+   pointing at placeholder repos (``github.com/nicely-done/...``) or at
+   wrong upstreams (e.g. ``airllm`` at ``liguodongiot/llm-airforce``,
+   ``llamacpp`` at ``ggerganov/llama.cpp`` instead of ``ggml-org/llama.cpp``).
 
-Architecture
+B. script-type installers (fabric, grafana_alloy, llamafile, meilisearch,
-  - Migrated from flat script layout to src/ai_lsc/ package with 22
+   ollama, qdrant) get a new ``pkg`` field added referencing the github
-    core modules, 13 registry layer files, and clean separation of
+   repo, while the existing working ``cmd`` (curl release tarball, etc.)
-    concerns (registry, runtime, stack, skills, agents, ui)
+   is left untouched (6 patches).
-  - Introduced AI_LSC_BASE_DIR env var chain: bootstrap writes .env,
-    launcher reads it, constants.py resolves it -- entire runtime
-    derives from one variable. No hardcoded paths leak outside constants.
-  - ADR-001 established: Capability as the foundational abstraction.
-    Every subsystem (templates, pipelines, skills, containers,
-    dashboards, monitoring) points at Capability. Tool is a
-    implementation detail. Swap Ollama for vLLM -- nothing above the
-    registry notices. See docs/ADR-001-capability-architecture.md.
 
-Registry
+C. registry-only git tools with no v12 markdown entry were resolved
-  - 115 registered tools organized across 13 infrastructure layers
+   via web search to their official upstreams (10 patches):
-    (Host Platform -> Containers). Each entry carries full metadata:
+     - agent_reach    -> Panniantong/Agent-Reach
-    installer, launcher, health probe, configuration, export rules,
+     - everos_memory  -> EverMind-AI/EverOS
-    capability mapping.
+     - headroom       -> headroomlabs-ai/headroom
-  - Modular per-layer registry: ai_lsc/registry/layers/*.py -- adding a
+     - mnemo_cortex   -> GuyMannDude/mnemo-cortex
-    tool means adding a dict entry, not touching Python logic.
+     - nightshift     -> johndaskovsky/nightshift
-  - Registry auto-merges new keys across releases without user action.
+     - openbrain      -> NateBJones-Projects/OB1
+     - turbovec       -> ryancodrai/turbovec
+     - crossplane     -> crossplane/crossplane
+     - keycloak       -> keycloak/keycloak
+     - dma            -> distcc/distcc (closest parent)
 
-Stack Templates
+D. type-mismatch fixes (3 patches): the v12 markdown lists these 3
-  - Template system expresses infrastructure intent, not install scripts.
+   tools with installer type `git` or `git_node`. The user manually
-  - 4 included templates (Claude Code Setup, Agentic OS Stack,
+   tested every entry in the md before publishing it; the registry
-    SaaS Integrations, Free Claude Code).
+   had them as `uv` package-manager installs, which would have
-  - Templates reference tool IDs; the registry provides all install and
+   called `uv tool install <pkg>` against PyPI — wrong for tools that
-    launch logic. Zero duplication.
+   are installed by cloning their github repo:
-  - Stack Wizard UI for template selection and deployment.
+     - pm_skills : uv:pm-skills    -> git:https://github.com/product-on-purpose/pm-skills
+     - agno      : uv:agno         -> git:https://github.com/agno-agi/agno
+     - openhands : uv:openhands-ai -> git_node:https://github.com/All-Hands-AI/OpenHands.git
 
-Runtime
+E. user-provided URLs for the 4 previously-unresolved registry-only
-  - Multi-runtime execution: native, Podman, Docker Compose, LXC.
+   tools (4 patches).  These tools had placeholder
-  - RuntimeExecutor unifies install/start/stop/health across all targets.
+   `github.com/nicely-done/<tid>` URLs; the user provided the
-  - Container export generates Podman Quadlet, Docker Compose, or LXC
+   official upstream URLs directly:
-    config from a template -- same template, different output format.
+     - algory    -> aryaghan-mutum/algory
-  - Fixed LXC config path bug (Path string concat) and hardcoded
+     - atlas_os  -> atlas-os/atlas
-    /mnt/AI mount targets.
+     - eagle_eye -> thoughtfuldev/eagleeye
+     - glassmind -> khodges42/glassMind
 
-Bootstrap
+New tool entry (1):
-  - Fully portable: extracts anywhere, detects parent directory tree,
+  - comfyui (user_interfaces.py):  ComfyUI was referenced in the
-    auto-resolves base dir. No assumptions about install location.
+    `ai-image-gen-local.json` stack template but had no registry
-  - Arch Linux: --system-site-packages venv sees pacman-installed
+    entry.  Added as a Level 10 (Human Interface & System Operations)
-    PySide6, avoids pip compile hell.
+    tool with installer `git:https://github.com/comfy-org/comfyui`,
-  - Python version stamping detects stale venv after pacman -Syu,
+    launcher `python main.py --listen 0.0.0.0 --port 8188`,
-    auto-recreates.
+    deps [cuda], license GPL-3.0.  Total registry size is now 187
-  - Cleans stale ~/.local/bin/ai-lsc and pipx installs from v2.x.
+    tools (was 186).
-  - python-pyside6 availability check before attempting pacman install
-    (package not in official Arch repos).
 
-Installer
+Runtime: bandwidth-aware git-pull-on-update (runtime/installer.py)
-  - Supports pacman, apt, dnf, pip, git clone, npm, and manual installers.
-  - Dependency expansion: installing a template auto-detects and installs
-    missing prerequisite tools.
-  - License gate: tools requiring license acceptance prompt before install.
 
-Verification
+  The existing install_git / install_git_node methods already did
-  - Per-tool health probes: process check, port check, API ping.
+  `git pull --ff-only` if the destination dir existed, but the check
-  - Verification dashboard shows install status for all 115 tools.
+  was `os.path.exists(dest)` — which is True for any dir, not just a
-  - Hardware detection: GPU driver, CUDA version, memory, disk.
+  git working tree.  An empty or non-git dir at the destination would
+  cause `git pull` to fail and abort the install.  Hardened to:
 
-UI
+  1. Check `os.path.isdir(dest/.git)` to confirm a real git repo.
-  - PySide6 dark-themed interface with sidebar navigation across all
+  2. On pull failure (diverged branches, network errors, corrupted
-    13 layers.
+     index, etc.), move the old dir aside to `<dest>.bak.<unix_ts>`
-  - Dashboard with live service status, log feed, and system health.
+     and re-clone fresh — so the install always ends in a usable
-  - Infrastructure layer pages with per-tool ServiceRow widgets.
+     state instead of leaving a half-broken tree.
-  - Code analysis panel: ripgrep, fd, AST inspection, tree-sitter parsing.
+  3. If the dest dir exists but is not a git repo, back it up and
-  - Skills console with modelfile tree browser and model pull.
+     clone fresh.
-  - IPC stack editor for pipeline visualization.
+  4. Log clearly which path was taken (pulled / re-cloned / new clone
-  - Settings page with base directory configuration.
+     / non-git-dir backed up) so the user can see what happened.
-  - Fixed 8 NameError crashes in exception handlers (except without as).
-  - Fixed thread-unsafe UI mutation from background install thread.
-  - Fixed stack wizard KeyError on missing metadata fields.
 
-Skills
+  Effect: re-running install on a tool that's already cloned only
-  - Skill definitions as JSON manifests with capability requirements.
+  fetches the diff (a few KB / MB), not the entire repo.
-  - SkillRuntimeResolver maps skill requests to available capabilities.
-  - 6 included skills (code-reviewer, vector-search, rag-analyst,
-    stack-operator, agent-orchestrator, redis-operator).
 
-Agents (infrastructure only -- deferred to v4.0)
+Intentionally NOT touched:
-  - Redis pub/sub bridge for inter-agent communication.
+  - apex (md says `pip — https://github.com/NVIDIA/apex`): kept as
-  - Tool bridge connecting agent function-calling to RuntimeExecutor.
+    uv:apex (pip-installed).  The md's `pip` installer type is
-  - Ollama tools interface for model management.
+    authoritative and the user did not call this one out.
-  - Model pool with tier routing (8B/14B/32B/70B).
+  - 12 git-ish installers that already matched the v12 reference
-  - Dispatcher and clarification gate for multi-turn agent loops.
+    (anythingllm, dify, heretic, homelab, invokeai, koboldcpp,
-  - All symbols safely stubbed; no agent execution in v3.0.
+    librechat, mcp_drift_state_tracker, openjarvis, paperlessngx,
+    synapscli, wayland_ai).
+  - 3 registry-only git tools with real-looking URLs already in
+    place (goose -> block/goose, nvidia_agent_skills ->
+    NVIDIA/agent-skills, picode -> jasonjmcghee/picode.git).
+  - APP_CODENAME ("Decalogue") and all historical codename
+    references in docstrings / UI labels / README banner / bootstrap
+    banner — left as-is per user's clarification.
 
-Bug fixes from v2.4
+All 0 placeholder `github.com/nicely-done/...` URLs have been
-  - Resolved externally-managed-environment error on Arch (venv isolation)
+removed from the registry.
-  - Removed ModuleNotFoundError from stale ~/.local/bin/ai-lsc entry point
-  - Root launcher (ai_lsc.py) replaces pip entry-point -- no install needed
-  - Convenience launcher (run.sh) sources .env for proper env injection
-  - Path("/var/lib/lxc" / name) string concat crash -> proper Path join
-  - 8x except Exception without as exc -> all now capture correctly
-  - Thread-unsafe _run_install UI calls -> QTimer.singleShot dispatch
-  - Hardcoded /mnt/AI LXC mount targets -> dynamic path resolution
-  - Stack wizard meta['name'] KeyError -> .get() with safe defaults
-  - python-pyside6 pacman fallback for Arch repos that don't carry it
 
-Files changed: essentially everything. See ADR-001 for the architectural
+Versioning:
-rationale and the vocabulary that will govern v3.0 stabilization and
+  - pyproject.toml: 3.2.0 -> 3.3.0
-v4.0 development.
+  - src/ai_lsc/constants.py: APP_VERSION 3.2.0 -> 3.3.0
-```
+    (APP_CODENAME unchanged: "Decalogue")
+  - docs/REGISTRY-URLS-v3.3.0.md: per-file old -> new URL table.
+
+Verification:
+  - All 94 Python files under src/ AST-parse cleanly.
+  - Registry extractor re-reads the patched tree and confirms all 52
+    patches landed + the new ComfyUI entry.  Total tools: 187 (was
+    186).
+  - Each old `pkg` URL string was unique within its file and matched
+    exactly once during the patch — no blind global replaces.
+  - install_git / install_git_node hardened: the new logic
+    branches on `os.path.isdir(.git)`, falls back to re-clone on pull
+    failure, and uses `import time` for backup-dir timestamps.  All
+    confirmed present in installer.py.
+  - 0 `nicely-done` placeholder URLs remain in the registry.
+
+Layer ladder (unchanged from v3.2):
+  L1  Host Platform & Infrastructure          L6  Multi-Agent Orchestration Runtimes
+  L2  Development Runtime & Environment       L7  Agentic Software Engineering & Sandboxes
+  L3  GPU Acceleration & Optimization         L8  Decentralized Knowledge & Vector Stores
+  L4  Local Inference Engines                 L9  Data Extraction & Pipeline Harvest
+  L5  Intelligent API Routers & Proxies       L10 Human Interface & System Operations

pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ai-lsc"
-version = "3.1.1"
+version = "3.3.0"
 description = "AI Local Stack Control — PySide6 desktop app for orchestrating local AI/ML tool stacks"
 readme = "README.md"
 license = {text = "AGPL-3.0-or-later"}

quickstart.md

@@ -249,7 +249,7 @@ for f in os.listdir('ai_lsc/registry/layers'):
 
 ## Next Steps
 
-- Explore the **Infrastructure** section to understand the 13-layer architecture
+- Explore the **Infrastructure** section to understand the 10-layer architecture
 - Try different **Stack Templates** to find the right combination for your workflow
 - Set up the **Skills Console** to extend your tool capabilities
 - Use **Code Analysis** to inspect and understand your project dependencies

scripts/apply_10layer_taxonomy.py

@@ -0,0 +1,913 @@
+#!/usr/bin/env python3
+"""Finish the 10-Layer Systems Architecture Taxonomy migration for AI-LSC.
+
+This is the corrected, completed version of the partial migration that was
+started in the repo root ``apply_taxonomy_migration.py`` (which had defect
+fixes needed: regexes that could not match multi-word layer names, a ``sys``
+scoping bug, lossy installer handling, and no ``defaults.py`` install).
+
+Stages
+------
+1. defaults   — build the new 108-tool ``defaults.py``: taxonomy fields
+                (level/layer/role/category) + richer descriptions from the
+                master-target registry; operational fields (installer,
+                launcher, deps, flags, license, filesystem) preserved from
+                the previous registry.
+2. layers     — realign the 11 modular layer files (185 tools) to the
+                10-layer taxonomy; classify the 78 tools absent from the
+                master registry; reconcile ``kanban`` into the layer files.
+3. wiring     — migrate ``stack/connections.py``: static layer= values get
+                their new-layer names; loop-based bulk allocations become
+                dynamic registry lookups (with a supplement for wired tools
+                outside DEFAULT_REGISTRY).
+4. categorymap— extend the db_manager CATEGORY_MAP (+ reference file) so
+                the categorisation cascade covers every registry category.
+5. docfixes   — validator level range, stale header comments.
+
+Run from the repo root of the tree being migrated:
+    python3 scripts/migrate_10layer.py --new-defaults /path/to/new/defaults.py [stage...]
+"""
+
+from __future__ import annotations
+
+import argparse
+import importlib.util
+import re
+import sys
+from pathlib import Path
+
+REPO = Path.cwd().resolve()                             # tree being migrated
+SRC = REPO / "src"
+
+NEW_LAYERS = [
+    "Host Platform & Infrastructure",
+    "Development Runtime & Environment",
+    "GPU Acceleration & Optimization",
+    "Local Inference Engines",
+    "Intelligent API Routers & Proxies",
+    "Multi-Agent Orchestration Runtimes",
+    "Agentic Software Engineering & Sandboxes",
+    "Decentralized Knowledge & Vector Stores",
+    "Data Extraction & Pipeline Harvest",
+    "Human Interface & System Operations",
+]
+LAYER_LEVEL = {name: i + 1 for i, name in enumerate(NEW_LAYERS)}
+
+# Classification of the 78 modular-layer tools that are absent from the
+# 108-tool master registry.  Assignments follow the 10-layer philosophy:
+#   L1  foundational daemons (data, isolation, edge, identity, secrets)
+#   L2  runtimes, compilers, build, debug, shells, VCS
+#   L6  agent coordination / reasoning / workflow frameworks
+#   L7  agentic software engineering (coding agents, code skills)
+#   L8  agent memory + vector/graph stores
+#   L10 human interfaces, telemetry, IaC, cluster + security operations
+TOOL_CLASSIFICATION: dict[str, str] = {
+    # L1 — Host Platform & Infrastructure
+    "certbot": "Host Platform & Infrastructure",
+    "cloudflared": "Host Platform & Infrastructure",
+    "nginx": "Host Platform & Infrastructure",
+    "docker": "Host Platform & Infrastructure",
+    "podman": "Host Platform & Infrastructure",
+    "lxc": "Host Platform & Infrastructure",
+    "firecracker": "Host Platform & Infrastructure",
+    "qemu": "Host Platform & Infrastructure",
+    "libvirt": "Host Platform & Infrastructure",
+    "tmux": "Host Platform & Infrastructure",
+    "keycloak": "Host Platform & Infrastructure",
+    "vault": "Host Platform & Infrastructure",
+    "fail2ban": "Host Platform & Infrastructure",
+    # L2 — Development Runtime & Environment
+    "bash": "Development Runtime & Environment",
+    "fish": "Development Runtime & Environment",
+    "zsh": "Development Runtime & Environment",
+    "mksh": "Development Runtime & Environment",
+    "git": "Development Runtime & Environment",
+    "deno": "Development Runtime & Environment",
+    "go": "Development Runtime & Environment",
+    "java_jdk": "Development Runtime & Environment",
+    "julia": "Development Runtime & Environment",
+    "nodejs": "Development Runtime & Environment",
+    "perl": "Development Runtime & Environment",
+    "php": "Development Runtime & Environment",
+    "ruby": "Development Runtime & Environment",
+    "rust": "Development Runtime & Environment",
+    "gcc": "Development Runtime & Environment",
+    "make": "Development Runtime & Environment",
+    "cmake": "Development Runtime & Environment",
+    "bison": "Development Runtime & Environment",
+    "fakeroot": "Development Runtime & Environment",
+    "patchelf": "Development Runtime & Environment",
+    "pkg_config": "Development Runtime & Environment",
+    "upx": "Development Runtime & Environment",
+    "uv": "Development Runtime & Environment",
+    "gdb": "Development Runtime & Environment",
+    "ltrace": "Development Runtime & Environment",
+    "strace": "Development Runtime & Environment",
+    "valgrind": "Development Runtime & Environment",
+    "distcc": "Development Runtime & Environment",
+    "dma": "Development Runtime & Environment",
+    # L3 — GPU Acceleration & Optimization
+    "tinygrad": "GPU Acceleration & Optimization",
+    # L4 — Local Inference Engines
+    "sglang": "Local Inference Engines",
+    # L5 — Intelligent API Routers & Proxies
+    "meshllm": "Intelligent API Routers & Proxies",
+    # L6 — Multi-Agent Orchestration Runtimes
+    "agent_reach": "Multi-Agent Orchestration Runtimes",
+    "algory": "Multi-Agent Orchestration Runtimes",
+    "atlas_os": "Multi-Agent Orchestration Runtimes",
+    "glassmind": "Multi-Agent Orchestration Runtimes",
+    "headroom": "Multi-Agent Orchestration Runtimes",
+    "honcho": "Multi-Agent Orchestration Runtimes",
+    "letta": "Multi-Agent Orchestration Runtimes",
+    "nightshift": "Multi-Agent Orchestration Runtimes",
+    "nvidia_agent_skills": "Multi-Agent Orchestration Runtimes",
+    "odysseus": "Multi-Agent Orchestration Runtimes",
+    "openbrain": "Multi-Agent Orchestration Runtimes",
+    "ray": "Multi-Agent Orchestration Runtimes",
+    # L7 — Agentic Software Engineering & Sandboxes
+    "gemini_cli": "Agentic Software Engineering & Sandboxes",
+    "goose": "Agentic Software Engineering & Sandboxes",
+    "opencode": "Agentic Software Engineering & Sandboxes",
+    "qwen_code": "Agentic Software Engineering & Sandboxes",
+    "zcoder": "Agentic Software Engineering & Sandboxes",
+    "picode": "Agentic Software Engineering & Sandboxes",
+    "graphify": "Agentic Software Engineering & Sandboxes",
+    # L8 — Decentralized Knowledge & Vector Stores
+    "everos_memory": "Decentralized Knowledge & Vector Stores",
+    "mem0": "Decentralized Knowledge & Vector Stores",
+    "mnemo_cortex": "Decentralized Knowledge & Vector Stores",
+    "turbovec": "Decentralized Knowledge & Vector Stores",
+    # L10 — Human Interface & System Operations
+    "hermes_webui": "Human Interface & System Operations",
+    "jan": "Human Interface & System Operations",
+    "btop": "Human Interface & System Operations",
+    "eagle_eye": "Human Interface & System Operations",
+    "crossplane": "Human Interface & System Operations",
+    "pssh": "Human Interface & System Operations",
+    "n8n": "Human Interface & System Operations",
+    "clamav": "Human Interface & System Operations",
+    "trivy": "Human Interface & System Operations",
+    "opa": "Human Interface & System Operations",
+}
+
+# Categories added to the CATEGORY_MAP cascade for the classified tools
+# (category -> layer).  Role mirrors the category, per existing convention.
+EXTRA_CATEGORY_LAYERS: dict[str, str] = {
+    "VCS": "Development Runtime & Environment",
+    "Shell": "Development Runtime & Environment",
+    "Runtime": "Development Runtime & Environment",
+    "Build": "Development Runtime & Environment",
+    "Build Monitoring": "Development Runtime & Environment",
+    "Distributed Compilation": "Development Runtime & Environment",
+    "Debugging": "Development Runtime & Environment",
+    "Terminal": "Host Platform & Infrastructure",
+    "Networking": "Host Platform & Infrastructure",
+    "Containers": "Host Platform & Infrastructure",
+    "Virtualization": "Host Platform & Infrastructure",
+    "Auth": "Host Platform & Infrastructure",
+    "Secrets Management": "Host Platform & Infrastructure",
+    "Intrusion Prevention": "Host Platform & Infrastructure",
+    "Antivirus": "Human Interface & System Operations",
+    "Container Security": "Human Interface & System Operations",
+    "Policy Engine": "Human Interface & System Operations",
+    "IaC Control Plane": "Human Interface & System Operations",
+    "Cluster SSH": "Human Interface & System Operations",
+    "Project Management": "Human Interface & System Operations",
+    "Workflow Automation": "Multi-Agent Orchestration Runtimes",
+    "Multi-Agent": "Multi-Agent Orchestration Runtimes",
+    "AI Agent": "Multi-Agent Orchestration Runtimes",
+    "Agent OS": "Multi-Agent Orchestration Runtimes",
+    "Agent Toolkit": "Multi-Agent Orchestration Runtimes",
+    "Agent Framework": "Multi-Agent Orchestration Runtimes",
+    "Reasoning Engine": "Multi-Agent Orchestration Runtimes",
+    "Agent Workflow": "Multi-Agent Orchestration Runtimes",
+    "Infrastructure": "Multi-Agent Orchestration Runtimes",
+    "Distributed Compute": "Multi-Agent Orchestration Runtimes",
+    "AI Coding Agent": "Agentic Software Engineering & Sandboxes",
+    "Claude Code Skill": "Agentic Software Engineering & Sandboxes",
+    "Mesh Client": "Agentic Software Engineering & Sandboxes",
+    "LLM Mesh": "Intelligent API Routers & Proxies",
+    "LLM Serving": "Local Inference Engines",
+    "Persistent Memory": "Decentralized Knowledge & Vector Stores",
+    "Memory System": "Decentralized Knowledge & Vector Stores",
+    "Cortex Memory": "Decentralized Knowledge & Vector Stores",
+    "Chat Frontend": "Human Interface & System Operations",
+    "LLM GUI": "Human Interface & System Operations",
+    "Metrics": "Human Interface & System Operations",
+    "Observability": "Human Interface & System Operations",
+}
+
+# The v3.1.1b db_manager (restored from the routing tarball) carries a
+# richer 124-category cascade than the master target's 103-category map.
+# These alt-only categories are preserved and translated to the 10-layer
+# taxonomy so the categorisation cascade keeps its full coverage.
+ALT_CATEGORY_TRANSLATIONS: dict[str, str] = {
+    "AI Assistant Platform": "Human Interface & System Operations",
+    "AI Augmentation": "Multi-Agent Orchestration Runtimes",
+    "AI Monitoring": "Human Interface & System Operations",
+    "AI Observability": "Human Interface & System Operations",
+    "AI Operating System": "Multi-Agent Orchestration Runtimes",
+    "Academic References": "Human Interface & System Operations",
+    "Agent Network": "Multi-Agent Orchestration Runtimes",
+    "Algorithm Toolkit": "Multi-Agent Orchestration Runtimes",
+    "Audio Parsing": "Data Extraction & Pipeline Harvest",
+    "Chat": "Human Interface & System Operations",
+    "Chat Agent Platform": "Human Interface & System Operations",
+    "Code Analysis": "Agentic Software Engineering & Sandboxes",
+    "Code Generation": "Agentic Software Engineering & Sandboxes",
+    "Computer Vision": "Data Extraction & Pipeline Harvest",
+    "Config Management": "Human Interface & System Operations",
+    "Container Ops": "Host Platform & Infrastructure",
+    "Context Manager": "Agentic Software Engineering & Sandboxes",
+    "Dashboard": "Human Interface & System Operations",
+    "Data Pipeline": "Data Extraction & Pipeline Harvest",
+    "Data Sync": "Data Extraction & Pipeline Harvest",
+    "Desktop Agent": "Human Interface & System Operations",
+    "Dev Automation": "Agentic Software Engineering & Sandboxes",
+    "Development": "Agentic Software Engineering & Sandboxes",
+    "Document Converter": "Data Extraction & Pipeline Harvest",
+    "Document Management": "Human Interface & System Operations",
+    "Document Understanding": "Data Extraction & Pipeline Harvest",
+    "Ebook Library": "Human Interface & System Operations",
+    "Ecosystem Dashboard": "Human Interface & System Operations",
+    "Efficient LLM": "Local Inference Engines",
+    "File Parsing": "Data Extraction & Pipeline Harvest",
+    "Find Tool": "Development Runtime & Environment",
+    "GPU": "GPU Acceleration & Optimization",
+    "Graph RAG": "Decentralized Knowledge & Vector Stores",
+    "Homepage": "Human Interface & System Operations",
+    "IaC": "Human Interface & System Operations",
+    "IaC Wrapper": "Human Interface & System Operations",
+    "Image Generation": "Human Interface & System Operations",
+    "Knowledge Graph": "Decentralized Knowledge & Vector Stores",
+    "Knowledge Graph Notes": "Human Interface & System Operations",
+    "LLM Evaluation": "Human Interface & System Operations",
+    "LLM Fine-tuning": "GPU Acceleration & Optimization",
+    "LLM Framework": "Multi-Agent Orchestration Runtimes",
+    "LLM Router": "Intelligent API Routers & Proxies",
+    "LLM Runtime": "Local Inference Engines",
+    "MCP Server": "Agentic Software Engineering & Sandboxes",
+    "Model Training": "GPU Acceleration & Optimization",
+    "Notes": "Human Interface & System Operations",
+    "OCI Export": "Host Platform & Infrastructure",
+    "Outliner": "Human Interface & System Operations",
+    "PDF Pipeline": "Data Extraction & Pipeline Harvest",
+    "Parser": "Development Runtime & Environment",
+    "Pipeline": "Intelligent API Routers & Proxies",
+    "Procfile Runner": "Multi-Agent Orchestration Runtimes",
+    "Prompt Tooling": "Agentic Software Engineering & Sandboxes",
+    "Provisioning": "Human Interface & System Operations",
+    "Proxy": "Intelligent API Routers & Proxies",
+    "Sandbox": "Host Platform & Infrastructure",
+    "Search Engine": "Decentralized Knowledge & Vector Stores",
+    "Search Tool": "Development Runtime & Environment",
+    "Serverless Framework": "Development Runtime & Environment",
+    "Single-File LLM": "Local Inference Engines",
+    "Skill Analysis": "Agentic Software Engineering & Sandboxes",
+    "Skill Inspection": "Agentic Software Engineering & Sandboxes",
+    "Spaced Repetition": "Human Interface & System Operations",
+    "Spec Writer": "Agentic Software Engineering & Sandboxes",
+    "Speech Recognition": "Data Extraction & Pipeline Harvest",
+    "Task Runner": "Human Interface & System Operations",
+    "Telemetry": "Human Interface & System Operations",
+    "Text-to-Speech": "Data Extraction & Pipeline Harvest",
+    "Uncensored Models": "Local Inference Engines",
+    "Vector Store": "Decentralized Knowledge & Vector Stores",
+    "Visualization": "Human Interface & System Operations",
+    "Web Crawler": "Data Extraction & Pipeline Harvest",
+    "Workflow": "Human Interface & System Operations",
+}
+
+
+# ── helpers ───────────────────────────────────────────────────────────
+
+def load_module(path: Path, name: str):
+    spec = importlib.util.spec_from_file_location(name, path)
+    mod = importlib.util.module_from_spec(spec)
+    sys.modules[name] = mod
+    spec.loader.exec_module(mod)
+    return mod
+
+
+def py_str(value: str) -> str:
+    """Render a string as a single-quoted Python literal (old-file style)."""
+    escaped = value.replace("\\", "\\\\").replace("'", "\\'")
+    return f"'{escaped}'"
+
+
+def render_tool_block(tid: str, entry: dict, indent: str = "    ") -> list[str]:
+    """Render one registry entry in the historical defaults.py style."""
+    lines = [
+        f"{indent}'{tid}': {{",
+        f'{indent}"name": {py_str(entry["name"])},',
+        f'{indent}"level": {entry["level"]},',
+        f'{indent}"layer": {py_str(entry["layer"])},',
+        f'{indent}"role": {py_str(entry["role"])},',
+        f'{indent}"category": {py_str(entry["category"])},',
+        f'{indent}"installer": {{',
+    ]
+    for key, val in entry["installer"].items():
+        if key == "env_overrides":
+            lines.append(f'{indent}    "env_overrides": {{')
+            for env_k, env_v in val.items():
+                lines.append(f'{indent}        {py_str(env_k)}: {py_str(env_v)},')
+            lines.append(f'{indent}    }},')
+        elif isinstance(val, bool):
+            lines.append(f'{indent}    "{key}": {val},')
+        elif isinstance(val, (int, float)):
+            lines.append(f'{indent}    "{key}": {val},')
+        else:
+            lines.append(f'{indent}    "{key}": {py_str(val)},')
+    lines.append(f'{indent}}},')
+    lines.append(f'{indent}"launcher": {{')
+    for key, val in entry["launcher"].items():
+        if val is None or isinstance(val, bool):
+            lines.append(f'{indent}    "{key}": {val},')
+        elif isinstance(val, (int, float)):
+            lines.append(f'{indent}    "{key}": {val},')
+        else:
+            lines.append(f'{indent}    "{key}": {py_str(val)},')
+    lines.append(f'{indent}}},')
+    lines.append(f'{indent}"deps": [')
+    lines += [f'{indent}    {py_str(d)},' for d in entry["deps"]]
+    lines.append(f"{indent}],")
+    if "filesystem" in entry:
+        lines.append(f'{indent}"filesystem": {{')
+        for key, val in entry["filesystem"].items():
+            lines.append(f'{indent}    "{key}": {py_str(val)},')
+        lines.append(f'{indent}}},')
+    lines.append(f'{indent}"description": {py_str(entry["description"])},')
+    lines.append(f'{indent}"license": {py_str(entry["license"])},')
+    flags = entry["flags"]
+    lines.append(f'{indent}"flags": {{')
+    for key in ("has_cli", "has_gui", "has_web", "is_ollama",
+                "is_passive", "is_mcp", "is_skills_collection"):
+        lines.append(f'{indent}    "{key}": {flags[key]},')
+    lines.append(f'{indent}}}')
+    lines.append(f"{indent}}},")
+    return lines
+
+
+# ── Stage 1: defaults.py ─────────────────────────────────────────────
+
+DEFAULTS_HEADER = '''"""
+AI-LSC — Default tool registry (108 tools, 10-Layer Systems Architecture).
+
+This is the first-boot seed registry.  The canonical source of truth at
+runtime is the set of modular per-layer files under
+``ai_lsc/registry/layers`` (discovered by :mod:`ai_lsc.registry.loader`);
+``RegistryManager`` seeds ``ecosystem.json`` from the merged layer files
+and syncs structural fields (layer, level, role, category) from them on
+every start while preserving user customisations.
+
+Convention
+----------
+Every entry has the same top-level shape::
+
+    {
+        "name":       <Human-readable display name>,
+        "level":      <1–10 taxonomy level (int)>,
+        "layer":      <Layer name matching NAV_LAYER_ORDER>,
+        "role":       <Functional role within the layer>,
+        "category":   <UI grouping category>,
+        "installer":  {"type": <pacman|uv|pipx|pip|npm|git|git_node|script|custom>,
+                        "pkg": <package name or URL>,
+                        "cmd": <only for "script" type>,
+                        "post_install" / "update_cmd" / "env_overrides": optional},
+        "launcher":  {"type": <systemd|tmux|desktop>,
+                        "cmd": <shell command with {placeholders}>,
+                        "default_port": <int | None>},
+        "deps":       [<tool_ids this tool depends on>],
+        "description": <One-line human description>,
+        "license":    <SPDX ID from registry/licenses.py>,
+        "flags":      {<ToolFlags boolean fields>},
+        "filesystem": {optional install/config/cache/logs/models paths},
+    }
+
+Launcher command placeholders
+-----------------------------
+``{port}``, ``{tools_root}``, ``{models_root}``,
+``{workspaces_root}``, ``{base_dir}`` are resolved at launch time by
+the ``ServiceRow`` dispatcher.
+
+Layer map (10-Layer Systems Architecture Taxonomy)
+---------------------------------------------------
+L1  Host Platform & Infrastructure          — databases, caches, isolation, edge daemons
+L2  Development Runtime & Environment       — runtimes, compilers, build, debug, search, VCS
+L3  GPU Acceleration & Optimization          — CUDA, mixed precision, tensor libraries
+L4  Local Inference Engines                  — local LLM servers (vLLM, llama.cpp, Ollama)
+L5  Intelligent API Routers & Proxies        — LiteLLM, routers, mesh transport
+L6  Multi-Agent Orchestration Runtimes       — Swarm, AutoGen, CrewAI, reasoning engines
+L7  Agentic Software Engineering & Sandboxes — OpenHands, Aider, Claude Code, code skills
+L8  Decentralized Knowledge & Vector Stores  — Chroma, Qdrant, Neo4j, agent memory
+L9  Data Extraction & Pipeline Harvest       — Docling, Crawl4AI, Whisper, ETL
+L10 Human Interface & System Operations      — chat consoles, telemetry, flow canvases, IaC
+
+Flags
+-----
+``has_cli`` / ``has_gui`` / ``has_web`` describe the active surface(s) a
+user can interact with once the tool is running.
+
+``is_passive`` marks tools that are *consumed* (libraries, model packs,
+CLIs without a daemon) rather than launched as long-running services.
+``is_mcp`` marks MCP (Model Context Protocol) API tools.
+``is_skills_collection`` marks bundled skill / capability definitions.
+
+NOTE: This dict is intentionally kept as a *literal* so that it can be
+      round-tripped through JSON without loss.  Do NOT add non-serialisable
+      objects (Path, Enum, etc.) here.
+"""
+
+# NOTE: This dict is intentionally kept as a *literal* so that it can be
+#       round-tripped through JSON without loss.  Do NOT add non-serialisable
+#       objects (Path, Enum, etc.) here.
+
+'''
+
+
+def stage_defaults(new_defaults_path: Path) -> None:
+    old_mod = load_module(SRC / "ai_lsc" / "registry" / "defaults.py", "old_defaults")
+    new_mod = load_module(new_defaults_path, "new_defaults")
+    old, new = old_mod.DEFAULT_REGISTRY, new_mod.DEFAULT_REGISTRY
+
+    merged: dict[str, dict] = {}
+    for tid, entry in new.items():
+        prev = old.get(tid, {})
+        out = dict(entry)  # taxonomy + description from the master target
+        # Operational metadata is preserved from the previous registry:
+        # the master-target file rewrote installers (placeholder URLs,
+        # dropped cmds), launchers (wrong binary names, systemd→tmux),
+        # deps (all edges wiped), licenses and flags.
+        for field in ("installer", "launcher", "deps", "flags", "license"):
+            if field in prev:
+                out[field] = prev[field]
+        if "filesystem" in prev:
+            out["filesystem"] = prev["filesystem"]
+        merged[tid] = out
+
+    # sanity: every layer/level pair must be consistent with the taxonomy
+    for tid, entry in merged.items():
+        assert entry["layer"] in LAYER_LEVEL, f"{tid}: unknown layer {entry['layer']!r}"
+        assert entry["level"] == LAYER_LEVEL[entry["layer"]], \
+            f"{tid}: level {entry['level']} != taxonomy level for {entry['layer']!r}"
+
+    lines = [DEFAULTS_HEADER, "DEFAULT_REGISTRY: dict = {"]
+    order = sorted(merged, key=lambda t: (merged[t]["level"], t))
+    current_level = 0
+    for tid in order:
+        entry = merged[tid]
+        if entry["level"] != current_level:
+            current_level = entry["level"]
+            banner = f"L{current_level}: {entry['layer']}"
+            pad = max(4, 62 - len(banner))
+            lines.append("")
+            lines.append(f"    # ── {banner} {'─' * pad}")
+            lines.append("")
+        lines += render_tool_block(tid, entry)
+    lines.append("}")
+    lines.append("")
+
+    out_path = SRC / "ai_lsc" / "registry" / "defaults.py"
+    out_path.write_text("\n".join(lines), encoding="utf-8")
+    print(f"[defaults] wrote {out_path} ({len(merged)} tools)")
+
+
+# ── Stage 2: layer files ─────────────────────────────────────────────
+
+def find_block_span(content: str, tid: str) -> tuple[int, int] | None:
+    """Locate `'tid': {` ... matching close brace in a layer file."""
+    m = re.search(rf"^(\s*)['\"]{re.escape(tid)}['\"]\s*:\s*\{{", content, re.M)
+    if not m:
+        return None
+    start = m.start()
+    depth = 0
+    for i in range(m.end() - 1, len(content)):
+        ch = content[i]
+        if ch == "{":
+            depth += 1
+        elif ch == "}":
+            depth -= 1
+            if depth == 0:
+                return start, i + 1
+    return None
+
+
+def set_field(block: str, key: str, value: str) -> str:
+    """Replace (or insert) a top-level "key": <value> line in a tool block."""
+    pattern = re.compile(rf'^(\s*)"{key}"\s*:\s*[^,\n]+,?$', re.M)
+    line = f'"{key}": {value},'
+    if pattern.search(block):
+        return pattern.sub(lambda m: f"{m.group(1)}{line}", block, count=1)
+    # insert after the opening brace line
+    return re.sub(r"^(\s*['\"][^'\"]+['\"]\s*:\s*\{)",
+                  lambda m: f"{m.group(1)}\n    {line}", block, count=1)
+
+
+def stage_layers(new_defaults_path: Path) -> None:
+    new_mod = load_module(new_defaults_path, "new_defaults")
+    new = new_mod.DEFAULT_REGISTRY
+    layers_dir = SRC / "ai_lsc" / "registry" / "layers"
+
+    # import merged registry from the tree being migrated
+    sys.path.insert(0, str(SRC))
+    loader = importlib.import_module("ai_lsc.registry.loader")
+    merged = loader.load_merged_registry()
+    sys.path.pop(0)
+
+    # resolve the final structural assignment for every registry tool
+    final: dict[str, dict[str, str]] = {}
+    for tid, entry in merged.items():
+        if tid in new:
+            src = new[tid]
+            final[tid] = {"layer": src["layer"], "level": str(src["level"]),
+                          "role": src["role"], "category": src["category"]}
+        else:
+            layer = TOOL_CLASSIFICATION.get(tid)
+            assert layer, f"no 10-layer classification for tool {tid!r}"
+            final[tid] = {"layer": layer, "level": str(LAYER_LEVEL[layer]),
+                          "role": entry["role"], "category": entry["category"]}
+
+    # kanban exists only in defaults.py — reconcile it into the layer files
+    old_mod = load_module(SRC / "ai_lsc" / "registry" / "defaults.py", "old_defaults_l")
+    kanban = old_mod.DEFAULT_REGISTRY.get("kanban")
+    kanban_target_file = "user_interfaces.py"
+    if kanban is not None and "kanban" not in merged:
+        kanban_layer = new.get("kanban", {}).get("layer", "Human Interface & System Operations")
+        kanban_level = new.get("kanban", {}).get("level", 10)
+        kanban_role = new.get("kanban", {}).get("role", kanban["role"])
+        kanban_cat = new.get("kanban", {}).get("category", kanban["category"])
+        final["kanban"] = {"layer": kanban_layer, "level": str(kanban_level),
+                           "role": kanban_role, "category": kanban_cat}
+
+    counts: dict[str, int] = {}
+    for path in sorted(layers_dir.glob("*.py")):
+        if path.name == "__init__.py":
+            continue
+        content = path.read_text(encoding="utf-8")
+        touched = 0
+        for tid, fields in final.items():
+            span = find_block_span(content, tid)
+            if span is None:
+                continue
+            block = content[span[0]:span[1]]
+            new_block = block
+            new_block = set_field(new_block, "layer", py_str(fields["layer"]))
+            new_block = set_field(new_block, "level", fields["level"])
+            new_block = set_field(new_block, "role", py_str(fields["role"]))
+            new_block = set_field(new_block, "category", py_str(fields["category"]))
+            if new_block != block:
+                content = content[:span[0]] + new_block + content[span[1]:]
+                touched += 1
+        if path.name == kanban_target_file and kanban is not None and "kanban" not in merged:
+            block = "\n".join(render_tool_block("kanban", {
+                **kanban,
+                "layer": final["kanban"]["layer"],
+                "level": int(final["kanban"]["level"]),
+                "role": final["kanban"]["role"],
+                "category": final["kanban"]["category"],
+            }))
+            # insert inside the TOOLS dict, before its closing brace
+            body = content.rstrip()
+            idx = body.rfind("\n}")
+            assert idx != -1, f"TOOLS closing brace not found in {path}"
+            content = body[:idx] + "\n\n" + block + "\n}\n"
+            touched += 1
+        if touched:
+            path.write_text(content, encoding="utf-8")
+        counts[path.name] = touched
+        print(f"[layers] {path.name}: realigned {touched} tools")
+
+    # refresh each layer-file module docstring to reference the new taxonomy
+    layer_doc_note = (
+        "\nStructural fields (layer, level) follow the 10-Layer Systems\n"
+        "Architecture Taxonomy; tools may be regrouped across files in a\n"
+        "future pass — the loader merges by tool, not by filename.\n"
+    )
+    for path in sorted(layers_dir.glob("*.py")):
+        if path.name == "__init__.py":
+            continue
+        content = path.read_text(encoding="utf-8")
+        m = re.match(r'^"""(.*?)"""', content, re.S)
+        if m and "10-Layer Systems" not in m.group(1):
+            doc = m.group(1).rstrip()
+            content = f'"""{doc}\n{layer_doc_note}"""' + content[m.end():]
+            path.write_text(content, encoding="utf-8")
+
+
+# ── Stage 3: connections.py ──────────────────────────────────────────
+
+WIRING_PRELUDE = '''
+
+# ── 10-layer taxonomy resolution ──────────────────────────────────────
+# Static wiring entries carry their layer as a literal; loop-based bulk
+# allocations resolve the layer dynamically from the registry so the
+# wiring graph can never drift from the taxonomy again.
+from ai_lsc.registry.defaults import DEFAULT_REGISTRY
+
+# Layer assignments for staged tools that live in the modular layer
+# files but are not part of the shipped DEFAULT_REGISTRY seed.
+_WIRING_LAYER_SUPPLEMENT: dict[str, str] = {
+    "agent_reach": "Multi-Agent Orchestration Runtimes",
+    "algory": "Multi-Agent Orchestration Runtimes",
+    "atlas_os": "Multi-Agent Orchestration Runtimes",
+    "clamav": "Human Interface & System Operations",
+    "crossplane": "Human Interface & System Operations",
+    "distcc": "Development Runtime & Environment",
+    "eagle_eye": "Human Interface & System Operations",
+    "everos_memory": "Decentralized Knowledge & Vector Stores",
+    "gemini_cli": "Agentic Software Engineering & Sandboxes",
+    "glassmind": "Multi-Agent Orchestration Runtimes",
+    "goose": "Agentic Software Engineering & Sandboxes",
+    "graphify": "Agentic Software Engineering & Sandboxes",
+    "headroom": "Multi-Agent Orchestration Runtimes",
+    "hermes_webui": "Human Interface & System Operations",
+    "honcho": "Multi-Agent Orchestration Runtimes",
+    "jan": "Human Interface & System Operations",
+    "letta": "Multi-Agent Orchestration Runtimes",
+    "mem0": "Decentralized Knowledge & Vector Stores",
+    "meshllm": "Intelligent API Routers & Proxies",
+    "mnemo_cortex": "Decentralized Knowledge & Vector Stores",
+    "n8n": "Human Interface & System Operations",
+    "nightshift": "Multi-Agent Orchestration Runtimes",
+    "nvidia_agent_skills": "Multi-Agent Orchestration Runtimes",
+    "odysseus": "Multi-Agent Orchestration Runtimes",
+    "openbrain": "Multi-Agent Orchestration Runtimes",
+    "opencode": "Agentic Software Engineering & Sandboxes",
+    "picode": "Agentic Software Engineering & Sandboxes",
+    "pssh": "Human Interface & System Operations",
+    "qwen_code": "Agentic Software Engineering & Sandboxes",
+    "sglang": "Local Inference Engines",
+    "tinygrad": "GPU Acceleration & Optimization",
+    "trivy": "Human Interface & System Operations",
+    "turbovec": "Decentralized Knowledge & Vector Stores",
+    "zcoder": "Agentic Software Engineering & Sandboxes",
+    "dma": "Development Runtime & Environment",
+    "opa": "Human Interface & System Operations",
+}
+
+
+def _wiring_layer(tool_id: str) -> str:
+    """Resolve a tool's 10-layer taxonomy layer for its wiring entry."""
+    entry = DEFAULT_REGISTRY.get(tool_id)
+    if entry:
+        return entry.get("layer", "")
+    return _WIRING_LAYER_SUPPLEMENT.get(tool_id, "")
+
+'''
+
+SECTION_RENAMES = [
+    ("# L1: Host Platform",
+     "# L1: Host Platform  →  Layer 1: Host Platform & Infrastructure"),
+    ("# L2: Development Environment",
+     "# L2: Development Environment  →  Layer 2: Development Runtime & Environment"),
+    ("# L3: GPU Runtime",
+     "# L3: GPU Runtime  →  Layer 3: GPU Acceleration & Optimization"),
+    ("# L4: Inference Engines",
+     "# L4: Inference Engines  →  Layer 4: Local Inference Engines"),
+    ("# L6: AI Endpoints  (→ the restored \"Routing\" layer in the 11-layer taxonomy)",
+     "# L6: AI Endpoints  →  Layer 5: Intelligent API Routers & Proxies (10-layer taxonomy)"),
+    ("# L10: Intelligent Routing  (folded into \"Orchestrators\" in the 11-layer taxonomy)",
+     "# L10: Intelligent Routing  →  Layer 5: Intelligent API Routers & Proxies (10-layer taxonomy)"),
+    ("# L7: Data & Knowledge Pipelines",
+     "# L7: Data & Knowledge Pipelines  →  Layer 8/9: Vector Stores + Data Extraction (10-layer taxonomy)"),
+    ("# L8: Automation & Execution",
+     "# L8: Automation & Execution  →  Layer 6/7: Orchestration + Agentic Engineering (10-layer taxonomy)"),
+    ("# L9: Observability",
+     "# L9: Observability  →  Layer 10: Human Interface & System Operations (10-layer taxonomy)"),
+    ("# L11: User Interfaces",
+     "# L11: User Interfaces  →  Layer 10: Human Interface & System Operations (10-layer taxonomy)"),
+    ("# L12: DevOps",
+     "# L12: DevOps  →  Layer 9/10: Data Extraction + System Operations (10-layer taxonomy)"),
+    ("# L13: Knowledge Management",
+     "# L13: Knowledge Management  →  Layer 8/10: Vector Stores + System Operations (10-layer taxonomy)"),
+    ("# L5: Distributed Runtime",
+     "# L5: Distributed Runtime  →  Layer 3/4: GPU + Inference Engines (10-layer taxonomy)"),
+]
+
+
+def stage_wiring(new_defaults_path: Path) -> None:
+    new_mod = load_module(new_defaults_path, "new_defaults")
+    new = new_mod.DEFAULT_REGISTRY
+
+    layer_of: dict[str, str] = {}
+    for tid, entry in new.items():
+        layer_of[tid] = entry["layer"]
+    for tid, layer in TOOL_CLASSIFICATION.items():
+        layer_of.setdefault(tid, layer)
+
+    path = SRC / "ai_lsc" / "stack" / "connections.py"
+    content = path.read_text(encoding="utf-8")
+
+    # 1. Insert the taxonomy resolution prelude after the imports.
+    if "_wiring_layer" not in content:
+        anchor = "from typing import Any\n"
+        content = content.replace(anchor, anchor + WIRING_PRELUDE, 1)
+
+    # 2. Static StackWiring entries: replace layer="<old>" with the tool's
+    #    new layer.  Iterate over `_reg(StackWiring(` blocks.
+    parts = content.split("_reg(StackWiring(")
+    rebuilt = [parts[0]]
+    static_updated = 0
+    for part in parts[1:]:
+        tid_m = re.search(r'tool_id\s*=\s*"([A-Za-z0-9_.:\-]+)"', part)
+        if tid_m:
+            tid = tid_m.group(1)
+            new_layer = layer_of.get(tid)
+            if new_layer:
+                part, n = re.subn(
+                    r'layer\s*=\s*"[^"]*"',
+                    f'layer="{new_layer}"',
+                    part, count=1)
+                static_updated += n
+        rebuilt.append(part)
+    content = "_reg(StackWiring(".join(rebuilt)
+
+    # 3. Loop-based bulk allocations -> dynamic lookups.
+    loop_pat = re.compile(
+        r'layer\s*=\s*"(?:DevOps|User Interfaces|Knowledge Management|'
+        r'Orchestrators|Host Platform|Development Environment|GPU Runtimes|'
+        r'Engines|Routing|Security|Observability)"')
+    content, loops_updated = loop_pat.subn('layer=_wiring_layer(_tid)', content)
+
+    # 4. Refresh section header comments to the 10-layer taxonomy mapping.
+    for old, new_c in SECTION_RENAMES:
+        content = content.replace(old, new_c)
+
+    path.write_text(content, encoding="utf-8")
+    print(f"[wiring] static layers updated: {static_updated}, "
+          f"loop allocations converted: {loops_updated}")
+
+
+# ── Stage 4: CATEGORY_MAP ────────────────────────────────────────────
+
+def category_map_lines(cmap: dict[str, dict]) -> str:
+    lines = ["CATEGORY_MAP: dict[str, dict[str, object]] = {"]
+    for cat in sorted(cmap):
+        val = cmap[cat]
+        lines.append(
+            f'    "{cat}": {{"layer": "{val["layer"]}", '
+            f'"level": {val["level"]}, "role": "{val["role"]}"'
+            '},')
+    lines.append("}")
+    return "\n".join(lines)
+
+
+def stage_category_map() -> None:
+    # read the current CATEGORY_MAP from the restored v3.1.1b db_manager
+    # (full 124-category cascade in the old 11-layer taxonomy)
+    dbm = SRC / "ai_lsc" / "ui" / "pages" / "db_manager.py"
+    content = dbm.read_text(encoding="utf-8")
+    m = re.search(
+        r'CATEGORY_MAP:\s*dict\[str,\s*dict\[str,\s*object\]\]\s*=\s*\{.*?\n\}',
+        content, re.S)
+    assert m, "CATEGORY_MAP block not found in db_manager.py"
+    alt_map = eval(m.group(0).split("=", 1)[1])  # literal dict, safe to eval
+
+    # the master target's 10-layer map (from apply_taxonomy_migration.py)
+    atm_path = REPO / "apply_taxonomy_migration.py"
+    atm = load_module(atm_path, "atm_map")
+    cmap = {cat: dict(val) for cat, val in atm.NEW_CATEGORY_MAP.items()}
+
+    # extend with the categories introduced by the classified tools
+    for cat, layer in EXTRA_CATEGORY_LAYERS.items():
+        if cat not in cmap:
+            cmap[cat] = {"layer": layer, "level": LAYER_LEVEL[layer],
+                         "role": cat}
+    if "Project Management" not in cmap:
+        cmap["Project Management"] = {
+            "layer": "Human Interface & System Operations", "level": 10,
+            "role": "Project Management"}
+
+    # preserve the alt cascade's richer coverage: keep its curated roles,
+    # translate the layer/level to the 10-layer taxonomy
+    for cat, val in alt_map.items():
+        if cat in cmap:
+            continue
+        layer = ALT_CATEGORY_TRANSLATIONS.get(cat)
+        assert layer, f"no 10-layer translation for alt category {cat!r}"
+        cmap[cat] = {"layer": layer, "level": LAYER_LEVEL[layer],
+                     "role": val.get("role", cat)}
+
+    # every layer referenced must be a valid 10-layer name
+    for cat, val in cmap.items():
+        assert val["layer"] in LAYER_LEVEL, f"{cat}: bad layer {val['layer']!r}"
+        assert val["level"] == LAYER_LEVEL[val["layer"]], \
+            f"{cat}: level {val['level']} inconsistent with {val['layer']!r}"
+
+    new_block = category_map_lines(cmap)
+    content = content[:m.start()] + new_block + content[m.end():]
+
+    # refresh the stale header comment above the map
+    content = re.sub(
+        r'# ── Category → default Layer / Level / Role mapping ──+\n'
+        r'# Derived from the canonical registry \(11-layer taxonomy, v3\.1\.1b:\n'
+        r'# Routing=L5, Orchestrators=L6, Security=L7, Observability=L8,\n'
+        r'# User Interfaces=L9, DevOps=L10, Knowledge Management=L11\)\.\n'
+        r'# When the user picks a category these fields auto-fill; the user can\n'
+        r'# still override afterwards\.',
+        '# ── Category → default Layer / Level / Role mapping ──────────────────\n'
+        '# Derived from the canonical registry (10-Layer Systems Architecture\n'
+        '# Taxonomy).  When the user picks a category these fields auto-fill;\n'
+        '# the user can still override afterwards.',
+        content)
+
+    dbm.write_text(content, encoding="utf-8")
+    print(f"[categorymap] db_manager.py CATEGORY_MAP -> {len(cmap)} categories")
+
+    # regenerate the standalone reference file
+    ref = SRC / "ai_lsc" / "ui" / "pages" / "db_manager_category_map.py"
+    ref.write_text(
+        "# This file contains the fully reorganized CATEGORY_MAP for db_manager.py\n"
+        "# mapped cleanly to the 10-Layer Systems Architecture.\n\n"
+        + new_block + "\n",
+        encoding="utf-8")
+    print(f"[categorymap] regenerated {ref.name}")
+
+
+# ── Stage 5: doc fixes ───────────────────────────────────────────────
+
+def stage_docfixes() -> None:
+    # validator: enforce the 10-level range of the new taxonomy
+    vpath = SRC / "ai_lsc" / "registry" / "validator.py"
+    content = vpath.read_text(encoding="utf-8")
+    content = content.replace(
+        "    # Level must be 1–13\n"
+        '    level = entry.get("level")\n'
+        "    if isinstance(level, int) and not (1 <= level <= 13):\n"
+        '        errors.append(f"{tool_id}: level {level} out of range 1-13")',
+        "    # Level must be 1–10 (10-Layer Systems Architecture Taxonomy)\n"
+        '    level = entry.get("level")\n'
+        "    if isinstance(level, int) and not (1 <= level <= 10):\n"
+        '        errors.append(f"{tool_id}: level {level} out of range 1-10 "\n'
+        '                      f"(10-layer taxonomy)")')
+    vpath.write_text(content, encoding="utf-8")
+    print("[docfixes] validator level range 1-13 -> 1-10")
+
+    # README layer table + file-tree note
+    rpath = REPO / "README.md"
+    readme = rpath.read_text(encoding="utf-8")
+    old_table_start = readme.find("| Layer | Tools | Examples |")
+    old_table_end = readme.find("![Infrastructure Layers]")
+    if old_table_start != -1 and old_table_end != -1:
+        new_table = (
+            "| Layer | Tools | Examples |\n"
+            "|-------|-------|----------|\n"
+            "| L1 — Host Platform & Infrastructure | 28 | PostgreSQL, MariaDB, Redis, DuckDB, Podman, Docker, LXC, Firecracker, libvirt, nginx, Tmux, Keycloak, Vault |\n"
+            "| L2 — Development Runtime & Environment | 37 | Python, uv, Node.js, Deno, Go, Rust, GCC, make, ripgrep, fd, tree-sitter, git, gdb, valgrind |\n"
+            "| L3 — GPU Acceleration & Optimization | 5 | CUDA, CuPy, Apex, Unsloth, tinygrad |\n"
+            "| L4 — Local Inference Engines | 10 | vLLM, SGLang, llama.cpp, KoboldCPP, Llamafile, Ollama, TurboLLM, AirLLM |\n"
+            "| L5 — Intelligent API Routers & Proxies | 4 | LiteLLM Proxy, 9Router Proxy, MeshLLM, Fabric |\n"
+            "| L6 — Multi-Agent Orchestration Runtimes | 22 | Swarm, AutoGen, CrewAI, Agno, LangChain, Letta, OpenBrain, Ray, Glassmind |\n"
+            "| L7 — Agentic Software Engineering & Sandboxes | 17 | OpenHands, Aider, Claude Code, Codex, Gemini CLI, OpenCode, goose, spec-kit |\n"
+            "| L8 — Decentralized Knowledge & Vector Stores | 11 | ChromaDB, LanceDB, Qdrant, Neo4j, Elasticsearch, Meilisearch, Mem0, TurboVec |\n"
+            "| L9 — Data Extraction & Pipeline Harvest | 12 | Crawl4AI, Docling, MarkItDown, Whisper, Parakeet, Airweave, OpenDataloader |\n"
+            "| L10 — Human Interface & System Operations | 40 | Open WebUI, AnythingLLM, LibreChat, Flowise, n8n, Dify, Grafana, Prometheus, Terraform, Ansible |\n"
+            "\n"
+        )
+        readme = readme[:old_table_start] + new_table + readme[old_table_end:]
+        readme = readme.replace(
+            "layers/                    # 10 per-layer tool files",
+            "layers/                    # 11 per-layer tool files (10-layer taxonomy)")
+        rpath.write_text(readme, encoding="utf-8")
+        print("[docfixes] README layer table updated")
+
+    # quickstart stale reference
+    qpath = REPO / "quickstart.md"
+    quick = qpath.read_text(encoding="utf-8")
+    quick = quick.replace(
+        "the 13-layer architecture", "the 10-layer architecture")
+    qpath.write_text(quick, encoding="utf-8")
+    print("[docfixes] quickstart layer reference updated")
+
+
+# ── main ─────────────────────────────────────────────────────────────
+
+def main() -> None:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--new-defaults", required=True,
+                    help="path to the master-target 108-tool defaults.py")
+    ap.add_argument("stages", nargs="*",
+                    default=["defaults", "layers", "wiring",
+                             "categorymap", "docfixes"],
+                    help="stages to run (default: all)")
+    args = ap.parse_args()
+
+    new_defaults = Path(args.new_defaults).resolve()
+    stages = args.stages or ["defaults", "layers", "wiring",
+                             "categorymap", "docfixes"]
+    if "defaults" in stages:
+        stage_defaults(new_defaults)
+    if "layers" in stages:
+        stage_layers(new_defaults)
+    if "wiring" in stages:
+        stage_wiring(new_defaults)
+    if "categorymap" in stages:
+        stage_category_map()
+    if "docfixes" in stages:
+        stage_docfixes()
+    print("[done]")
+
+
+if __name__ == "__main__":
+    main()

src/ai_lsc/constants.py

@@ -1,11 +1,9 @@
 """
 AI-LSC v3.1 — Application-wide constants.
-
 Release codename: Ankh of Jah
-
 Pure data: file names, schema version, required directories, default ports,
-status styles, log colours, service licences, tree-skip patterns, and the
+status styles, log colours, service licences, tree-skip patterns,
-navigation layer order.  No behaviour lives here.
+and the reorganized 10-layer navigation layer order.
 """
 
 import os
@@ -14,13 +12,11 @@ import os
 # Overridable via AI_LSC_BASE_DIR environment variable.
 # Bootstrap sets this; the app resolves everything relative to it.
 BASE_DIR: str = os.environ.get("AI_LSC_BASE_DIR", "/mnt/AI")
-
-# LA-03: alias so run.sh --headless can import it
 CANONICAL_BASE_DIR: str = BASE_DIR
 
 # ── Filenames ────────────────────────────────────────────────────────────
-APP_VERSION: str = "3.1.1"
+APP_VERSION: str = "3.3.0"
-APP_CODENAME: str = "Ankh of Jah"
+APP_CODENAME: str = "Decalogue"
 APP_DISPLAY_NAME: str = f"AI - Local Stack Control v{APP_VERSION} - http://dcos.net"
 CONFIG_FILE: str = "controller_config.json"
 APP_ICON_FILE: str = "ai-lsc-logo.png"
@@ -31,16 +27,7 @@ MANIFEST_FILE_NAME: str = ".ai-lsc-project.json"
 JCL_FILE_NAME: str = ".ai-lsc-jobs.json"
 
 # ── Required sub-directories under BASE_DIR ────────────────────
-# The canonical /mnt/AI/ folder layout (v3.1.1b, 24 dirs).  Per-tool
+# The canonical /mnt/AI/ folder layout (v3.1.1b, 24 dirs).
-# subdirs (runtime/<tool>/, configs/<tool>/, dashboards/<tool>/) are
-# created on demand by InstallerManager; only top-level layout dirs are
-# listed here so a fresh install has the full skeleton.
-#
-# App-internal storage that is NOT part of the canonical layout:
-#   registry/          — ecosystem.json tool DB (RegistryManager mkdirs it)
-#   registry/manifests — SHA256 hashes, build logs, chunking records
-#   bootstraps/        — legacy minimal bootstrap scripts (no longer created)
-#   staging/           — legacy quarantine zone (no longer created)
 REQUIRED_DIRS: list[str] = [
     "backends",                 # S3/MinIO/Ceph connection profiles + topology
     "distfiles",                # permanent mirror of raw source tarballs + installers
@@ -70,17 +57,35 @@ REQUIRED_DIRS: list[str] = [
 
 # ── Default ports for every known tool ───────────────────────────────────
 DEFAULT_PORTS: dict[str, int | None] = {
-    "postgresql": 5432, "mariadb": 3306, "redis": 6379,
+    "postgresql": 5432,
-    "sqlite3": None, "python": None, "cuda": None,
+    "mariadb": 3306,
-    "ollama": 11434, "llamacpp": 8080, "vllm": 8000,
+    "redis": 6379,
-    "litellm": 4000, "chromadb": 8000, "whisper": None,
+    "sqlite3": None,
-    "docling": None, "aider": None, "claude_code": None,
+    "python": None,
-    "fabric": None, "btop": None, "glances": 61208,
+    "cuda": None,
-    "crewai": None, "autogen": None,
+    "ollama": 11434,
-    "hermes": 17050, "openwebui": 8080, "anythingllm": 3001,
+    "llamacpp": 8080,
-    "flowise": 3000, "dify": 80, "stack_exporter": None,
+    "vllm": 8000,
-    # Agentic OS stack additions
+    "litellm": 4000,
-    "qdrant": 6333, "librechat": 3080, "n8n": 5678,
+    "chromadb": 8000,
+    "whisper": None,
+    "docling": None,
+    "aider": None,
+    "claude_code": None,
+    "fabric": None,
+    "btop": None,
+    "glances": 61208,
+    "crewai": None,
+    "autogen": None,
+    "hermes": 17050,
+    "openwebui": 8080,
+    "anythingllm": 3001,
+    "flowise": 3000,
+    "dify": 80,
+    "stack_exporter": None,
+    "qdrant": 6333,
+    "librechat": 3080,
+    "n8n": 5678,
 }
 
 # ── UI status label formatting ──────────────────────────────────────────
@@ -91,11 +96,16 @@ STATUS_STYLES: dict[bool, tuple[str, str]] = {
 
 # ── Log source colours for the activity feed ────────────────────────────
 LOG_SOURCE_COLORS: dict[str, str] = {
-    "Ollama": "#e67e22", "Tmux": "#3498db",
+    "Ollama": "#e67e22",
-    "Installer": "#2ecc71", "Audit": "#f39c12",
+    "Tmux": "#3498db",
-    "Container": "#9b59b6", "SkillRuntime": "#1abc9c",
+    "Installer": "#2ecc71",
-    "Pipeline": "#e74c3c", "Lifecycle": "#2980b9",
+    "Audit": "#f39c12",
-    "SelfHeal": "#8e44ad", "Compiler": "#e67e22",
+    "Container": "#9b59b6",
+    "SkillRuntime": "#1abc9c",
+    "Pipeline": "#e74c3c",
+    "Lifecycle": "#2980b9",
+    "SelfHeal": "#8e44ad",
+    "Compiler": "#e67e22",
 }
 LOG_COLOR_DEFAULT: str = "#bdc3c7"
 
@@ -133,21 +143,26 @@ SERVICE_LICENSES: dict[str, str] = {
 TREE_SKIP_PATTERNS: set[str] = {".", "__pycache__", "node_modules", "vendor"}
 
 # ── Navigation layer order for the sidebar rack diagram ───────────────
+# Updated to the new reorganized 10-Layer Architecture
 NAV_LAYER_ORDER: list[str] = [
-    "Host Platform", "Development Environment", "GPU Runtimes",
+    "Host Platform & Infrastructure",
-    "Engines", "Routing", "Orchestrators", "Security",
+    "Development Runtime & Environment",
-    "Observability", "User Interfaces", "DevOps",
+    "GPU Acceleration & Optimization",
-    "Knowledge Management",
+    "Local Inference Engines",
+    "Intelligent API Routers & Proxies",
+    "Multi-Agent Orchestration Runtimes",
+    "Agentic Software Engineering & Sandboxes",
+    "Decentralized Knowledge & Vector Stores",
+    "Data Extraction & Pipeline Harvest",
+    "Human Interface & System Operations",
 ]
 
 # ── Ollama server candidate paths (probed in order) ────────────────
-# The runtime probes these paths to locate the ollama server binary or
-# service data.  First match wins.
 OLLAMA_SERVER_CANDIDATES: list[str] = [
     "ollama",                  # /mnt/AI/ollama
     "tools/ollama",            # /mnt/AI/tools/ollama
     "runtime/ollama",          # /mnt/AI/runtime/ollama
-    "bin/ollama",              # /mnt/AI/bin/ollama
+    "bin/ollama"               # /mnt/AI/bin/ollama
 ]
 
 # ── Model tier routing (reserved for v4.0 agentic layer) ──────────
@@ -166,35 +181,99 @@ CLARIFICATION_CONFIRM_THRESHOLD: float = 0.70
 
 # ── Qt Stylesheets ──────────────────────────────────────────────────────
 GLOBAL_STYLE: str = """
-QWidget { background-color: #161616; color: #e0e0e0;
+QWidget {
-    font-family: 'Segoe UI', Arial, sans-serif; font-size: 13px; }
+    background-color: #161616;
-QGroupBox { border: 1px solid #333; border-radius: 6px; margin-top: 14px;
+    color: #e0e0e0;
-    padding-top: 10px; font-weight: bold; color: #a5d6a7; }
+    font-family: 'Segoe UI', Arial, sans-serif;
-QGroupBox::title { subcontrol-origin: margin; subcontrol-position: top left;
+    font-size: 13px;
-    padding: 0 5px; left: 10px; }
+}
-QPushButton { background-color: #2c3e50; color: white; border: 1px solid #1a252f;
+QGroupBox {
-    border-radius: 4px; padding: 6px 12px; font-weight: bold; }
+    border: 1px solid #333;
-QPushButton:hover { background-color: #34495e; }
+    border-radius: 6px;
-QPushButton:pressed { background-color: #1a252f; }
+    margin-top: 14px;
+    padding-top: 10px;
+    font-weight: bold;
+    color: #a5d6a7;
+}
+QGroupBox::title {
+    subcontrol-origin: margin;
+    subcontrol-position: top left;
+    padding: 0 5px;
+    left: 10px;
+}
+QPushButton {
+    background-color: #2c3e50;
+    color: white;
+    border: 1px solid #1a252f;
+    border-radius: 4px;
+    padding: 6px 12px;
+    font-weight: bold;
+}
+QPushButton:hover {
+    background-color: #34495e;
+}
+QPushButton:pressed {
+    background-color: #1a252f;
+}
 QLineEdit, QTextEdit, QComboBox, QSpinBox, QDoubleSpinBox {
-    background-color: #1e1e1e; border: 1px solid #444;
+    background-color: #1e1e1e;
-    border-radius: 4px; padding: 5px; color: white; }
+    border: 1px solid #444;
-QTabWidget::pane { border: 1px solid #333; background-color: #1a1a1a;
+    border-radius: 4px;
-    border-radius: 4px; }
+    padding: 5px;
-QTabBar::tab { background-color: #222; border: 1px solid #333; padding: 8px 15px;
+    color: white;
-    margin-right: 2px; border-top-left-radius: 4px; border-top-right-radius: 4px; }
+}
-QTabBar::tab:selected { background-color: #3498db; color: white; font-weight: bold; }
+QTabWidget::pane {
-QTableWidget, QTreeWidget, QListWidget { background-color: #1e1e1e;
+    border: 1px solid #333;
-    gridline-color: #333; border: 1px solid #333; border-radius: 4px; }
+    background-color: #1a1a1a;
-QHeaderView::section { background-color: #2c3e50; color: white; padding: 4px;
+    border-radius: 4px;
-    border: 1px solid #1a252f; font-weight: bold; }
+}
+QTabBar::tab {
+    background-color: #222;
+    border: 1px solid #333;
+    padding: 8px 15px;
+    margin-right: 2px;
+    border-top-left-radius: 4px;
+    border-top-right-radius: 4px;
+}
+QTabBar::tab:selected {
+    background-color: #3498db;
+    color: white;
+    font-weight: bold;
+}
+QTableWidget, QTreeWidget, QListWidget {
+    background-color: #1e1e1e;
+    gridline-color: #333;
+    border: 1px solid #333;
+    border-radius: 4px;
+}
+QHeaderView::section {
+    background-color: #2c3e50;
+    color: white;
+    padding: 4px;
+    border: 1px solid #1a252f;
+    font-weight: bold;
+}
 """
 
 SIDEBAR_TREE_STYLE: str = """
-    QTreeWidget { background-color: #111111; border: none; color: #bdc3c7;
+QTreeWidget {
-        font-family: 'Segoe UI'; font-size: 11px; }
+    background-color: #111111;
-    QTreeWidget::item { padding: 6px; border-bottom: 1px solid #161616; }
+    border: none;
-    QTreeWidget::item:hover { background-color: #1c1c1c; color: #fff; }
+    color: #bdc3c7;
-    QTreeWidget::item:selected { background-color: #2c3e50; color: #2ecc71;
+    font-family: 'Segoe UI';
-        font-weight: bold; }
+    font-size: 11px;
+}
+QTreeWidget::item {
+    padding: 6px;
+    border-bottom: 1px solid #161616;
+}
+QTreeWidget::item:hover {
+    background-color: #1c1c1c;
+    color: #fff;
+}
+QTreeWidget::item:selected {
+    background-color: #2c3e50;
+    color: #2ecc71;
+    font-weight: bold;
+}
 """

src/ai_lsc/registry/layers/development.py

@@ -15,15 +15,19 @@ Each entry follows the standard registry schema:
 
 This module is consumed by
 :mod:`ai_lsc.registry.loader`.
+
+Structural fields (layer, level) follow the 10-Layer Systems
+Architecture Taxonomy; tools may be regrouped across files in a
+future pass — the loader merges by tool, not by filename.
 """
 
 TOOLS: dict[str, dict] = {
     'python': {
     "name": "Python Environment",
     "level": 2,
-    "layer": "Development Environment",
+    "layer": 'Development Runtime & Environment',
-    "role": "Build System",
+    "role": 'Runtime Environment',
-    "category": "Runtime",
+    "category": 'Runtime Environment',
     "installer": {
         "type": "pacman",
         "pkg": "python-pip"
@@ -48,10 +52,10 @@ TOOLS: dict[str, dict] = {
 },
     'cupy': {
     "name": "CuPy",
-    "level": 2,
+    "level": 3,
-    "layer": "Development Environment",
+    "layer": 'GPU Acceleration & Optimization',
-    "role": "GPU Acceleration",
+    "role": 'GPU Computing',
-    "category": "GPU Computing",
+    "category": 'GPU Computing',
     "installer": {
         "type": "uv",
         "pkg": "cupy-cuda12x"
@@ -79,9 +83,9 @@ TOOLS: dict[str, dict] = {
     'fd': {
     "name": "fd",
     "level": 2,
-    "layer": "Development Environment",
+    "layer": 'Development Runtime & Environment',
-    "role": "Search",
+    "role": 'File Discovery',
-    "category": "Find Tool",
+    "category": 'File Discovery',
     "installer": {
         "type": "pacman",
         "pkg": "fd"
@@ -107,9 +111,9 @@ TOOLS: dict[str, dict] = {
     'ripgrep': {
     "name": "ripgrep (rg)",
     "level": 2,
-    "layer": "Development Environment",
+    "layer": 'Development Runtime & Environment',
-    "role": "Search",
+    "role": 'Text Search',
-    "category": "Search Tool",
+    "category": 'Text Search',
     "installer": {
         "type": "pacman",
         "pkg": "ripgrep"
@@ -135,9 +139,9 @@ TOOLS: dict[str, dict] = {
     'tree_sitter': {
     "name": "tree-sitter",
     "level": 2,
-    "layer": "Development Environment",
+    "layer": 'Development Runtime & Environment',
-    "role": "Parsing",
+    "role": 'Parsing Engine',
-    "category": "Parser",
+    "category": 'Parsing Engine',
     "installer": {
         "type": "uv",
         "pkg": "tree-sitter"
@@ -163,9 +167,9 @@ TOOLS: dict[str, dict] = {
     'sst': {
     "name": "SST (Serverless Stack)",
     "level": 2,
-    "layer": "Development Environment",
+    "layer": 'Development Runtime & Environment',
-    "role": "Full-Stack Framework",
+    "role": 'Infrastructure as Code',
-    "category": "Serverless Framework",
+    "category": 'Infrastructure as Code',
     "installer": {
         "type": "npm",
         "pkg": "sst"
@@ -190,10 +194,10 @@ TOOLS: dict[str, dict] = {
 },
     'unsloth': {
     "name": "Unsloth",
-    "level": 2,
+    "level": 3,
-    "layer": "Development Environment",
+    "layer": 'GPU Acceleration & Optimization',
-    "role": "Training",
+    "role": 'Model Optimization',
-    "category": "Model Training",
+    "category": 'Model Optimization',
     "installer": {
         "type": "uv",
         "pkg": "unsloth"
@@ -221,9 +225,9 @@ TOOLS: dict[str, dict] = {
     'php': {
         "name": "PHP",
         "level": 2,
-        "layer": "Development Environment",
+        "layer": 'Development Runtime & Environment',
-        "role": "Language",
+        "role": 'Language',
-        "category": "Runtime",
+        "category": 'Runtime',
         "installer": {
             "type": "pacman",
             "pkg": "php"
@@ -249,9 +253,9 @@ TOOLS: dict[str, dict] = {
     'ruby': {
         "name": "Ruby",
         "level": 2,
-        "layer": "Development Environment",
+        "layer": 'Development Runtime & Environment',
-        "role": "Language",
+        "role": 'Language',
-        "category": "Runtime",
+        "category": 'Runtime',
         "installer": {
             "type": "pacman",
             "pkg": "ruby"
@@ -277,9 +281,9 @@ TOOLS: dict[str, dict] = {
     'perl': {
         "name": "Perl",
         "level": 2,
-        "layer": "Development Environment",
+        "layer": 'Development Runtime & Environment',
-        "role": "Language",
+        "role": 'Language',
-        "category": "Runtime",
+        "category": 'Runtime',
         "installer": {
             "type": "pacman",
             "pkg": "perl"
@@ -305,9 +309,9 @@ TOOLS: dict[str, dict] = {
     'julia': {
         "name": "Julia",
         "level": 2,
-        "layer": "Development Environment",
+        "layer": 'Development Runtime & Environment',
-        "role": "Language",
+        "role": 'Language',
-        "category": "Runtime",
+        "category": 'Runtime',
         "installer": {
             "type": "pacman",
             "pkg": "julia"
@@ -333,9 +337,9 @@ TOOLS: dict[str, dict] = {
     'nodejs': {
         "name": "Node.js",
         "level": 2,
-        "layer": "Development Environment",
+        "layer": 'Development Runtime & Environment',
-        "role": "Language",
+        "role": 'Language',
-        "category": "Runtime",
+        "category": 'Runtime',
         "installer": {
             "type": "pacman",
             "pkg": "nodejs"
@@ -361,9 +365,9 @@ TOOLS: dict[str, dict] = {
     'go': {
         "name": "Go",
         "level": 2,
-        "layer": "Development Environment",
+        "layer": 'Development Runtime & Environment',
-        "role": "Language",
+        "role": 'Language',
-        "category": "Runtime",
+        "category": 'Runtime',
         "installer": {
             "type": "pacman",
             "pkg": "go"
@@ -389,9 +393,9 @@ TOOLS: dict[str, dict] = {
     'rust': {
         "name": "Rust",
         "level": 2,
-        "layer": "Development Environment",
+        "layer": 'Development Runtime & Environment',
-        "role": "Language",
+        "role": 'Language',
-        "category": "Runtime",
+        "category": 'Runtime',
         "installer": {
             "type": "pacman",
             "pkg": "rust"
@@ -417,9 +421,9 @@ TOOLS: dict[str, dict] = {
     'java_jdk': {
         "name": "Java JDK",
         "level": 2,
-        "layer": "Development Environment",
+        "layer": 'Development Runtime & Environment',
-        "role": "Language",
+        "role": 'Language',
-        "category": "Runtime",
+        "category": 'Runtime',
         "installer": {
             "type": "pacman",
             "pkg": "jdk-openjdk"
@@ -445,9 +449,9 @@ TOOLS: dict[str, dict] = {
     'zsh': {
         "name": "Zsh",
         "level": 2,
-        "layer": "Development Environment",
+        "layer": 'Development Runtime & Environment',
-        "role": "Shell",
+        "role": 'Shell',
-        "category": "Shell",
+        "category": 'Shell',
         "installer": {
             "type": "pacman",
             "pkg": "zsh"
@@ -473,9 +477,9 @@ TOOLS: dict[str, dict] = {
     'mksh': {
         "name": "mksh",
         "level": 2,
-        "layer": "Development Environment",
+        "layer": 'Development Runtime & Environment',
-        "role": "Shell",
+        "role": 'Shell',
-        "category": "Shell",
+        "category": 'Shell',
         "installer": {
             "type": "pacman",
             "pkg": "mksh"
@@ -501,9 +505,9 @@ TOOLS: dict[str, dict] = {
     'bash': {
         "name": "Bash",
         "level": 2,
-        "layer": "Development Environment",
+        "layer": 'Development Runtime & Environment',
-        "role": "Shell",
+        "role": 'Shell',
-        "category": "Shell",
+        "category": 'Shell',
         "installer": {
             "type": "pacman",
             "pkg": "bash"
@@ -529,9 +533,9 @@ TOOLS: dict[str, dict] = {
     'fish': {
         "name": "Fish",
         "level": 2,
-        "layer": "Development Environment",
+        "layer": 'Development Runtime & Environment',
-        "role": "Shell",
+        "role": 'Shell',
-        "category": "Shell",
+        "category": 'Shell',
         "installer": {
             "type": "pacman",
             "pkg": "fish"
@@ -557,9 +561,9 @@ TOOLS: dict[str, dict] = {
     'fakeroot': {
         "name": "Fakeroot",
         "level": 2,
-        "layer": "Development Environment",
+        "layer": 'Development Runtime & Environment',
-        "role": "Build Tool",
+        "role": 'Build Tool',
-        "category": "Build",
+        "category": 'Build',
         "installer": {
             "type": "pacman",
             "pkg": "fakeroot"
@@ -585,9 +589,9 @@ TOOLS: dict[str, dict] = {
     'make': {
         "name": "GNU Make",
         "level": 2,
-        "layer": "Development Environment",
+        "layer": 'Development Runtime & Environment',
-        "role": "Build System",
+        "role": 'Build System',
-        "category": "Build",
+        "category": 'Build',
         "installer": {
             "type": "pacman",
             "pkg": "make"
@@ -613,9 +617,9 @@ TOOLS: dict[str, dict] = {
     'cmake': {
         "name": "CMake",
         "level": 2,
-        "layer": "Development Environment",
+        "layer": 'Development Runtime & Environment',
-        "role": "Build System",
+        "role": 'Build System',
-        "category": "Build",
+        "category": 'Build',
         "installer": {
             "type": "pacman",
             "pkg": "cmake"
@@ -641,9 +645,9 @@ TOOLS: dict[str, dict] = {
     'gcc': {
         "name": "GCC",
         "level": 2,
-        "layer": "Development Environment",
+        "layer": 'Development Runtime & Environment',
-        "role": "Compiler",
+        "role": 'Compiler',
-        "category": "Build",
+        "category": 'Build',
         "installer": {
             "type": "pacman",
             "pkg": "gcc"
@@ -669,9 +673,9 @@ TOOLS: dict[str, dict] = {
     'bison': {
         "name": "Bison",
         "level": 2,
-        "layer": "Development Environment",
+        "layer": 'Development Runtime & Environment',
-        "role": "Parser Generator",
+        "role": 'Parser Generator',
-        "category": "Build",
+        "category": 'Build',
         "installer": {
             "type": "pacman",
             "pkg": "bison"
@@ -697,9 +701,9 @@ TOOLS: dict[str, dict] = {
     'pkg_config': {
         "name": "pkg-config",
         "level": 2,
-        "layer": "Development Environment",
+        "layer": 'Development Runtime & Environment',
-        "role": "Build Tool",
+        "role": 'Build Tool',
-        "category": "Build",
+        "category": 'Build',
         "installer": {
             "type": "pacman",
             "pkg": "pkg-config"
@@ -725,9 +729,9 @@ TOOLS: dict[str, dict] = {
     'valgrind': {
         "name": "Valgrind",
         "level": 2,
-        "layer": "Development Environment",
+        "layer": 'Development Runtime & Environment',
-        "role": "Profiling",
+        "role": 'Profiling',
-        "category": "Debugging",
+        "category": 'Debugging',
         "installer": {
             "type": "pacman",
             "pkg": "valgrind"
@@ -753,9 +757,9 @@ TOOLS: dict[str, dict] = {
     'gdb': {
         "name": "GDB",
         "level": 2,
-        "layer": "Development Environment",
+        "layer": 'Development Runtime & Environment',
-        "role": "Debugger",
+        "role": 'Debugger',
-        "category": "Debugging",
+        "category": 'Debugging',
         "installer": {
             "type": "pacman",
             "pkg": "gdb"
@@ -781,9 +785,9 @@ TOOLS: dict[str, dict] = {
     'strace': {
         "name": "strace",
         "level": 2,
-        "layer": "Development Environment",
+        "layer": 'Development Runtime & Environment',
-        "role": "Tracing",
+        "role": 'Tracing',
-        "category": "Debugging",
+        "category": 'Debugging',
         "installer": {
             "type": "pacman",
             "pkg": "strace"
@@ -809,9 +813,9 @@ TOOLS: dict[str, dict] = {
     'ltrace': {
         "name": "ltrace",
         "level": 2,
-        "layer": "Development Environment",
+        "layer": 'Development Runtime & Environment',
-        "role": "Tracing",
+        "role": 'Tracing',
-        "category": "Debugging",
+        "category": 'Debugging',
         "installer": {
             "type": "pacman",
             "pkg": "ltrace"
@@ -837,9 +841,9 @@ TOOLS: dict[str, dict] = {
     'patchelf': {
         "name": "PatchELF",
         "level": 2,
-        "layer": "Development Environment",
+        "layer": 'Development Runtime & Environment',
-        "role": "Binary Tool",
+        "role": 'Binary Tool',
-        "category": "Build",
+        "category": 'Build',
         "installer": {
             "type": "pacman",
             "pkg": "patchelf"
@@ -865,9 +869,9 @@ TOOLS: dict[str, dict] = {
     'upx': {
         "name": "UPX",
         "level": 2,
-        "layer": "Development Environment",
+        "layer": 'Development Runtime & Environment',
-        "role": "Packer",
+        "role": 'Packer',
-        "category": "Build",
+        "category": 'Build',
         "installer": {
             "type": "pacman",
             "pkg": "upx"
@@ -893,9 +897,9 @@ TOOLS: dict[str, dict] = {
     'deno': {
         "name": "Deno",
         "level": 2,
-        "layer": "Development Environment",
+        "layer": 'Development Runtime & Environment',
-        "role": "Language",
+        "role": 'Language',
-        "category": "Runtime",
+        "category": 'Runtime',
         "installer": {
             "type": "pacman",
             "pkg": "deno"
@@ -923,9 +927,9 @@ TOOLS: dict[str, dict] = {
     'uv': {
         "name": "uv",
         "level": 2,
-        "layer": "Development Environment",
+        "layer": 'Development Runtime & Environment',
-        "role": "Package Manager",
+        "role": 'Package Manager',
-        "category": "Build",
+        "category": 'Build',
         "installer": {
             "type": "pacman",
             "pkg": "uv"

src/ai_lsc/registry/layers/devops.py

@@ -7,15 +7,19 @@ qwen_code, goose, zcoder).
 
 This module is consumed by
 :mod:`ai_lsc.registry.loader`.
+
+Structural fields (layer, level) follow the 10-Layer Systems
+Architecture Taxonomy; tools may be regrouped across files in a
+future pass — the loader merges by tool, not by filename.
 """
 
 TOOLS: dict[str, dict] = {
     'terraform': {
     "name": "Terraform",
     "level": 10,
-    "layer": "DevOps",
+    "layer": 'Human Interface & System Operations',
-    "role": "Infrastructure as Code",
+    "role": 'Infrastructure Provision',
-    "category": "IaC",
+    "category": 'Infrastructure Provision',
     "installer": {
         "type": "pacman",
         "pkg": "terraform"
@@ -41,9 +45,9 @@ TOOLS: dict[str, dict] = {
     'ansible': {
     "name": "Ansible",
     "level": 10,
-    "layer": "DevOps",
+    "layer": 'Human Interface & System Operations',
-    "role": "Configuration Management",
+    "role": 'Agentless Deployment',
-    "category": "Config Management",
+    "category": 'Agentless Deployment',
     "installer": {
         "type": "pacman",
         "pkg": "ansible"
@@ -69,9 +73,9 @@ TOOLS: dict[str, dict] = {
     'puppet': {
     "name": "Puppet",
     "level": 10,
-    "layer": "DevOps",
+    "layer": 'Human Interface & System Operations',
-    "role": "Configuration Management",
+    "role": 'System Auditor',
-    "category": "Config Management",
+    "category": 'System Auditor',
     "installer": {
         "type": "pacman",
         "pkg": "puppet"
@@ -97,9 +101,9 @@ TOOLS: dict[str, dict] = {
     'pulumi': {
     "name": "Pulumi",
     "level": 10,
-    "layer": "DevOps",
+    "layer": 'Human Interface & System Operations',
-    "role": "Infrastructure as Code",
+    "role": 'Programmable IaC',
-    "category": "IaC",
+    "category": 'Programmable IaC',
     "installer": {
         "type": "npm",
         "pkg": "@pulumi/pulumi"
@@ -125,9 +129,9 @@ TOOLS: dict[str, dict] = {
     'bicep': {
     "name": "Bicep",
     "level": 10,
-    "layer": "DevOps",
+    "layer": 'Human Interface & System Operations',
-    "role": "Infrastructure as Code",
+    "role": 'Local Declarative DSL',
-    "category": "IaC",
+    "category": 'Local Declarative DSL',
     "installer": {
         "type": "npm",
         "pkg": "@azure/bicep"
@@ -153,12 +157,12 @@ TOOLS: dict[str, dict] = {
     'opentofu': {
     "name": "OpenTofu",
     "level": 10,
-    "layer": "DevOps",
+    "layer": 'Human Interface & System Operations',
-    "role": "Infrastructure as Code",
+    "role": 'Open-Source IaC',
-    "category": "IaC",
+    "category": 'Open-Source IaC',
     "installer": {
         "type": "custom",
-        "pkg": "https://opentofu.org/docs/intro/install/"
+        "pkg": "https://github.com/opentofu/opentofu"
     },
     "launcher": {
         "type": "desktop",
@@ -181,9 +185,9 @@ TOOLS: dict[str, dict] = {
     'aws_cdk': {
     "name": "AWS CDK",
     "level": 10,
-    "layer": "DevOps",
+    "layer": 'Human Interface & System Operations',
-    "role": "Infrastructure as Code",
+    "role": 'Cloud Dev Kit',
-    "category": "IaC",
+    "category": 'Cloud Dev Kit',
     "installer": {
         "type": "npm",
         "pkg": "aws-cdk"
@@ -209,12 +213,12 @@ TOOLS: dict[str, dict] = {
     'crossplane': {
     "name": "Crossplane",
     "level": 10,
-    "layer": "DevOps",
+    "layer": 'Human Interface & System Operations',
-    "role": "Infrastructure as Code",
+    "role": 'Infrastructure as Code',
-    "category": "IaC Control Plane",
+    "category": 'IaC Control Plane',
     "installer": {
         "type": "custom",
-        "pkg": "https://docs.crossplane.io/v2/getting-started/install/"
+        "pkg": "https://github.com/crossplane/crossplane"
     },
     "launcher": {
         "type": "desktop",
@@ -239,12 +243,12 @@ TOOLS: dict[str, dict] = {
     'terragrunt': {
     "name": "Terragrunt",
     "level": 10,
-    "layer": "DevOps",
+    "layer": 'Human Interface & System Operations',
-    "role": "Infrastructure as Code",
+    "role": 'IaC DRY Wrapper',
-    "category": "IaC Wrapper",
+    "category": 'IaC DRY Wrapper',
     "installer": {
         "type": "custom",
-        "pkg": "https://terragrunt.gruntwork.io/docs/getting-started/install/"
+        "pkg": "https://github.com/gruntwork-io/terragrunt"
     },
     "launcher": {
         "type": "desktop",
@@ -268,10 +272,10 @@ TOOLS: dict[str, dict] = {
 },
     'stack_exporter': {
     "name": "Stack Container Packager",
-    "level": 10,
+    "level": 1,
-    "layer": "DevOps",
+    "layer": 'Host Platform & Infrastructure',
-    "role": "Runtime Packaging",
+    "role": 'Runtime Packaging',
-    "category": "OCI Export",
+    "category": 'Runtime Packaging',
     "installer": {
         "type": "pacman",
         "pkg": "podman"
@@ -297,9 +301,9 @@ TOOLS: dict[str, dict] = {
     'homelab': {
     "name": "Homelab",
     "level": 10,
-    "layer": "DevOps",
+    "layer": 'Human Interface & System Operations',
-    "role": "Provisioning",
+    "role": 'Metal Provisioner',
-    "category": "Provisioning",
+    "category": 'Metal Provisioner',
     "installer": {
         "type": "git",
         "pkg": "https://github.com/khuedoan/homelab",
@@ -325,10 +329,10 @@ TOOLS: dict[str, dict] = {
 },
     'aider': {
     "name": "Aider",
-    "level": 10,
+    "level": 7,
-    "layer": "DevOps",
+    "layer": 'Agentic Software Engineering & Sandboxes',
-    "role": "Coding Agent",
+    "role": 'CLI Pair Programmer',
-    "category": "AI Coding Agent",
+    "category": 'CLI Pair Programmer',
     "installer": {
         "type": "uv",
         "pkg": "aider-chat"
@@ -354,10 +358,10 @@ TOOLS: dict[str, dict] = {
 
     'claude_code': {
     "name": "Claude Code",
-    "level": 10,
+    "level": 7,
-    "layer": "DevOps",
+    "layer": 'Agentic Software Engineering & Sandboxes',
-    "role": "Coding Agent",
+    "role": 'Terminal Coding Agent',
-    "category": "AI Coding Agent",
+    "category": 'Terminal Coding Agent',
     "installer": {
         "type": "npm",
         "pkg": "@anthropic-ai/claude-code"
@@ -383,10 +387,10 @@ TOOLS: dict[str, dict] = {
 
     'codex': {
     "name": "Codex",
-    "level": 10,
+    "level": 7,
-    "layer": "DevOps",
+    "layer": 'Agentic Software Engineering & Sandboxes',
-    "role": "Coding Agent",
+    "role": 'Codex Developer',
-    "category": "AI Coding Agent",
+    "category": 'Codex Developer',
     "installer": {
         "type": "npm",
         "pkg": "@openai/codex"
@@ -412,13 +416,13 @@ TOOLS: dict[str, dict] = {
 
     'openhands': {
     "name": "OpenHands",
-    "level": 10,
+    "level": 7,
-    "layer": "DevOps",
+    "layer": 'Agentic Software Engineering & Sandboxes',
-    "role": "Coding Agent",
+    "role": 'Sovereign Software Agent',
-    "category": "AI Coding Agent",
+    "category": 'Sovereign Software Agent',
     "installer": {
-        "type": "uv",
+        "type": "git_node",
-        "pkg": "openhands-ai"
+        "pkg": "https://github.com/All-Hands-AI/OpenHands.git"
     },
     "launcher": {
         "type": "tmux",
@@ -441,10 +445,10 @@ TOOLS: dict[str, dict] = {
 
     'opencode': {
     "name": "OpenCode",
-    "level": 10,
+    "level": 7,
-    "layer": "DevOps",
+    "layer": 'Agentic Software Engineering & Sandboxes',
-    "role": "Coding Agent",
+    "role": 'Coding Agent',
-    "category": "AI Coding Agent",
+    "category": 'AI Coding Agent',
     "installer": {
         "type": "npm",
         "pkg": "opencode-ai"
@@ -472,10 +476,10 @@ TOOLS: dict[str, dict] = {
 
     'gemini_cli': {
     "name": "Gemini CLI",
-    "level": 10,
+    "level": 7,
-    "layer": "DevOps",
+    "layer": 'Agentic Software Engineering & Sandboxes',
-    "role": "Coding Agent",
+    "role": 'Coding Agent',
-    "category": "AI Coding Agent",
+    "category": 'AI Coding Agent',
     "installer": {
         "type": "npm",
         "pkg": "@google/gemini-cli"
@@ -503,10 +507,10 @@ TOOLS: dict[str, dict] = {
 
     'qwen_code': {
     "name": "Qwen Code",
-    "level": 10,
+    "level": 7,
-    "layer": "DevOps",
+    "layer": 'Agentic Software Engineering & Sandboxes',
-    "role": "Coding Agent",
+    "role": 'Coding Agent',
-    "category": "AI Coding Agent",
+    "category": 'AI Coding Agent',
     "installer": {
         "type": "npm",
         "pkg": "@qwen-code/qwen-code"
@@ -534,10 +538,10 @@ TOOLS: dict[str, dict] = {
 
     'goose': {
     "name": "codename goose",
-    "level": 10,
+    "level": 7,
-    "layer": "DevOps",
+    "layer": 'Agentic Software Engineering & Sandboxes',
-    "role": "Coding Agent",
+    "role": 'Coding Agent',
-    "category": "AI Coding Agent",
+    "category": 'AI Coding Agent',
     "installer": {
         "type": "custom",
         "pkg": "https://github.com/block/goose"
@@ -566,10 +570,10 @@ TOOLS: dict[str, dict] = {
 # ---- zcoder -----------------------------------------------------------------
     'zcoder': {
     "name": "ZCoder",
-    "level": 10,
+    "level": 7,
-    "layer": "DevOps",
+    "layer": 'Agentic Software Engineering & Sandboxes',
-    "role": "Coding Agent",
+    "role": 'Coding Agent',
-    "category": "AI Coding Agent",
+    "category": 'AI Coding Agent',
     "installer": {
         "type": "npm",
         "pkg": "zcoder-cli"

src/ai_lsc/registry/layers/gpu.py

@@ -15,15 +15,19 @@ Each entry follows the standard registry schema:
 
 This module is consumed by
 :mod:`ai_lsc.registry.loader`.
+
+Structural fields (layer, level) follow the 10-Layer Systems
+Architecture Taxonomy; tools may be regrouped across files in a
+future pass — the loader merges by tool, not by filename.
 """
 
 TOOLS: dict[str, dict] = {
     'cuda': {
     "name": "CUDA Toolkit",
     "level": 3,
-    "layer": "GPU Runtimes",
+    "layer": 'GPU Acceleration & Optimization',
-    "role": "Acceleration",
+    "role": 'Hardware Acceleration',
-    "category": "GPU",
+    "category": 'Hardware Acceleration',
     "installer": {
         "type": "pacman",
         "pkg": "cuda"
@@ -49,9 +53,9 @@ TOOLS: dict[str, dict] = {
     'apex': {
     "name": "NVIDIA Apex",
     "level": 3,
-    "layer": "GPU Runtimes",
+    "layer": 'GPU Acceleration & Optimization',
-    "role": "Optimization",
+    "role": 'Mixed Precision',
-    "category": "Mixed Precision",
+    "category": 'Mixed Precision',
     "installer": {
         "type": "uv",
         "pkg": "apex"
@@ -79,9 +83,9 @@ TOOLS: dict[str, dict] = {
     'tinygrad': {
     "name": "tinygrad",
     "level": 3,
-    "layer": "GPU Runtimes",
+    "layer": 'GPU Acceleration & Optimization',
-    "role": "GPU Acceleration",
+    "role": 'GPU Acceleration',
-    "category": "GPU Computing",
+    "category": 'GPU Computing',
     "installer": {
         "type": "uv",
         "pkg": "tinygrad"

src/ai_lsc/registry/layers/host_platform.py

@@ -15,15 +15,19 @@ Each entry follows the standard registry schema:
 
 This module is consumed by
 :mod:`ai_lsc.registry.loader`.
+
+Structural fields (layer, level) follow the 10-Layer Systems
+Architecture Taxonomy; tools may be regrouped across files in a
+future pass — the loader merges by tool, not by filename.
 """
 
 TOOLS: dict[str, dict] = {
     'tmux': {
     "name": "Tmux",
     "level": 1,
-    "layer": "Host Platform",
+    "layer": 'Host Platform & Infrastructure',
-    "role": "Multiplexer",
+    "role": 'Multiplexer',
-    "category": "Terminal",
+    "category": 'Terminal',
     "installer": {
         "type": "pacman",
         "pkg": "tmux"
@@ -48,10 +52,10 @@ TOOLS: dict[str, dict] = {
 },
     'git': {
     "name": "Git",
-    "level": 1,
+    "level": 2,
-    "layer": "Host Platform",
+    "layer": 'Development Runtime & Environment',
-    "role": "Version Control",
+    "role": 'Version Control',
-    "category": "VCS",
+    "category": 'VCS',
     "installer": {
         "type": "pacman",
         "pkg": "git"
@@ -77,9 +81,9 @@ TOOLS: dict[str, dict] = {
     'podman': {
     "name": "Podman",
     "level": 1,
-    "layer": "Host Platform",
+    "layer": 'Host Platform & Infrastructure',
-    "role": "Container Runtime",
+    "role": 'Container Runtime',
-    "category": "Containers",
+    "category": 'Containers',
     "installer": {
         "type": "pacman",
         "pkg": "podman"
@@ -105,9 +109,9 @@ TOOLS: dict[str, dict] = {
     'docker': {
     "name": "Docker",
     "level": 1,
-    "layer": "Host Platform",
+    "layer": 'Host Platform & Infrastructure',
-    "role": "Container Runtime",
+    "role": 'Container Runtime',
-    "category": "Containers",
+    "category": 'Containers',
     "installer": {
         "type": "pacman",
         "pkg": "docker"
@@ -133,9 +137,9 @@ TOOLS: dict[str, dict] = {
     'postgresql': {
     "name": "PostgreSQL",
     "level": 1,
-    "layer": "Host Platform",
+    "layer": 'Host Platform & Infrastructure',
-    "role": "Foundation",
+    "role": 'Database',
-    "category": "Database",
+    "category": 'Database',
     "installer": {
         "type": "pacman",
         "pkg": "postgresql"
@@ -161,9 +165,9 @@ TOOLS: dict[str, dict] = {
     'mariadb': {
     "name": "MariaDB",
     "level": 1,
-    "layer": "Host Platform",
+    "layer": 'Host Platform & Infrastructure',
-    "role": "Foundation",
+    "role": 'Database',
-    "category": "Database",
+    "category": 'Database',
     "installer": {
         "type": "pacman",
         "pkg": "mariadb"
@@ -189,9 +193,9 @@ TOOLS: dict[str, dict] = {
     'redis': {
     "name": "Redis",
     "level": 1,
-    "layer": "Host Platform",
+    "layer": 'Host Platform & Infrastructure',
-    "role": "Foundation",
+    "role": 'Cache',
-    "category": "Cache",
+    "category": 'Cache',
     "installer": {
         "type": "pacman",
         "pkg": "redis"
@@ -217,9 +221,9 @@ TOOLS: dict[str, dict] = {
     'sqlite3': {
     "name": "SQLite3",
     "level": 1,
-    "layer": "Host Platform",
+    "layer": 'Host Platform & Infrastructure',
-    "role": "Foundation",
+    "role": 'Database',
-    "category": "Database",
+    "category": 'Database',
     "installer": {
         "type": "pacman",
         "pkg": "sqlite"
@@ -245,9 +249,9 @@ TOOLS: dict[str, dict] = {
     'duckdb': {
     "name": "DuckDB",
     "level": 1,
-    "layer": "Host Platform",
+    "layer": 'Host Platform & Infrastructure',
-    "role": "Foundation",
+    "role": 'Analytical Database',
-    "category": "Analytical Database",
+    "category": 'Analytical Database',
     "installer": {
         "type": "uv",
         "pkg": "duckdb"
@@ -273,9 +277,9 @@ TOOLS: dict[str, dict] = {
     'lxc': {
     "name": "LXC",
     "level": 1,
-    "layer": "Host Platform",
+    "layer": 'Host Platform & Infrastructure',
-    "role": "Container Runtime",
+    "role": 'Container Runtime',
-    "category": "Containers",
+    "category": 'Containers',
     "installer": {
         "type": "pacman",
         "pkg": "lxc"
@@ -301,9 +305,9 @@ TOOLS: dict[str, dict] = {
     'firecracker': {
     "name": "Firecracker",
     "level": 1,
-    "layer": "Host Platform",
+    "layer": 'Host Platform & Infrastructure',
-    "role": "MicroVM",
+    "role": 'MicroVM',
-    "category": "Virtualization",
+    "category": 'Virtualization',
     "installer": {
         "type": "script",
         "cmd": "mkdir -p {tools_root}/bin {tools_root}/firecracker && FC_VER=$(curl -sIL https://github.com/firecracker-microvm/firecracker/releases/latest | grep -i '^location:' | tail -1 | sed 's|.*/tag/||' | tr -d '\r') && curl -fsSL 'https://github.com/firecracker-microvm/firecracker/releases/download/$FC_VER/firecracker-$FC_VER-x86_64.tgz' | tar xz -C {tools_root}/firecracker --strip-components=1 && ln -sf {tools_root}/firecracker/firecracker-$FC_VER-x86_64 {tools_root}/bin/firecracker && ln -sf {tools_root}/firecracker/jailer-$FC_VER-x86_64 {tools_root}/bin/jailer"
@@ -329,9 +333,9 @@ TOOLS: dict[str, dict] = {
     'qemu': {
     "name": "QEMU",
     "level": 1,
-    "layer": "Host Platform",
+    "layer": 'Host Platform & Infrastructure',
-    "role": "Emulation",
+    "role": 'Emulation',
-    "category": "Virtualization",
+    "category": 'Virtualization',
     "installer": {
         "type": "pacman",
         "pkg": "qemu-base"
@@ -357,9 +361,9 @@ TOOLS: dict[str, dict] = {
     'libvirt': {
     "name": "libvirt",
     "level": 1,
-    "layer": "Host Platform",
+    "layer": 'Host Platform & Infrastructure',
-    "role": "VM Management",
+    "role": 'VM Management',
-    "category": "Virtualization",
+    "category": 'Virtualization',
     "installer": {
         "type": "pacman",
         "pkg": "libvirt"
@@ -385,9 +389,9 @@ TOOLS: dict[str, dict] = {
     'cloudflared': {
     "name": "Cloudflared",
     "level": 1,
-    "layer": "Host Platform",
+    "layer": 'Host Platform & Infrastructure',
-    "role": "Tunnel",
+    "role": 'Tunnel',
-    "category": "Networking",
+    "category": 'Networking',
     "installer": {
         "type": "script",
         "cmd": "mkdir -p {tools_root}/bin && curl -L https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64 -o {tools_root}/bin/cloudflared && chmod +x {tools_root}/bin/cloudflared"
@@ -413,9 +417,9 @@ TOOLS: dict[str, dict] = {
     'nginx': {
     "name": "Nginx",
     "level": 1,
-    "layer": "Host Platform",
+    "layer": 'Host Platform & Infrastructure',
-    "role": "Reverse Proxy",
+    "role": 'Reverse Proxy',
-    "category": "Networking",
+    "category": 'Networking',
     "installer": {
         "type": "pacman",
         "pkg": "nginx"
@@ -441,9 +445,9 @@ TOOLS: dict[str, dict] = {
     'certbot': {
     "name": "Certbot",
     "level": 1,
-    "layer": "Host Platform",
+    "layer": 'Host Platform & Infrastructure',
-    "role": "TLS",
+    "role": 'TLS',
-    "category": "Networking",
+    "category": 'Networking',
     "installer": {
         "type": "pacman",
         "pkg": "certbot"

src/ai_lsc/registry/layers/inference.py

@@ -15,18 +15,23 @@ Each entry follows the standard registry schema:
 
 This module is consumed by
 :mod:`ai_lsc.registry.loader`.
+
+Structural fields (layer, level) follow the 10-Layer Systems
+Architecture Taxonomy; tools may be regrouped across files in a
+future pass — the loader merges by tool, not by filename.
 """
 
 TOOLS: dict[str, dict] = {
     'ollama': {
     "name": "Ollama",
     "level": 4,
-    "layer": "Engines",
+    "layer": 'Local Inference Engines',
-    "role": "Engine",
+    "role": 'Local LLM Runner',
-    "category": "LLM Runtime",
+    "category": 'Local LLM Runner',
     "installer": {
         "type": "script",
-        "cmd": "curl -fsSL https://ollama.com/install.sh | sh"
+        "cmd": "curl -fsSL https://ollama.com/install.sh | sh",
+        "pkg": "https://github.com/ollama/ollama"
     },
     "launcher": {
         "type": "tmux",
@@ -49,12 +54,12 @@ TOOLS: dict[str, dict] = {
     'llamacpp': {
     "name": "llama.cpp",
     "level": 4,
-    "layer": "Engines",
+    "layer": 'Local Inference Engines',
-    "role": "Engine",
+    "role": 'Native Inference',
-    "category": "LLM Runtime",
+    "category": 'Native Inference',
     "installer": {
         "type": "git",
-        "pkg": "https://github.com/ggerganov/llama.cpp"
+        "pkg": "https://github.com/ggml-org/llama.cpp"
     },
     "launcher": {
         "type": "tmux",
@@ -77,9 +82,9 @@ TOOLS: dict[str, dict] = {
     'koboldcpp': {
     "name": "KoboldCPP",
     "level": 4,
-    "layer": "Engines",
+    "layer": 'Local Inference Engines',
-    "role": "Engine",
+    "role": 'GGUF Runtime',
-    "category": "LLM Runtime",
+    "category": 'GGUF Runtime',
     "installer": {
         "type": "git",
         "pkg": "https://github.com/LostRuins/koboldcpp"
@@ -105,12 +110,13 @@ TOOLS: dict[str, dict] = {
     'llamafile': {
     "name": "Llamafile",
     "level": 4,
-    "layer": "Engines",
+    "layer": 'Local Inference Engines',
-    "role": "Engine",
+    "role": 'Single-File Runtime',
-    "category": "Single-File LLM",
+    "category": 'Single-File Runtime',
     "installer": {
         "type": "script",
-        "cmd": "mkdir -p {tools_root}/bin && curl -L https://github.com/Mozilla-Ocho/llamafile/releases/latest/download/llamafile -o {tools_root}/bin/llamafile && chmod +x {tools_root}/bin/llamafile"
+        "cmd": "mkdir -p {tools_root}/bin && curl -L https://github.com/Mozilla-Ocho/llamafile/releases/latest/download/llamafile -o {tools_root}/bin/llamafile && chmod +x {tools_root}/bin/llamafile",
+        "pkg": "https://github.com/Mozilla-Ocho/llamafile"
     },
     "launcher": {
         "type": "desktop",
@@ -133,12 +139,12 @@ TOOLS: dict[str, dict] = {
     'turbollm': {
     "name": "TurboLLM",
     "level": 4,
-    "layer": "Engines",
+    "layer": 'Local Inference Engines',
-    "role": "Engine",
+    "role": 'Performance Engine',
-    "category": "LLM Runtime",
+    "category": 'Performance Engine',
     "installer": {
         "type": "git",
-        "pkg": "https://github.com/nicely-done/turbollm"
+        "pkg": "https://github.com/mohitsoni48/TurboLLM"
     },
     "launcher": {
         "type": "tmux",
@@ -163,12 +169,12 @@ TOOLS: dict[str, dict] = {
     'airllm': {
     "name": "AirLLM",
     "level": 4,
-    "layer": "Engines",
+    "layer": 'Local Inference Engines',
-    "role": "Engine",
+    "role": 'Layer-wise Inference',
-    "category": "Efficient LLM",
+    "category": 'Layer-wise Inference',
     "installer": {
         "type": "git",
-        "pkg": "https://github.com/liguodongiot/llm-airforce"
+        "pkg": "https://github.com/lyogavin/airllm"
     },
     "launcher": {
         "type": "tmux",
@@ -193,12 +199,12 @@ TOOLS: dict[str, dict] = {
     'locally_uncensored': {
     "name": "Locally-Uncensored",
     "level": 4,
-    "layer": "Engines",
+    "layer": 'Local Inference Engines',
-    "role": "Engine",
+    "role": 'Model Curation',
-    "category": "Uncensored Models",
+    "category": 'Model Curation',
     "installer": {
         "type": "git",
-        "pkg": "https://github.com/nicely-done/locally-uncensored"
+        "pkg": "https://github.com/PurpleDoubleD/locally-uncensored"
     },
     "launcher": {
         "type": "desktop",
@@ -223,9 +229,9 @@ TOOLS: dict[str, dict] = {
     'heretic': {
     "name": "Heretic",
     "level": 4,
-    "layer": "Engines",
+    "layer": 'Local Inference Engines',
-    "role": "Abliteration",
+    "role": 'Model Surgery',
-    "category": "Model Surgery",
+    "category": 'Model Surgery',
     "installer": {
         "type": "git",
         "pkg": "https://github.com/p-e-w/heretic",
@@ -254,9 +260,9 @@ TOOLS: dict[str, dict] = {
     'vllm': {
     "name": "vLLM",
     "level": 4,
-    "layer": "Engines",
+    "layer": 'Local Inference Engines',
-    "role": "Engine",
+    "role": 'Datacenter Inference',
-    "category": "LLM Serving",
+    "category": 'Datacenter Inference',
     "installer": {
         "type": "uv",
         "pkg": "vllm"
@@ -285,9 +291,9 @@ TOOLS: dict[str, dict] = {
     'sglang': {
     "name": "SGLang",
     "level": 4,
-    "layer": "Engines",
+    "layer": 'Local Inference Engines',
-    "role": "Engine",
+    "role": 'Engine',
-    "category": "LLM Serving",
+    "category": 'LLM Serving',
     "installer": {
         "type": "uv",
         "pkg": "sglang"

src/ai_lsc/registry/layers/knowledge_management.py

@@ -5,15 +5,19 @@ data pipelines, memory systems, and knowledge management tools.
 
 This module is consumed by
 :mod:`ai_lsc.registry.loader`.
+
+Structural fields (layer, level) follow the 10-Layer Systems
+Architecture Taxonomy; tools may be regrouped across files in a
+future pass — the loader merges by tool, not by filename.
 """
 
 TOOLS: dict[str, dict] = {
     'zotero': {
     "name": "Zotero",
-    "level": 11,
+    "level": 10,
-    "layer": "Knowledge Management",
+    "layer": 'Human Interface & System Operations',
-    "role": "Reference Manager",
+    "role": 'Reference Manager',
-    "category": "Academic References",
+    "category": 'Reference Manager',
     "installer": {
         "type": "pacman",
         "pkg": "zotero"
@@ -38,10 +42,10 @@ TOOLS: dict[str, dict] = {
 },
     'calibre': {
     "name": "Calibre",
-    "level": 11,
+    "level": 10,
-    "layer": "Knowledge Management",
+    "layer": 'Human Interface & System Operations',
-    "role": "Library Manager",
+    "role": 'Library Manager',
-    "category": "Ebook Library",
+    "category": 'Library Manager',
     "installer": {
         "type": "pacman",
         "pkg": "calibre"
@@ -66,10 +70,10 @@ TOOLS: dict[str, dict] = {
 },
     'paperlessngx': {
     "name": "Paperless-ngx",
-    "level": 11,
+    "level": 10,
-    "layer": "Knowledge Management",
+    "layer": 'Human Interface & System Operations',
-    "role": "Document Archive",
+    "role": 'Document Archiver',
-    "category": "Document Management",
+    "category": 'Document Archiver',
     "installer": {
         "type": "git",
         "pkg": "https://github.com/paperless-ngx/paperless-ngx"
@@ -97,10 +101,10 @@ TOOLS: dict[str, dict] = {
 },
     'logseq': {
     "name": "Logseq",
-    "level": 11,
+    "level": 10,
-    "layer": "Knowledge Management",
+    "layer": 'Human Interface & System Operations',
-    "role": "Knowledge Graph",
+    "role": 'Outliner Graph',
-    "category": "Outliner",
+    "category": 'Outliner Graph',
     "installer": {
         "type": "npm",
         "pkg": "logseq"
@@ -125,10 +129,10 @@ TOOLS: dict[str, dict] = {
 },
     'joplin': {
     "name": "Joplin",
-    "level": 11,
+    "level": 10,
-    "layer": "Knowledge Management",
+    "layer": 'Human Interface & System Operations',
-    "role": "Note Taking",
+    "role": 'Offline Journal',
-    "category": "Notes",
+    "category": 'Offline Journal',
     "installer": {
         "type": "pacman",
         "pkg": "joplin"
@@ -153,10 +157,10 @@ TOOLS: dict[str, dict] = {
 },
     'chromadb': {
     "name": "ChromaDB",
-    "level": 11,
+    "level": 8,
-    "layer": "Knowledge Management",
+    "layer": 'Decentralized Knowledge & Vector Stores',
-    "role": "Memory",
+    "role": 'Vector Engine',
-    "category": "Vector Store",
+    "category": 'Vector Engine',
     "installer": {
         "type": "uv",
         "pkg": "chromadb"
@@ -181,10 +185,10 @@ TOOLS: dict[str, dict] = {
 },
     'lancedb': {
     "name": "LanceDB",
-    "level": 11,
+    "level": 8,
-    "layer": "Knowledge Management",
+    "layer": 'Decentralized Knowledge & Vector Stores',
-    "role": "Memory",
+    "role": 'Serverless Database',
-    "category": "Vector Store",
+    "category": 'Serverless Database',
     "installer": {
         "type": "uv",
         "pkg": "lancedb"
@@ -209,13 +213,14 @@ TOOLS: dict[str, dict] = {
 },
     'qdrant': {
     "name": "Qdrant",
-    "level": 11,
+    "level": 8,
-    "layer": "Knowledge Management",
+    "layer": 'Decentralized Knowledge & Vector Stores',
-    "role": "Memory",
+    "role": 'High-Performance Vector',
-    "category": "Vector Store",
+    "category": 'High-Performance Vector',
     "installer": {
         "type": "script",
-        "cmd": "curl -L https://github.com/qdrant/qdrant/releases/latest/download/qdrant-x86_64-unknown-linux-musl.tar.gz | tar xz -C {tools_root}/qdrant && chmod +x {tools_root}/qdrant/qdrant"
+        "cmd": "curl -L https://github.com/qdrant/qdrant/releases/latest/download/qdrant-x86_64-unknown-linux-musl.tar.gz | tar xz -C {tools_root}/qdrant && chmod +x {tools_root}/qdrant/qdrant",
+        "pkg": "https://github.com/qdrant/qdrant"
     },
     "launcher": {
         "type": "tmux",
@@ -242,10 +247,10 @@ TOOLS: dict[str, dict] = {
 },
     'neo4j': {
     "name": "Neo4j",
-    "level": 11,
+    "level": 8,
-    "layer": "Knowledge Management",
+    "layer": 'Decentralized Knowledge & Vector Stores',
-    "role": "Memory",
+    "role": 'Graph Database',
-    "category": "Graph Database",
+    "category": 'Graph Database',
     "installer": {
         "type": "pacman",
         "pkg": "neo4j"
@@ -270,10 +275,10 @@ TOOLS: dict[str, dict] = {
 },
     'elasticsearch': {
     "name": "Elasticsearch",
-    "level": 11,
+    "level": 8,
-    "layer": "Knowledge Management",
+    "layer": 'Decentralized Knowledge & Vector Stores',
-    "role": "Memory",
+    "role": 'Distributed Search',
-    "category": "Search Engine",
+    "category": 'Distributed Search',
     "installer": {
         "type": "pacman",
         "pkg": "elasticsearch"
@@ -298,13 +303,14 @@ TOOLS: dict[str, dict] = {
 },
     'meilisearch': {
     "name": "Meilisearch",
-    "level": 11,
+    "level": 8,
-    "layer": "Knowledge Management",
+    "layer": 'Decentralized Knowledge & Vector Stores',
-    "role": "Memory",
+    "role": 'Lexical Search',
-    "category": "Search Engine",
+    "category": 'Lexical Search',
     "installer": {
         "type": "script",
-        "cmd": "mkdir -p {tools_root}/bin && cd {tools_root}/bin && curl -L https://install.meilisearch.com | sh"
+        "cmd": "mkdir -p {tools_root}/bin && cd {tools_root}/bin && curl -L https://install.meilisearch.com | sh",
+        "pkg": "https://github.com/meilisearch/meilisearch"
     },
     "launcher": {
         "type": "tmux",
@@ -326,10 +332,10 @@ TOOLS: dict[str, dict] = {
 },
     'graphrag': {
     "name": "GraphRAG",
-    "level": 11,
+    "level": 8,
-    "layer": "Knowledge Management",
+    "layer": 'Decentralized Knowledge & Vector Stores',
-    "role": "Knowledge Synthesis",
+    "role": 'Structured Synthesis',
-    "category": "Graph RAG",
+    "category": 'Structured Synthesis',
     "installer": {
         "type": "uv",
         "pkg": "graphrag"
@@ -354,13 +360,13 @@ TOOLS: dict[str, dict] = {
 },
     'turbovec': {
     "name": "TurboVec",
-    "level": 11,
+    "level": 8,
-    "layer": "Knowledge Management",
+    "layer": 'Decentralized Knowledge & Vector Stores',
-    "role": "Embedding",
+    "role": 'Embedding',
-    "category": "Vector Engine",
+    "category": 'Vector Engine',
     "installer": {
         "type": "git",
-        "pkg": "https://github.com/nicely-done/turbovec"
+        "pkg": "https://github.com/ryancodrai/turbovec"
     },
     "launcher": {
         "type": "tmux",
@@ -384,13 +390,13 @@ TOOLS: dict[str, dict] = {
 },
     'airweave': {
     "name": "Airweave",
-    "level": 11,
+    "level": 9,
-    "layer": "Knowledge Management",
+    "layer": 'Data Extraction & Pipeline Harvest',
-    "role": "Integration",
+    "role": 'Synchronization Layer',
-    "category": "Data Sync",
+    "category": 'Synchronization Layer',
     "installer": {
         "type": "git",
-        "pkg": "https://github.com/nicely-done/airweave"
+        "pkg": "https://github.com/airweave-ai/airweave"
     },
     "launcher": {
         "type": "tmux",
@@ -412,10 +418,10 @@ TOOLS: dict[str, dict] = {
 },
     'crawl4ai': {
     "name": "Crawl4AI",
-    "level": 11,
+    "level": 9,
-    "layer": "Knowledge Management",
+    "layer": 'Data Extraction & Pipeline Harvest',
-    "role": "Data Harvesting",
+    "role": 'Web Scraper',
-    "category": "Web Crawler",
+    "category": 'Web Scraper',
     "installer": {
         "type": "uv",
         "pkg": "crawl4ai"
@@ -440,10 +446,10 @@ TOOLS: dict[str, dict] = {
 },
     'docling': {
     "name": "Docling",
-    "level": 11,
+    "level": 9,
-    "layer": "Knowledge Management",
+    "layer": 'Data Extraction & Pipeline Harvest',
-    "role": "Memory",
+    "role": 'Document Parser',
-    "category": "File Parsing",
+    "category": 'Document Parser',
     "installer": {
         "type": "uv",
         "pkg": "docling"
@@ -468,10 +474,10 @@ TOOLS: dict[str, dict] = {
 },
     'markitdown': {
     "name": "MarkItDown",
-    "level": 11,
+    "level": 9,
-    "layer": "Knowledge Management",
+    "layer": 'Data Extraction & Pipeline Harvest',
-    "role": "File Parsing",
+    "role": 'Markdown Converter',
-    "category": "Document Converter",
+    "category": 'Markdown Converter',
     "installer": {
         "type": "uv",
         "pkg": "markitdown"
@@ -496,13 +502,13 @@ TOOLS: dict[str, dict] = {
 },
     'opendataloader': {
     "name": "OpenDataLoader",
-    "level": 11,
+    "level": 9,
-    "layer": "Knowledge Management",
+    "layer": 'Data Extraction & Pipeline Harvest',
-    "role": "Ingestion",
+    "role": 'Data Ingest',
-    "category": "Data Pipeline",
+    "category": 'Data Ingest',
     "installer": {
         "type": "git",
-        "pkg": "https://github.com/nicely-done/opendataloader"
+        "pkg": "https://github.com/opendataloader-project/opendataloader-pdf"
     },
     "launcher": {
         "type": "desktop",
@@ -524,10 +530,10 @@ TOOLS: dict[str, dict] = {
 },
     'whisper': {
     "name": "Whisper",
-    "level": 11,
+    "level": 9,
-    "layer": "Knowledge Management",
+    "layer": 'Data Extraction & Pipeline Harvest',
-    "role": "Memory",
+    "role": 'Audio Extraction',
-    "category": "Audio Parsing",
+    "category": 'Audio Extraction',
     "installer": {
         "type": "uv",
         "pkg": "openai-whisper"
@@ -552,10 +558,10 @@ TOOLS: dict[str, dict] = {
 },
     'mnemosyne': {
     "name": "Mnemosyne",
-    "level": 11,
+    "level": 10,
-    "layer": "Knowledge Management",
+    "layer": 'Human Interface & System Operations',
-    "role": "Memory",
+    "role": 'Learning Cards',
-    "category": "Spaced Repetition",
+    "category": 'Learning Cards',
     "installer": {
         "type": "pipx",
         "pkg": "mnemosyne"
@@ -580,13 +586,13 @@ TOOLS: dict[str, dict] = {
 },
     'mnemo_cortex': {
     "name": "Mnemo Cortex",
-    "level": 11,
+    "level": 8,
-    "layer": "Knowledge Management",
+    "layer": 'Decentralized Knowledge & Vector Stores',
-    "role": "Memory",
+    "role": 'Memory',
-    "category": "Cortex Memory",
+    "category": 'Cortex Memory',
     "installer": {
         "type": "git",
-        "pkg": "https://github.com/nicely-done/mnemo-cortex"
+        "pkg": "https://github.com/GuyMannDude/mnemo-cortex"
     },
     "launcher": {
         "type": "tmux",
@@ -610,13 +616,13 @@ TOOLS: dict[str, dict] = {
 },
     'everos_memory': {
     "name": "EverOS Memory",
-    "level": 11,
+    "level": 8,
-    "layer": "Knowledge Management",
+    "layer": 'Decentralized Knowledge & Vector Stores',
-    "role": "Memory",
+    "role": 'Memory',
-    "category": "Persistent Memory",
+    "category": 'Persistent Memory',
     "installer": {
         "type": "git",
-        "pkg": "https://github.com/nicely-done/everos-memory"
+        "pkg": "https://github.com/EverMind-AI/EverOS"
     },
     "launcher": {
         "type": "tmux",
@@ -638,13 +644,13 @@ TOOLS: dict[str, dict] = {
 },
     'mirofish': {
     "name": "Mirofish",
-    "level": 11,
+    "level": 9,
-    "layer": "Knowledge Management",
+    "layer": 'Data Extraction & Pipeline Harvest',
-    "role": "Transform",
+    "role": 'ETL Transformation',
-    "category": "Data Pipeline",
+    "category": 'ETL Transformation',
     "installer": {
         "type": "git",
-        "pkg": "https://github.com/nicely-done/mirofish"
+        "pkg": "https://github.com/666ghj/MiroFish"
     },
     "launcher": {
         "type": "desktop",
@@ -666,13 +672,13 @@ TOOLS: dict[str, dict] = {
 },
     'opendataloader_pdf': {
     "name": "OpenDataLoader PDF",
-    "level": 11,
+    "level": 9,
-    "layer": "Knowledge Management",
+    "layer": 'Data Extraction & Pipeline Harvest',
-    "role": "Extraction",
+    "role": 'PDF Processing',
-    "category": "PDF Pipeline",
+    "category": 'PDF Processing',
     "installer": {
         "type": "git",
-        "pkg": "https://github.com/nicely-done/opendataloader-pdf"
+        "pkg": "https://github.com/opendataloader-project/opendataloader-pdf"
     },
     "launcher": {
         "type": "desktop",
@@ -694,13 +700,13 @@ TOOLS: dict[str, dict] = {
 },
     'understand_anything': {
     "name": "Understand Anything",
-    "level": 11,
+    "level": 9,
-    "layer": "Knowledge Management",
+    "layer": 'Data Extraction & Pipeline Harvest',
-    "role": "Comprehension",
+    "role": 'Document Comprehension',
-    "category": "Document Understanding",
+    "category": 'Document Comprehension',
     "installer": {
         "type": "git",
-        "pkg": "https://github.com/nicely-done/understand-anything"
+        "pkg": "https://github.com/Egonex-AI/Understand-Anything"
     },
     "launcher": {
         "type": "desktop",
@@ -724,10 +730,10 @@ TOOLS: dict[str, dict] = {
 },
     'mem0': {
     "name": "Mem0",
-    "level": 11,
+    "level": 8,
-    "layer": "Knowledge Management",
+    "layer": 'Decentralized Knowledge & Vector Stores',
-    "role": "Memory",
+    "role": 'Memory',
-    "category": "Memory System",
+    "category": 'Memory System',
     "installer": {
         "type": "uv",
         "pkg": "mem0ai"

src/ai_lsc/registry/layers/observability.py

@@ -5,15 +5,19 @@ evaluation, and build/system monitoring tools.
 
 This module is consumed by
 :mod:`ai_lsc.registry.loader`.
+
+Structural fields (layer, level) follow the 10-Layer Systems
+Architecture Taxonomy; tools may be regrouped across files in a
+future pass — the loader merges by tool, not by filename.
 """
 
 TOOLS: dict[str, dict] = {
     'btop': {
     "name": "Btop",
-    "level": 8,
+    "level": 10,
-    "layer": "Observability",
+    "layer": 'Human Interface & System Operations',
-    "role": "Dashboard",
+    "role": 'Dashboard',
-    "category": "Metrics",
+    "category": 'Metrics',
     "installer": {
         "type": "pacman",
         "pkg": "btop"
@@ -38,10 +42,10 @@ TOOLS: dict[str, dict] = {
 },
     'glances': {
     "name": "Glances",
-    "level": 8,
+    "level": 10,
-    "layer": "Observability",
+    "layer": 'Human Interface & System Operations',
-    "role": "Dashboard",
+    "role": 'Telemetry Monitor',
-    "category": "Metrics",
+    "category": 'Telemetry Monitor',
     "installer": {
         "type": "pacman",
         "pkg": "glances"
@@ -66,10 +70,10 @@ TOOLS: dict[str, dict] = {
 },
     'prometheus': {
     "name": "Prometheus",
-    "level": 8,
+    "level": 10,
-    "layer": "Observability",
+    "layer": 'Human Interface & System Operations',
-    "role": "Metrics Collector",
+    "role": 'Metric Scraper',
-    "category": "Metrics",
+    "category": 'Metric Scraper',
     "installer": {
         "type": "pacman",
         "pkg": "prometheus"
@@ -94,10 +98,10 @@ TOOLS: dict[str, dict] = {
 },
     'grafana': {
     "name": "Grafana",
-    "level": 8,
+    "level": 10,
-    "layer": "Observability",
+    "layer": 'Human Interface & System Operations',
-    "role": "Dashboard",
+    "role": 'Telemetry Visualizer',
-    "category": "Visualization",
+    "category": 'Telemetry Visualizer',
     "installer": {
         "type": "pacman",
         "pkg": "grafana"
@@ -122,13 +126,14 @@ TOOLS: dict[str, dict] = {
 },
     'grafana_alloy': {
     "name": "Grafana Alloy",
-    "level": 8,
+    "level": 10,
-    "layer": "Observability",
+    "layer": 'Human Interface & System Operations',
-    "role": "Collector",
+    "role": 'Alloy Telemetry',
-    "category": "Telemetry",
+    "category": 'Alloy Telemetry',
     "installer": {
         "type": "script",
-        "cmd": "mkdir -p {tools_root}/bin {tools_root}/alloy && curl -fsSL https://github.com/grafana/alloy/releases/latest/download/alloy-linux-amd64.zip -o {tools_root}/alloy/alloy.zip && python3 -m zipfile -e {tools_root}/alloy/alloy.zip {tools_root}/alloy && mv {tools_root}/alloy/alloy-linux-amd64 {tools_root}/bin/alloy && chmod +x {tools_root}/bin/alloy"
+        "cmd": "mkdir -p {tools_root}/bin {tools_root}/alloy && curl -fsSL https://github.com/grafana/alloy/releases/latest/download/alloy-linux-amd64.zip -o {tools_root}/alloy/alloy.zip && python3 -m zipfile -e {tools_root}/alloy/alloy.zip {tools_root}/alloy && mv {tools_root}/alloy/alloy-linux-amd64 {tools_root}/bin/alloy && chmod +x {tools_root}/bin/alloy",
+        "pkg": "https://github.com/grafana/alloy"
     },
     "launcher": {
         "type": "tmux",
@@ -152,10 +157,10 @@ TOOLS: dict[str, dict] = {
 },
     'opik': {
     "name": "Opik",
-    "level": 8,
+    "level": 10,
-    "layer": "Observability",
+    "layer": 'Human Interface & System Operations',
-    "role": "LLM Tracing",
+    "role": 'LLM Observability',
-    "category": "AI Observability",
+    "category": 'LLM Observability',
     "installer": {
         "type": "uv",
         "pkg": "opik"
@@ -180,13 +185,13 @@ TOOLS: dict[str, dict] = {
 },
     'pulse_ai': {
     "name": "Pulse AI",
-    "level": 8,
+    "level": 10,
-    "layer": "Observability",
+    "layer": 'Human Interface & System Operations',
-    "role": "Health Monitor",
+    "role": 'Auto Recovery Daemon',
-    "category": "AI Monitoring",
+    "category": 'Auto Recovery Daemon',
     "installer": {
         "type": "git",
-        "pkg": "https://github.com/nicely-done/pulse-ai"
+        "pkg": "https://github.com/glieai/pulse-ai"
     },
     "launcher": {
         "type": "tmux",
@@ -208,13 +213,13 @@ TOOLS: dict[str, dict] = {
 },
     'latitude': {
     "name": "Latitude",
-    "level": 8,
+    "level": 10,
-    "layer": "Observability",
+    "layer": 'Human Interface & System Operations',
-    "role": "Evaluation",
+    "role": 'Output Evaluator',
-    "category": "LLM Evaluation",
+    "category": 'Output Evaluator',
     "installer": {
         "type": "git",
-        "pkg": "https://github.com/nicely-done/latitude"
+        "pkg": "https://github.com/latitude-dev/latitude-llm"
     },
     "launcher": {
         "type": "tmux",
@@ -238,13 +243,13 @@ TOOLS: dict[str, dict] = {
 },
     'eagle_eye': {
     "name": "Eagle Eye",
-    "level": 8,
+    "level": 10,
-    "layer": "Observability",
+    "layer": 'Human Interface & System Operations',
-    "role": "Monitoring",
+    "role": 'Monitoring',
-    "category": "Observability",
+    "category": 'Observability',
     "installer": {
         "type": "git",
-        "pkg": "https://github.com/nicely-done/eagle_eye"
+        "pkg": "https://github.com/thoughtfuldev/eagleeye"
     },
     "launcher": {
         "type": "desktop",
@@ -267,13 +272,13 @@ TOOLS: dict[str, dict] = {
 
     'dma': {
     "name": "DMA (Distcc Monitor Agent)",
-    "level": 8,
+    "level": 2,
-    "layer": "Observability",
+    "layer": 'Development Runtime & Environment',
-    "role": "Monitoring",
+    "role": 'Monitoring',
-    "category": "Build Monitoring",
+    "category": 'Build Monitoring',
     "installer": {
         "type": "git",
-        "pkg": "https://github.com/distcc/dma"
+        "pkg": "https://github.com/distcc/distcc"
     },
     "launcher": {
         "type": "desktop",

src/ai_lsc/registry/layers/orchestrators.py

@@ -7,15 +7,19 @@ coding agents to DevOps in the 11-layer taxonomy.)
 
 This module is consumed by
 :mod:`ai_lsc.registry.loader`.
+
+Structural fields (layer, level) follow the 10-Layer Systems
+Architecture Taxonomy; tools may be regrouped across files in a
+future pass — the loader merges by tool, not by filename.
 """
 
 TOOLS: dict[str, dict] = {
     'distcc': {
     "name": "DistCC",
-    "level": 6,
+    "level": 2,
-    "layer": "Orchestrators",
+    "layer": 'Development Runtime & Environment',
-    "role": "Distribution",
+    "role": 'Distribution',
-    "category": "Distributed Compilation",
+    "category": 'Distributed Compilation',
     "installer": {
         "type": "pacman",
         "pkg": "distcc"
@@ -41,9 +45,9 @@ TOOLS: dict[str, dict] = {
     'ray': {
     "name": "Ray",
     "level": 6,
-    "layer": "Orchestrators",
+    "layer": 'Multi-Agent Orchestration Runtimes',
-    "role": "Scaling",
+    "role": 'Scaling',
-    "category": "Distributed Compute",
+    "category": 'Distributed Compute',
     "installer": {
         "type": "uv",
         "pkg": "ray"
@@ -68,10 +72,10 @@ TOOLS: dict[str, dict] = {
 },
     'pssh': {
     "name": "PSSH (Parallel SSH)",
-    "level": 6,
+    "level": 10,
-    "layer": "Orchestrators",
+    "layer": 'Human Interface & System Operations',
-    "role": "Coordination",
+    "role": 'Coordination',
-    "category": "Cluster SSH",
+    "category": 'Cluster SSH',
     "installer": {
         "type": "pacman",
         "pkg": "pssh"
@@ -97,9 +101,9 @@ TOOLS: dict[str, dict] = {
     'langchain': {
     "name": "LangChain",
     "level": 6,
-    "layer": "Orchestrators",
+    "layer": 'Multi-Agent Orchestration Runtimes',
-    "role": "Orchestration",
+    "role": 'Integration Library',
-    "category": "LLM Framework",
+    "category": 'Integration Library',
     "installer": {
         "type": "uv",
         "pkg": "langchain"
@@ -124,10 +128,10 @@ TOOLS: dict[str, dict] = {
 },
     'langflow': {
     "name": "LangFlow",
-    "level": 6,
+    "level": 10,
-    "layer": "Orchestrators",
+    "layer": 'Human Interface & System Operations',
-    "role": "Visual Builder",
+    "role": 'RAG Flow Canvas',
-    "category": "Workflow",
+    "category": 'RAG Flow Canvas',
     "installer": {
         "type": "uv",
         "pkg": "langflow"
@@ -153,9 +157,9 @@ TOOLS: dict[str, dict] = {
     'crewai': {
     "name": "CrewAI",
     "level": 6,
-    "layer": "Orchestrators",
+    "layer": 'Multi-Agent Orchestration Runtimes',
-    "role": "Brain",
+    "role": 'Role-Playing Agent',
-    "category": "Agent Workflow",
+    "category": 'Role-Playing Agent',
     "installer": {
         "type": "uv",
         "pkg": "crewai"
@@ -181,9 +185,9 @@ TOOLS: dict[str, dict] = {
     'autogen': {
     "name": "AutoGen",
     "level": 6,
-    "layer": "Orchestrators",
+    "layer": 'Multi-Agent Orchestration Runtimes',
-    "role": "Brain",
+    "role": 'Multi-Agent Framework',
-    "category": "Agent Workflow",
+    "category": 'Multi-Agent Framework',
     "installer": {
         "type": "uv",
         "pkg": "pyautogen"
@@ -209,9 +213,9 @@ TOOLS: dict[str, dict] = {
     'openai_swarm': {
     "name": "OpenAI Swarm",
     "level": 6,
-    "layer": "Orchestrators",
+    "layer": 'Multi-Agent Orchestration Runtimes',
-    "role": "Multi-Agent",
+    "role": 'Stateless Orchestration',
-    "category": "Agent Framework",
+    "category": 'Stateless Orchestration',
     "installer": {
         "type": "uv",
         "pkg": "swarm"
@@ -237,12 +241,12 @@ TOOLS: dict[str, dict] = {
     'agno': {
     "name": "Agno",
     "level": 6,
-    "layer": "Orchestrators",
+    "layer": 'Multi-Agent Orchestration Runtimes',
-    "role": "Agent Framework",
+    "role": 'Production Multi-Agent',
-    "category": "AI Agent",
+    "category": 'Production Multi-Agent',
     "installer": {
-        "type": "uv",
+        "type": "git",
-        "pkg": "agno"
+        "pkg": "https://github.com/agno-agi/agno"
     },
     "launcher": {
         "type": "desktop",
@@ -265,9 +269,9 @@ TOOLS: dict[str, dict] = {
     'nvidia_agent_skills': {
     "name": "NVIDIA Agent Skills",
     "level": 6,
-    "layer": "Orchestrators",
+    "layer": 'Multi-Agent Orchestration Runtimes',
-    "role": "Tool Integration",
+    "role": 'Tool Integration',
-    "category": "Agent Toolkit",
+    "category": 'Agent Toolkit',
     "installer": {
         "type": "git",
         "pkg": "https://github.com/NVIDIA/agent-skills"
@@ -295,12 +299,12 @@ TOOLS: dict[str, dict] = {
     'openbrain': {
     "name": "OpenBrain",
     "level": 6,
-    "layer": "Orchestrators",
+    "layer": 'Multi-Agent Orchestration Runtimes',
-    "role": "Brain",
+    "role": 'Brain',
-    "category": "Reasoning Engine",
+    "category": 'Reasoning Engine',
     "installer": {
         "type": "git",
-        "pkg": "https://github.com/nicely-done/openbrain"
+        "pkg": "https://github.com/NateBJones-Projects/OB1"
     },
     "launcher": {
         "type": "tmux",
@@ -325,9 +329,9 @@ TOOLS: dict[str, dict] = {
     'odysseus': {
     "name": "Odysseus",
     "level": 6,
-    "layer": "Orchestrators",
+    "layer": 'Multi-Agent Orchestration Runtimes',
-    "role": "Reasoning",
+    "role": 'Reasoning',
-    "category": "Agent Workflow",
+    "category": 'Agent Workflow',
     "installer": {
         "type": "uv",
         "pkg": "odysseus"
@@ -340,7 +344,12 @@ TOOLS: dict[str, dict] = {
     "deps": [
         "ollama"
     ],
-    "description": "Local reasoning and orchestration agent.",
+    "filesystem": {
+        "install": "tools/odysseus",
+        "config": "configs/odysseus",
+        "logs": "logs/odysseus",
+    },
+"description": "Local reasoning and orchestration agent.",
     "license": 'MIT',
     "flags": {
         "has_cli": False,
@@ -354,10 +363,10 @@ TOOLS: dict[str, dict] = {
 },
     'n8n': {
     "name": "n8n",
-    "level": 6,
+    "level": 10,
-    "layer": "Orchestrators",
+    "layer": 'Human Interface & System Operations',
-    "role": "Workflow Orchestrator",
+    "role": 'Workflow Orchestrator',
-    "category": "Workflow Automation",
+    "category": 'Workflow',
     "installer": {
         "type": "npm",
         "pkg": "n8n",
@@ -371,7 +380,12 @@ TOOLS: dict[str, dict] = {
         "default_port": 5678
     },
     "deps": [],
-    "description": "Ops-oriented workflow automation for multi-step agent orchestration beyond single-turn tool calls.",
+    "filesystem": {
+        "install": "tools/n8n",
+        "data": "workspaces/n8n",
+        "logs": "logs/n8n",
+    },
+"description": "Ops-oriented workflow automation for multi-step agent orchestration beyond single-turn tool calls.",
     "license": 'Sustainable-Use',
     "flags": {
         "has_cli": True,
@@ -385,13 +399,14 @@ TOOLS: dict[str, dict] = {
 },
     'fabric': {
     "name": "Fabric",
-    "level": 6,
+    "level": 5,
-    "layer": "Orchestrators",
+    "layer": 'Intelligent API Routers & Proxies',
-    "role": "Curation",
+    "role": 'Curation Pipeline',
-    "category": "AI Augmentation",
+    "category": 'Curation Pipeline',
     "installer": {
         "type": "script",
-        "cmd": "curl -L https://github.com/danielmiessler/fabric/releases/latest/download/fabric-linux-amd64 > {tools_root}/bin/fabric && chmod +x {tools_root}/bin/fabric"
+        "cmd": "curl -L https://github.com/danielmiessler/fabric/releases/latest/download/fabric-linux-amd64 > {tools_root}/bin/fabric && chmod +x {tools_root}/bin/fabric",
+        "pkg": "https://github.com/danielmiessler/fabric"
     },
     "launcher": {
         "type": "tmux",
@@ -416,9 +431,9 @@ TOOLS: dict[str, dict] = {
     'synapscli': {
     "name": "SynapsCLI",
     "level": 6,
-    "layer": "Orchestrators",
+    "layer": 'Multi-Agent Orchestration Runtimes',
-    "role": "Agent",
+    "role": 'Terminal Agent',
-    "category": "AI Agent",
+    "category": 'Terminal Agent',
     "installer": {
         "type": "git",
         "pkg": "https://github.com/HaseebKhalid1507/SynapsCLI",
@@ -445,12 +460,12 @@ TOOLS: dict[str, dict] = {
     'hivemind': {
     "name": "HiveMind",
     "level": 6,
-    "layer": "Orchestrators",
+    "layer": 'Multi-Agent Orchestration Runtimes',
-    "role": "Coordination",
+    "role": 'Coordination Protocol',
-    "category": "Multi-Agent",
+    "category": 'Coordination Protocol',
     "installer": {
         "type": "git",
-        "pkg": "https://github.com/nicely-done/hivemind"
+        "pkg": "https://github.com/hivementality-ai/hivemind"
     },
     "launcher": {
         "type": "tmux",
@@ -475,9 +490,9 @@ TOOLS: dict[str, dict] = {
     'hermes_agent': {
     "name": "Hermes Agent",
     "level": 6,
-    "layer": "Orchestrators",
+    "layer": 'Multi-Agent Orchestration Runtimes',
-    "role": "Agent",
+    "role": 'Agent Daemon',
-    "category": "AI Agent",
+    "category": 'Agent Daemon',
     "installer": {
         "type": "npm",
         "pkg": "hermes-agent"
@@ -505,12 +520,12 @@ TOOLS: dict[str, dict] = {
     'agentic_os': {
     "name": "Agentic OS",
     "level": 6,
-    "layer": "Orchestrators",
+    "layer": 'Multi-Agent Orchestration Runtimes',
-    "role": "Hands",
+    "role": 'Agent Shell',
-    "category": "Agent OS",
+    "category": 'Agent Shell',
     "installer": {
         "type": "git",
-        "pkg": "https://github.com/nicely-done/agentic-os"
+        "pkg": "https://github.com/aporb/agentic-os"
     },
     "launcher": {
         "type": "tmux",
@@ -534,10 +549,10 @@ TOOLS: dict[str, dict] = {
 },
     'mcp_drift_state_tracker': {
     "name": "MCP Drift State Tracker",
-    "level": 6,
+    "level": 7,
-    "layer": "Orchestrators",
+    "layer": 'Agentic Software Engineering & Sandboxes',
-    "role": "Code Audit",
+    "role": 'Context Integrity Core',
-    "category": "MCP Server",
+    "category": 'Context Integrity Core',
     "installer": {
         "type": "git_node",
         "pkg": "https://git.dcos.net/dcosnet/MCP-Drift-State-Tracker.git",
@@ -565,12 +580,12 @@ TOOLS: dict[str, dict] = {
     'glassmind': {
     "name": "GlassMind",
     "level": 6,
-    "layer": "Orchestrators",
+    "layer": 'Multi-Agent Orchestration Runtimes',
-    "role": "Reasoning",
+    "role": 'Reasoning',
-    "category": "Reasoning Engine",
+    "category": 'Reasoning Engine',
     "installer": {
         "type": "git",
-        "pkg": "https://github.com/nicely-done/glassmind"
+        "pkg": "https://github.com/khodges42/glassMind"
     },
     "launcher": {
         "type": "tmux",
@@ -595,9 +610,9 @@ TOOLS: dict[str, dict] = {
     'honcho': {
     "name": "Honcho",
     "level": 6,
-    "layer": "Orchestrators",
+    "layer": 'Multi-Agent Orchestration Runtimes',
-    "role": "Process Manager",
+    "role": 'Process Manager',
-    "category": "Workflow Automation",
+    "category": 'Workflow Automation',
     "installer": {
         "type": "uv",
         "pkg": "honcho"
@@ -622,10 +637,10 @@ TOOLS: dict[str, dict] = {
 },
     'graphify': {
     "name": "Graphify",
-    "level": 6,
+    "level": 7,
-    "layer": "Orchestrators",
+    "layer": 'Agentic Software Engineering & Sandboxes',
-    "role": "Knowledge Graph Builder",
+    "role": 'Knowledge Graph Builder',
-    "category": "Claude Code Skill",
+    "category": 'Claude Code Skill',
     "installer": {
         "type": "uv",
         "pkg": "graphifyy"
@@ -661,12 +676,12 @@ TOOLS: dict[str, dict] = {
     'headroom': {
     "name": "Headroom",
     "level": 6,
-    "layer": "Orchestrators",
+    "layer": 'Multi-Agent Orchestration Runtimes',
-    "role": "Resource Manager",
+    "role": 'Resource Manager',
-    "category": "Infrastructure",
+    "category": 'Infrastructure',
     "installer": {
         "type": "git",
-        "pkg": "https://github.com/nicely-done/headroom"
+        "pkg": "https://github.com/headroomlabs-ai/headroom"
     },
     "launcher": {
         "type": "desktop",
@@ -688,13 +703,13 @@ TOOLS: dict[str, dict] = {
 },
     'loop_engineering': {
     "name": "Loop Engineering",
-    "level": 6,
+    "level": 7,
-    "layer": "Orchestrators",
+    "layer": 'Agentic Software Engineering & Sandboxes',
-    "role": "Engineering Loop",
+    "role": 'CI/CD Orchestration',
-    "category": "Workflow Automation",
+    "category": 'CI/CD Orchestration',
     "installer": {
         "type": "git",
-        "pkg": "https://github.com/nicely-done/loop_engineering"
+        "pkg": "https://github.com/lcajigasm/loop-engineering"
     },
     "launcher": {
         "type": "desktop",
@@ -717,12 +732,12 @@ TOOLS: dict[str, dict] = {
     'nightshift': {
     "name": "Nightshift",
     "level": 6,
-    "layer": "Orchestrators",
+    "layer": 'Multi-Agent Orchestration Runtimes',
-    "role": "Night Ops",
+    "role": 'Night Ops',
-    "category": "Workflow Automation",
+    "category": 'Workflow Automation',
     "installer": {
         "type": "git",
-        "pkg": "https://github.com/nicely-done/nightshift"
+        "pkg": "https://github.com/johndaskovsky/nightshift"
     },
     "launcher": {
         "type": "desktop",
@@ -744,13 +759,13 @@ TOOLS: dict[str, dict] = {
 },
     'opensandbox': {
     "name": "OpenSandbox",
-    "level": 6,
+    "level": 1,
-    "layer": "Orchestrators",
+    "layer": 'Host Platform & Infrastructure',
-    "role": "Sandbox",
+    "role": 'Isolation',
-    "category": "Container Ops",
+    "category": 'Isolation',
     "installer": {
         "type": "git",
-        "pkg": "https://github.com/nicely-done/opensandbox"
+        "pkg": "https://github.com/opensandbox-group/OpenSandbox"
     },
     "launcher": {
         "type": "desktop",
@@ -772,13 +787,13 @@ TOOLS: dict[str, dict] = {
 },
     'ponytail': {
     "name": "Ponytail",
-    "level": 6,
+    "level": 7,
-    "layer": "Orchestrators",
+    "layer": 'Agentic Software Engineering & Sandboxes',
-    "role": "CI/CD",
+    "role": 'Code Refactoring',
-    "category": "Workflow Automation",
+    "category": 'Code Refactoring',
     "installer": {
         "type": "git",
-        "pkg": "https://github.com/nicely-done/ponytail"
+        "pkg": "https://github.com/DietrichGebert/ponytail"
     },
     "launcher": {
         "type": "desktop",
@@ -800,13 +815,13 @@ TOOLS: dict[str, dict] = {
 },
     'promptops': {
     "name": "PromptOps",
-    "level": 6,
+    "level": 7,
-    "layer": "Orchestrators",
+    "layer": 'Agentic Software Engineering & Sandboxes',
-    "role": "Prompt Ops",
+    "role": 'Prompt Tester',
-    "category": "AI Agent",
+    "category": 'Prompt Tester',
     "installer": {
         "type": "git",
-        "pkg": "https://github.com/nicely-done/promptops"
+        "pkg": "https://github.com/llmhq-hub/promptops"
     },
     "launcher": {
         "type": "desktop",
@@ -829,12 +844,12 @@ TOOLS: dict[str, dict] = {
     'agent_reach': {
     "name": "Agent Reach",
     "level": 6,
-    "layer": "Orchestrators",
+    "layer": 'Multi-Agent Orchestration Runtimes',
-    "role": "Agent Discovery",
+    "role": 'Agent Discovery',
-    "category": "Multi-Agent",
+    "category": 'Multi-Agent',
     "installer": {
         "type": "git",
-        "pkg": "https://github.com/nicely-done/agent_reach"
+        "pkg": "https://github.com/Panniantong/Agent-Reach"
     },
     "launcher": {
         "type": "desktop",
@@ -857,12 +872,12 @@ TOOLS: dict[str, dict] = {
     'algory': {
     "name": "Algory",
     "level": 6,
-    "layer": "Orchestrators",
+    "layer": 'Multi-Agent Orchestration Runtimes',
-    "role": "Algorithm",
+    "role": 'Algorithm',
-    "category": "AI Agent",
+    "category": 'AI Agent',
     "installer": {
         "type": "git",
-        "pkg": "https://github.com/nicely-done/algory"
+        "pkg": "https://github.com/aryaghan-mutum/algory"
     },
     "launcher": {
         "type": "desktop",
@@ -885,12 +900,12 @@ TOOLS: dict[str, dict] = {
     'atlas_os': {
     "name": "Atlas OS",
     "level": 6,
-    "layer": "Orchestrators",
+    "layer": 'Multi-Agent Orchestration Runtimes',
-    "role": "OS Framework",
+    "role": 'OS Framework',
-    "category": "Agent OS",
+    "category": 'Agent OS',
     "installer": {
         "type": "git",
-        "pkg": "https://github.com/nicely-done/atlas_os"
+        "pkg": "https://github.com/atlas-os/atlas"
     },
     "launcher": {
         "type": "desktop",
@@ -912,13 +927,13 @@ TOOLS: dict[str, dict] = {
 },
     'career_ops': {
     "name": "Career Ops",
-    "level": 6,
+    "level": 10,
-    "layer": "Orchestrators",
+    "layer": 'Human Interface & System Operations',
-    "role": "Career Ops",
+    "role": 'Gap Analyzer',
-    "category": "Workflow Automation",
+    "category": 'Gap Analyzer',
     "installer": {
         "type": "git",
-        "pkg": "https://github.com/nicely-done/career_ops"
+        "pkg": "https://github.com/santifer/career-ops"
     },
     "launcher": {
         "type": "desktop",
@@ -940,13 +955,13 @@ TOOLS: dict[str, dict] = {
 },
     'container_tool': {
     "name": "Container Tool",
-    "level": 6,
+    "level": 1,
-    "layer": "Orchestrators",
+    "layer": 'Host Platform & Infrastructure',
-    "role": "Containerization",
+    "role": 'Isolation',
-    "category": "Container Ops",
+    "category": 'Isolation',
     "installer": {
         "type": "git",
-        "pkg": "https://github.com/nicely-done/container_tool"
+        "pkg": "https://github.com/NVIDIA/nvidia-container-toolkit"
     },
     "launcher": {
         "type": "desktop",
@@ -968,13 +983,13 @@ TOOLS: dict[str, dict] = {
 },
     'pm_skills': {
     "name": "PM Skills",
-    "level": 6,
+    "level": 10,
-    "layer": "Orchestrators",
+    "layer": 'Human Interface & System Operations',
-    "role": "Project Management",
+    "role": 'Sprint Planner',
-    "category": "Workflow Automation",
+    "category": 'Sprint Planner',
     "installer": {
-        "type": "uv",
+        "type": "git",
-        "pkg": "pm-skills"
+        "pkg": "https://github.com/product-on-purpose/pm-skills"
     },
     "launcher": {
         "type": "desktop",
@@ -996,13 +1011,13 @@ TOOLS: dict[str, dict] = {
 },
     'skillspector': {
     "name": "Skillspector",
-    "level": 6,
+    "level": 7,
-    "layer": "Orchestrators",
+    "layer": 'Agentic Software Engineering & Sandboxes',
-    "role": "Skill Inspector",
+    "role": 'Skill Auditor',
-    "category": "AI Agent",
+    "category": 'Skill Auditor',
     "installer": {
         "type": "git",
-        "pkg": "https://github.com/nicely-done/skillspector"
+        "pkg": "https://github.com/NVIDIA/skillspector"
     },
     "launcher": {
         "type": "desktop",
@@ -1024,13 +1039,13 @@ TOOLS: dict[str, dict] = {
 },
     'spec_kit': {
     "name": "Spec Kit",
-    "level": 6,
+    "level": 7,
-    "layer": "Orchestrators",
+    "layer": 'Agentic Software Engineering & Sandboxes',
-    "role": "Specification",
+    "role": 'Requirement Builder',
-    "category": "AI Agent",
+    "category": 'Requirement Builder',
     "installer": {
         "type": "git",
-        "pkg": "https://github.com/nicely-done/spec_kit"
+        "pkg": "https://github.com/github/spec-kit"
     },
     "launcher": {
         "type": "desktop",
@@ -1053,9 +1068,9 @@ TOOLS: dict[str, dict] = {
 'wayland_ai': {
     "name": "Wayland AI",
     "level": 6,
-    "layer": "Orchestrators",
+    "layer": 'Multi-Agent Orchestration Runtimes',
-    "role": "Agent Orchestrator",
+    "role": 'Desktop Agent Core',
-    "category": "AI Agent",
+    "category": 'Desktop Agent Core',
     "installer": {
         "type": "git",
         "pkg": "https://github.com/ferroxlabs/wayland",
@@ -1082,9 +1097,9 @@ TOOLS: dict[str, dict] = {
     'letta': {
     "name": "Letta",
     "level": 6,
-    "layer": "Orchestrators",
+    "layer": 'Multi-Agent Orchestration Runtimes',
-    "role": "Agent Framework",
+    "role": 'Agent Framework',
-    "category": "Agent Framework",
+    "category": 'Agent Framework',
     "installer": {
         "type": "uv",
         "pkg": "letta"

src/ai_lsc/registry/layers/routing.py

@@ -9,15 +9,19 @@ gateways) that had been folded into Orchestrators during the 13-to-10
 reorg, plus the mesh-aware clients that ride on it.
 
 This module is consumed by :mod:`ai_lsc.registry.loader`.
+
+Structural fields (layer, level) follow the 10-Layer Systems
+Architecture Taxonomy; tools may be regrouped across files in a
+future pass — the loader merges by tool, not by filename.
 """
 
 TOOLS: dict[str, dict] = {
     'litellm': {
     "name": "LiteLLM Proxy",
     "level": 5,
-    "layer": "Routing",
+    "layer": 'Intelligent API Routers & Proxies',
-    "role": "API Gateway",
+    "role": 'Unified API Gateway',
-    "category": "Proxy",
+    "category": 'Unified API Gateway',
     "installer": {
         "type": "uv",
         "pkg": "litellm"
@@ -44,12 +48,12 @@ TOOLS: dict[str, dict] = {
     '9router_proxy': {
     "name": "9Router Proxy",
     "level": 5,
-    "layer": "Routing",
+    "layer": 'Intelligent API Routers & Proxies',
-    "role": "API Gateway",
+    "role": 'Load Balancer',
-    "category": "LLM Router",
+    "category": 'Load Balancer',
     "installer": {
         "type": "git",
-        "pkg": "https://github.com/nicely-done/9router"
+        "pkg": "https://github.com/decolua/9router"
     },
     "launcher": {
         "type": "tmux",
@@ -79,9 +83,9 @@ TOOLS: dict[str, dict] = {
     'meshllm': {
     "name": "MeshLLM",
     "level": 5,
-    "layer": "Routing",
+    "layer": 'Intelligent API Routers & Proxies',
-    "role": "API Gateway",
+    "role": 'API Gateway',
-    "category": "LLM Mesh",
+    "category": 'LLM Mesh',
     "installer": {
         "type": "script",
         "cmd": "mkdir -p {tools_root}/meshllm/bin && curl -fsSL https://raw.githubusercontent.com/Mesh-LLM/mesh-llm/main/install.sh | MESH_LLM_INSTALL_DIR={tools_root}/meshllm/bin bash"
@@ -118,10 +122,10 @@ TOOLS: dict[str, dict] = {
 
     'dify': {
     "name": "Dify",
-    "level": 5,
+    "level": 10,
-    "layer": "Routing",
+    "layer": 'Human Interface & System Operations',
-    "role": "Pipeline Orchestrator",
+    "role": 'Platform Workspace',
-    "category": "Pipeline",
+    "category": 'Platform Workspace',
     "installer": {
         "type": "git",
         "pkg": "https://github.com/langgenius/dify.git"
@@ -152,10 +156,10 @@ TOOLS: dict[str, dict] = {
 
 'picode': {
     "name": "PiCode",
-    "level": 5,
+    "level": 7,
-    "layer": "Routing",
+    "layer": 'Agentic Software Engineering & Sandboxes',
-    "role": "Coding Agent",
+    "role": 'Coding Agent',
-    "category": "Mesh Client",
+    "category": 'Mesh Client',
     "installer": {
         "type": "git",
         "pkg": "https://github.com/jasonjmcghee/picode.git"

src/ai_lsc/registry/layers/security.py

@@ -6,18 +6,22 @@ the local AI infrastructure.
 
 This module is consumed by
 :mod:`ai_lsc.registry.loader`.
+
+Structural fields (layer, level) follow the 10-Layer Systems
+Architecture Taxonomy; tools may be regrouped across files in a
+future pass — the loader merges by tool, not by filename.
 """
 
 TOOLS: dict[str, dict] = {
     'keycloak': {
     "name": "Keycloak",
-    "level": 7,
+    "level": 1,
-    "layer": "Security",
+    "layer": 'Host Platform & Infrastructure',
-    "role": "Identity",
+    "role": 'Identity',
-    "category": "Auth",
+    "category": 'Auth',
     "installer": {
         "type": "custom",
-        "pkg": "keycloak"
+        "pkg": "https://github.com/keycloak/keycloak"
     },
     "launcher": {
         "type": "tmux",
@@ -39,10 +43,10 @@ TOOLS: dict[str, dict] = {
 },
     'vault': {
     "name": "HashiCorp Vault",
-    "level": 7,
+    "level": 1,
-    "layer": "Security",
+    "layer": 'Host Platform & Infrastructure',
-    "role": "Secrets",
+    "role": 'Secrets',
-    "category": "Secrets Management",
+    "category": 'Secrets Management',
     "installer": {
         "type": "pacman",
         "pkg": "vault"
@@ -67,10 +71,10 @@ TOOLS: dict[str, dict] = {
 },
     'trivy': {
     "name": "Trivy",
-    "level": 7,
+    "level": 10,
-    "layer": "Security",
+    "layer": 'Human Interface & System Operations',
-    "role": "Scanner",
+    "role": 'Scanner',
-    "category": "Container Security",
+    "category": 'Container Security',
     "installer": {
         "type": "pacman",
         "pkg": "trivy"
@@ -95,10 +99,10 @@ TOOLS: dict[str, dict] = {
 },
     'fail2ban': {
     "name": "Fail2Ban",
-    "level": 7,
+    "level": 1,
-    "layer": "Security",
+    "layer": 'Host Platform & Infrastructure',
-    "role": "IDS",
+    "role": 'IDS',
-    "category": "Intrusion Prevention",
+    "category": 'Intrusion Prevention',
     "installer": {
         "type": "pacman",
         "pkg": "fail2ban"
@@ -123,10 +127,10 @@ TOOLS: dict[str, dict] = {
 },
     'clamav': {
     "name": "ClamAV",
-    "level": 7,
+    "level": 10,
-    "layer": "Security",
+    "layer": 'Human Interface & System Operations',
-    "role": "Scanner",
+    "role": 'Scanner',
-    "category": "Antivirus",
+    "category": 'Antivirus',
     "installer": {
         "type": "pacman",
         "pkg": "clamav"
@@ -151,10 +155,10 @@ TOOLS: dict[str, dict] = {
 },
     'opa': {
     "name": "Open Policy Agent",
-    "level": 7,
+    "level": 10,
-    "layer": "Security",
+    "layer": 'Human Interface & System Operations',
-    "role": "Policy",
+    "role": 'Policy',
-    "category": "Policy Engine",
+    "category": 'Policy Engine',
     "installer": {
         "type": "pacman",
         "pkg": "opa"

src/ai_lsc/registry/layers/user_interfaces.py

@@ -5,15 +5,19 @@ sensory interfaces (vision, speech, voice), and knowledge graph tools.
 
 This module is consumed by
 :mod:`ai_lsc.registry.loader`.
+
+Structural fields (layer, level) follow the 10-Layer Systems
+Architecture Taxonomy; tools may be regrouped across files in a
+future pass — the loader merges by tool, not by filename.
 """
 
 TOOLS: dict[str, dict] = {
     'openwebui': {
     "name": "Open WebUI",
-    "level": 9,
+    "level": 10,
-    "layer": "User Interfaces",
+    "layer": 'Human Interface & System Operations',
-    "role": "Face",
+    "role": 'Extensible Interface',
-    "category": "Chat Frontend",
+    "category": 'Extensible Interface',
     "installer": {
         "type": "uv",
         "pkg": "open-webui"
@@ -40,10 +44,10 @@ TOOLS: dict[str, dict] = {
 },
     'anythingllm': {
     "name": "AnythingLLM",
-    "level": 9,
+    "level": 10,
-    "layer": "User Interfaces",
+    "layer": 'Human Interface & System Operations',
-    "role": "Face",
+    "role": 'Collaborative Chat',
-    "category": "Chat",
+    "category": 'Collaborative Chat',
     "installer": {
         "type": "git_node",
         "pkg": "https://github.com/Mintplex-Labs/anything-llm.git"
@@ -68,10 +72,10 @@ TOOLS: dict[str, dict] = {
 },
     'librechat': {
     "name": "LibreChat",
-    "level": 9,
+    "level": 10,
-    "layer": "User Interfaces",
+    "layer": 'Human Interface & System Operations',
-    "role": "Face",
+    "role": 'Enterprise Assistant',
-    "category": "Chat Agent Platform",
+    "category": 'Enterprise Assistant',
     "installer": {
         "type": "git_node",
         "pkg": "https://github.com/danny-avila/LibreChat.git",
@@ -105,10 +109,10 @@ TOOLS: dict[str, dict] = {
 },
     'flowise': {
     "name": "Flowise",
-    "level": 9,
+    "level": 10,
-    "layer": "User Interfaces",
+    "layer": 'Human Interface & System Operations',
-    "role": "Face",
+    "role": 'Visual Agent Canvas',
-    "category": "Workflow",
+    "category": 'Visual Agent Canvas',
     "installer": {
         "type": "npm",
         "pkg": "flowise"
@@ -133,10 +137,10 @@ TOOLS: dict[str, dict] = {
 },
     'invokeai': {
     "name": "InvokeAI",
-    "level": 9,
+    "level": 10,
-    "layer": "User Interfaces",
+    "layer": 'Human Interface & System Operations',
-    "role": "Face",
+    "role": 'Studio Canvas',
-    "category": "Image Generation",
+    "category": 'Studio Canvas',
     "installer": {
         "type": "git",
         "pkg": "https://github.com/invoke-ai/InvokeAI"
@@ -163,13 +167,13 @@ TOOLS: dict[str, dict] = {
 },
     'forge': {
     "name": "Forge (A1111)",
-    "level": 9,
+    "level": 10,
-    "layer": "User Interfaces",
+    "layer": 'Human Interface & System Operations',
-    "role": "Face",
+    "role": 'Image WebUI',
-    "category": "Image Generation",
+    "category": 'Image WebUI',
     "installer": {
         "type": "git",
-        "pkg": "https://github.com/AUTOMATIC1111/stable-diffusion-webui-forge"
+        "pkg": "https://github.com/lllyasviel/stable-diffusion-webui-forge"
     },
     "launcher": {
         "type": "tmux",
@@ -193,10 +197,10 @@ TOOLS: dict[str, dict] = {
 },
     'dashy': {
     "name": "Dashy",
-    "level": 9,
+    "level": 10,
-    "layer": "User Interfaces",
+    "layer": 'Human Interface & System Operations',
-    "role": "Face",
+    "role": 'Cluster Homepage',
-    "category": "Homepage",
+    "category": 'Cluster Homepage',
     "installer": {
         "type": "npm",
         "pkg": "dashy"
@@ -221,10 +225,10 @@ TOOLS: dict[str, dict] = {
 },
     'obsidian': {
     "name": "Obsidian",
-    "level": 9,
+    "level": 10,
-    "layer": "User Interfaces",
+    "layer": 'Human Interface & System Operations',
-    "role": "Face",
+    "role": 'Sovereign Graph Editor',
-    "category": "Knowledge Graph Notes",
+    "category": 'Sovereign Graph Editor',
     "installer": {
         "type": "pacman",
         "pkg": "obsidian"
@@ -249,10 +253,10 @@ TOOLS: dict[str, dict] = {
 },
     'hermes': {
     "name": "Hermes",
-    "level": 9,
+    "level": 10,
-    "layer": "User Interfaces",
+    "layer": 'Human Interface & System Operations',
-    "role": "Face",
+    "role": 'Ecosystem Launcher',
-    "category": "Ecosystem Dashboard",
+    "category": 'Ecosystem Launcher',
     "installer": {
         "type": "npm",
         "pkg": "hermes-ai"
@@ -279,10 +283,10 @@ TOOLS: dict[str, dict] = {
 },
     'hermes_desktop': {
     "name": "Hermes Desktop",
-    "level": 9,
+    "level": 10,
-    "layer": "User Interfaces",
+    "layer": 'Human Interface & System Operations',
-    "role": "Face",
+    "role": 'Desktop GUI',
-    "category": "Desktop Agent",
+    "category": 'Desktop GUI',
     "installer": {
         "type": "npm",
         "pkg": "hermes-desktop"
@@ -309,10 +313,10 @@ TOOLS: dict[str, dict] = {
 },
     'hermes_dashboard_page': {
     "name": "Hermes Dashboard",
-    "level": 9,
+    "level": 10,
-    "layer": "User Interfaces",
+    "layer": 'Human Interface & System Operations',
-    "role": "Face",
+    "role": 'System Console',
-    "category": "Dashboard",
+    "category": 'System Console',
     "installer": {
         "type": "npm",
         "pkg": "hermes-dashboard"
@@ -339,13 +343,13 @@ TOOLS: dict[str, dict] = {
 },
     'local_llm_launcher': {
     "name": "Local LLM Launcher",
-    "level": 9,
+    "level": 10,
-    "layer": "User Interfaces",
+    "layer": 'Human Interface & System Operations',
-    "role": "Face",
+    "role": 'Model Manager GUI',
-    "category": "LLM GUI",
+    "category": 'Model Manager GUI',
     "installer": {
         "type": "git",
-        "pkg": "https://github.com/nicely-done/local-llm-launcher-gui"
+        "pkg": "https://github.com/jimdawdy-hub/Local-LLM-Launcher-GUI"
     },
     "launcher": {
         "type": "desktop",
@@ -369,10 +373,10 @@ TOOLS: dict[str, dict] = {
 },
     'openjarvis': {
     "name": "OpenJarvis",
-    "level": 9,
+    "level": 10,
-    "layer": "User Interfaces",
+    "layer": 'Human Interface & System Operations',
-    "role": "Central Intelligence",
+    "role": 'Local Central Shell',
-    "category": "AI Assistant Platform",
+    "category": 'Local Central Shell',
     "installer": {
         "type": "git_node",
         "pkg": "https://github.com/openjarvis/openjarvis.git",
@@ -409,12 +413,12 @@ TOOLS: dict[str, dict] = {
     'deep_eye': {
     "name": "Deep Eye",
     "level": 9,
-    "layer": "User Interfaces",
+    "layer": 'Data Extraction & Pipeline Harvest',
-    "role": "Vision",
+    "role": 'Vision describer',
-    "category": "Computer Vision",
+    "category": 'Vision describer',
     "installer": {
         "type": "git",
-        "pkg": "https://github.com/nicely-done/deep-eye"
+        "pkg": "https://github.com/zakirkun/deep-eye"
     },
     "launcher": {
         "type": "tmux",
@@ -439,12 +443,12 @@ TOOLS: dict[str, dict] = {
     'parakeet': {
     "name": "Parakeet.cpp",
     "level": 9,
-    "layer": "User Interfaces",
+    "layer": 'Data Extraction & Pipeline Harvest',
-    "role": "Senses",
+    "role": 'Speech Transcriber',
-    "category": "Speech Recognition",
+    "category": 'Speech Transcriber',
     "installer": {
         "type": "git",
-        "pkg": "https://github.com/nicely-done/parakeet.cpp"
+        "pkg": "https://github.com/mudler/parakeet.cpp"
     },
     "launcher": {
         "type": "tmux",
@@ -469,9 +473,9 @@ TOOLS: dict[str, dict] = {
     'luxtts': {
     "name": "LuxTTS",
     "level": 9,
-    "layer": "User Interfaces",
+    "layer": 'Data Extraction & Pipeline Harvest',
-    "role": "Voice",
+    "role": 'Voice Synthesis',
-    "category": "Text-to-Speech",
+    "category": 'Voice Synthesis',
     "installer": {
         "type": "uv",
         "pkg": "luxtts"
@@ -496,10 +500,10 @@ TOOLS: dict[str, dict] = {
 },
     'jan': {
     "name": "Jan",
-    "level": 9,
+    "level": 10,
-    "layer": "User Interfaces",
+    "layer": 'Human Interface & System Operations',
-    "role": "Face",
+    "role": 'Face',
-    "category": "LLM GUI",
+    "category": 'LLM GUI',
     "installer": {
         "type": "npm",
         "pkg": "@janhq/jan"
@@ -526,10 +530,10 @@ TOOLS: dict[str, dict] = {
 },
 'hermes_webui': {
     "name": "Hermes WebUI",
-    "level": 9,
+    "level": 10,
-    "layer": "User Interfaces",
+    "layer": 'Human Interface & System Operations',
-    "role": "Face",
+    "role": 'Face',
-    "category": "Chat Frontend",
+    "category": 'Chat Frontend',
     "installer": {
         "type": "uv",
         "pkg": "open-webui"
@@ -561,4 +565,64 @@ TOOLS: dict[str, dict] = {
     }
 },
 
+
+    'kanban': {
+    "name": 'Kanban Board',
+    "level": 10,
+    "layer": 'Human Interface & System Operations',
+    "role": 'Sprints Manager',
+    "category": 'Sprints Manager',
+    "installer": {
+        "type": 'npm',
+        "pkg": 'kanban-board',
+    },
+    "launcher": {
+        "type": 'desktop',
+        "cmd": 'kanban',
+        "default_port": None,
+    },
+    "deps": [
+    ],
+    "description": 'Local visual dashboard designed to map task timelines and track developer sprints natively.',
+    "license": 'Proprietary',
+    "flags": {
+        "has_cli": False,
+        "has_gui": True,
+        "has_web": False,
+        "is_ollama": False,
+        "is_passive": False,
+        "is_mcp": False,
+        "is_skills_collection": False,
+    }
+    },
+    'comfyui': {
+    "name": "ComfyUI",
+    "level": 10,
+    "layer": 'Human Interface & System Operations',
+    "role": 'Node-Based Image Gen',
+    "category": 'Node-Based Image Gen',
+    "installer": {
+        "type": "git",
+        "pkg": "https://github.com/comfy-org/comfyui"
+    },
+    "launcher": {
+        "type": "tmux",
+        "cmd": "cd {tools_root}/comfyui && python main.py --listen 0.0.0.0 --port {port}",
+        "default_port": 8188
+    },
+    "deps": [
+        "cuda"
+    ],
+    "description": "Node-based Stable Diffusion / FLUX image generation pipeline editor.",
+    "license": 'GPL-3.0',
+    "flags": {
+        "has_cli": False,
+        "has_gui": False,
+        "has_web": True,
+        "is_ollama": False,
+        "is_passive": False,
+        "is_mcp": False,
+        "is_skills_collection": False
+    }
+    },
 }

src/ai_lsc/registry/validator.py

@@ -150,10 +150,11 @@ def _check_entry(tool_id: str, entry: dict[str, Any]) -> list[str]:
     if missing:
         errors.append(f"{tool_id}: missing fields {sorted(missing)}")
 
-    # Level must be 1–13
+    # Level must be 1–10 (10-Layer Systems Architecture Taxonomy)
     level = entry.get("level")
-    if isinstance(level, int) and not (1 <= level <= 13):
+    if isinstance(level, int) and not (1 <= level <= 10):
-        errors.append(f"{tool_id}: level {level} out of range 1-13")
+        errors.append(f"{tool_id}: level {level} out of range 1-10 "
+                      f"(10-layer taxonomy)")
     elif not isinstance(level, int):
         errors.append(f"{tool_id}: level is not an int ({level!r})")
 

src/ai_lsc/runtime/installer.py

@@ -43,6 +43,7 @@ Key capabilities
 from __future__ import annotations
 
 import os
+import time
 import re
 import shlex
 import shutil
@@ -562,14 +563,53 @@ class InstallerManager:
         post_install: str | None = None,
         env_overrides: dict[str, str] | None = None,
     ) -> str:
-        """Clone a git repository into ``tools_root/<tool_id>``."""
+        """Clone or update a git repository at ``tools_root/<tool_id>``.
+
+        Bandwidth-aware: if a git working tree already exists at the
+        destination, run ``git pull --ff-only`` to fetch only the diff.
+        If the destination exists but is not a git repo (or the pull
+        fails for any reason — diverged branches, network errors,
+        corrupted index, etc.), move the old dir aside and re-clone
+        fresh, so the install always ends in a usable state.
+        """
         dest = os.path.join(self.tools_root, tool_id)
-        if os.path.exists(dest):
+        git_dir = os.path.join(dest, ".git")
+        if os.path.isdir(git_dir):
+            try:
+                subprocess.run(
+                    ["git", "-C", dest, "pull", "--ff-only"],
+                    check=True, timeout=600,
+                )
+                msg = f"Git source updated (pulled): {dest}"
+            except subprocess.CalledProcessError as exc:
+                logger.warning(
+                    "git pull failed for %s (%s); re-cloning fresh",
+                    tool_id, exc,
+                )
+                backup = dest + ".bak." + str(int(time.time()))
+                shutil.move(dest, backup)
+                os.makedirs(dest, exist_ok=True)
+                subprocess.run(
+                    ["git", "clone", pkg, dest],
+                    check=True, timeout=600,
+                )
+                msg = (
+                    f"Git source re-cloned (pull failed, "
+                    f"old copy at {backup}): {dest}"
+                )
+        elif os.path.exists(dest):
+            # Dir exists but is not a git repo — back it up and clone.
+            backup = dest + ".bak." + str(int(time.time()))
+            shutil.move(dest, backup)
+            os.makedirs(dest, exist_ok=True)
             subprocess.run(
-                ["git", "-C", dest, "pull", "--ff-only"],
+                ["git", "clone", pkg, dest],
                 check=True, timeout=600,
             )
-            msg = f"Git source updated: {dest}"
+            msg = (
+                f"Git source cloned (existing non-git dir backed up "
+                f"at {backup}): {dest}"
+            )
         else:
             os.makedirs(dest, exist_ok=True)
             subprocess.run(
@@ -588,16 +628,58 @@ class InstallerManager:
         tool_id: str,
         post_install: str | None = None,
     ) -> str:
-        """Clone a git repo and run ``yarn setup``."""
+        """Clone or update a git repo and run ``yarn install``.
+
+        Bandwidth-aware: if a git working tree already exists at the
+        destination, run ``git pull --ff-only`` (diff-only fetch) and
+        then ``yarn install`` to pick up any changed dependencies.  If
+        the destination exists but is not a git repo, or if the pull
+        fails, move the old dir aside and re-clone fresh.
+        """
         dest = os.path.join(self.tools_root, tool_id)
-        if os.path.exists(dest):
+        git_dir = os.path.join(dest, ".git")
+        if os.path.isdir(git_dir):
+            try:
+                subprocess.run(
+                    ["git", "-C", dest, "pull", "--ff-only"],
+                    check=True, timeout=600,
+                )
+                subprocess.run(
+                    ["yarn", "install"], cwd=dest, check=True, timeout=300,
+                )
+                msg = f"Git+Node source updated (pulled): {dest}"
+            except subprocess.CalledProcessError as exc:
+                logger.warning(
+                    "git pull / yarn install failed for %s (%s); re-cloning",
+                    tool_id, exc,
+                )
+                backup = dest + ".bak." + str(int(time.time()))
+                shutil.move(dest, backup)
+                os.makedirs(dest, exist_ok=True)
+                subprocess.run(
+                    ["git", "clone", pkg, dest], check=True, timeout=600,
+                )
+                subprocess.run(
+                    ["yarn", "install"], cwd=dest, check=True, timeout=300,
+                )
+                msg = (
+                    f"Git+Node source re-cloned (pull failed, "
+                    f"old copy at {backup}): {dest}"
+                )
+        elif os.path.exists(dest):
+            backup = dest + ".bak." + str(int(time.time()))
+            shutil.move(dest, backup)
+            os.makedirs(dest, exist_ok=True)
             subprocess.run(
-                ["git", "-C", dest, "pull", "--ff-only"], check=True, timeout=600,
+                ["git", "clone", pkg, dest], check=True, timeout=600,
             )
             subprocess.run(
                 ["yarn", "install"], cwd=dest, check=True, timeout=300,
             )
-            msg = f"Git+Node source updated: {dest}"
+            msg = (
+                f"Git+Node source cloned (existing non-git dir backed "
+                f"up at {backup}): {dest}"
+            )
         else:
             os.makedirs(dest, exist_ok=True)
             subprocess.run(

src/ai_lsc/stack/connections.py

@@ -25,6 +25,63 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from typing import Any
 
+
+# ── 10-layer taxonomy resolution ──────────────────────────────────────
+# Static wiring entries carry their layer as a literal; loop-based bulk
+# allocations resolve the layer dynamically from the registry so the
+# wiring graph can never drift from the taxonomy again.
+from ai_lsc.registry.defaults import DEFAULT_REGISTRY
+
+# Layer assignments for staged tools that live in the modular layer
+# files but are not part of the shipped DEFAULT_REGISTRY seed.
+_WIRING_LAYER_SUPPLEMENT: dict[str, str] = {
+    "agent_reach": "Multi-Agent Orchestration Runtimes",
+    "algory": "Multi-Agent Orchestration Runtimes",
+    "atlas_os": "Multi-Agent Orchestration Runtimes",
+    "clamav": "Human Interface & System Operations",
+    "crossplane": "Human Interface & System Operations",
+    "distcc": "Development Runtime & Environment",
+    "eagle_eye": "Human Interface & System Operations",
+    "everos_memory": "Decentralized Knowledge & Vector Stores",
+    "gemini_cli": "Agentic Software Engineering & Sandboxes",
+    "glassmind": "Multi-Agent Orchestration Runtimes",
+    "goose": "Agentic Software Engineering & Sandboxes",
+    "graphify": "Agentic Software Engineering & Sandboxes",
+    "headroom": "Multi-Agent Orchestration Runtimes",
+    "hermes_webui": "Human Interface & System Operations",
+    "honcho": "Multi-Agent Orchestration Runtimes",
+    "jan": "Human Interface & System Operations",
+    "letta": "Multi-Agent Orchestration Runtimes",
+    "mem0": "Decentralized Knowledge & Vector Stores",
+    "meshllm": "Intelligent API Routers & Proxies",
+    "mnemo_cortex": "Decentralized Knowledge & Vector Stores",
+    "n8n": "Human Interface & System Operations",
+    "nightshift": "Multi-Agent Orchestration Runtimes",
+    "nvidia_agent_skills": "Multi-Agent Orchestration Runtimes",
+    "odysseus": "Multi-Agent Orchestration Runtimes",
+    "openbrain": "Multi-Agent Orchestration Runtimes",
+    "opencode": "Agentic Software Engineering & Sandboxes",
+    "picode": "Agentic Software Engineering & Sandboxes",
+    "pssh": "Human Interface & System Operations",
+    "qwen_code": "Agentic Software Engineering & Sandboxes",
+    "sglang": "Local Inference Engines",
+    "tinygrad": "GPU Acceleration & Optimization",
+    "trivy": "Human Interface & System Operations",
+    "turbovec": "Decentralized Knowledge & Vector Stores",
+    "zcoder": "Agentic Software Engineering & Sandboxes",
+    "dma": "Development Runtime & Environment",
+    "opa": "Human Interface & System Operations",
+}
+
+
+def _wiring_layer(tool_id: str) -> str:
+    """Resolve a tool's 10-layer taxonomy layer for its wiring entry."""
+    entry = DEFAULT_REGISTRY.get(tool_id)
+    if entry:
+        return entry.get("layer", "")
+    return _WIRING_LAYER_SUPPLEMENT.get(tool_id, "")
+
+
 # ── Schema version ──────────────────────────────────────────────────
 
 CONNECTIONS_SCHEMA_VERSION: str = "1.0.0"
@@ -358,12 +415,12 @@ def _reg(w: StackWiring) -> StackWiring:
 
 
 # ──────────────────────────────────────────────────────────────────
-# L1: Host Platform
+# L1: Host Platform  →  Layer 1: Host Platform & Infrastructure
 # ──────────────────────────────────────────────────────────────────
 
 _reg(StackWiring(
     tool_id="postgresql",
-    layer="Host Platform",
+    layer="Host Platform & Infrastructure",
     interfaces=[
         ToolInterface(
             interface_id="postgresql",
@@ -403,7 +460,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="redis",
-    layer="Host Platform",
+    layer="Host Platform & Infrastructure",
     interfaces=[
         ToolInterface(
             interface_id="redis",
@@ -443,7 +500,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="mariadb",
-    layer="Host Platform",
+    layer="Host Platform & Infrastructure",
     interfaces=[
         ToolInterface(
             interface_id="mariadb",
@@ -473,7 +530,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="duckdb",
-    layer="Host Platform",
+    layer="Host Platform & Infrastructure",
     interfaces=[
         ToolInterface(
             interface_id="duckdb_in_process",
@@ -501,7 +558,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="sqlite3",
-    layer="Host Platform",
+    layer="Host Platform & Infrastructure",
     interfaces=[],
     connections=[],
     context=EngineeringContext(
@@ -515,12 +572,12 @@ _reg(StackWiring(
 
 
 # ──────────────────────────────────────────────────────────────────
-# L2: Development Environment
+# L2: Development Environment  →  Layer 2: Development Runtime & Environment
 # ──────────────────────────────────────────────────────────────────
 
 _reg(StackWiring(
     tool_id="cuda",
-    layer="GPU Runtimes",
+    layer="GPU Acceleration & Optimization",
     interfaces=[_CUDA_INTERFACE],
     connections=[],
     context=EngineeringContext(
@@ -536,7 +593,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="cupy",
-    layer="Development Environment",
+    layer="GPU Acceleration & Optimization",
     interfaces=[],
     connections=[
         Connection(
@@ -558,7 +615,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="python",
-    layer="Development Environment",
+    layer="Development Runtime & Environment",
     interfaces=[],
     connections=[],
     context=EngineeringContext(
@@ -571,7 +628,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="tree_sitter",
-    layer="Development Environment",
+    layer="Development Runtime & Environment",
     interfaces=[],
     connections=[],
     context=EngineeringContext(
@@ -582,7 +639,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="ripgrep",
-    layer="Development Environment",
+    layer="Development Runtime & Environment",
     interfaces=[],
     connections=[],
     context=EngineeringContext(
@@ -593,7 +650,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="fd",
-    layer="Development Environment",
+    layer="Development Runtime & Environment",
     interfaces=[],
     connections=[],
     context=EngineeringContext(
@@ -604,12 +661,12 @@ _reg(StackWiring(
 
 
 # ──────────────────────────────────────────────────────────────────
-# L3: GPU Runtime
+# L3: GPU Runtime  →  Layer 3: GPU Acceleration & Optimization
 # ──────────────────────────────────────────────────────────────────
 
 _reg(StackWiring(
     tool_id="apex",
-    layer="GPU Runtimes",
+    layer="GPU Acceleration & Optimization",
     interfaces=[],
     connections=[
         Connection(
@@ -632,7 +689,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="heretic",
-    layer="Engines",
+    layer="Local Inference Engines",
     interfaces=[],
     connections=[
         Connection(
@@ -656,7 +713,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="unsloth",
-    layer="Development Environment",
+    layer="GPU Acceleration & Optimization",
     interfaces=[],
     connections=[
         Connection(
@@ -679,12 +736,12 @@ _reg(StackWiring(
 
 
 # ──────────────────────────────────────────────────────────────────
-# L4: Inference Engines
+# L4: Inference Engines  →  Layer 4: Local Inference Engines
 # ──────────────────────────────────────────────────────────────────
 
 _reg(StackWiring(
     tool_id="ollama",
-    layer="Engines",
+    layer="Local Inference Engines",
     interfaces=[
         ToolInterface(
             interface_id="openai_api",
@@ -741,7 +798,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="llamacpp",
-    layer="Engines",
+    layer="Local Inference Engines",
     interfaces=[
         ToolInterface(
             interface_id="openai_api",
@@ -771,7 +828,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="vllm",
-    layer="Engines",
+    layer="Local Inference Engines",
     interfaces=[
         ToolInterface(
             interface_id="openai_api",
@@ -818,7 +875,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="airllm",
-    layer="Engines",
+    layer="Local Inference Engines",
     interfaces=[
         ToolInterface(
             interface_id="airllm_api",
@@ -841,7 +898,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="koboldcpp",
-    layer="Engines",
+    layer="Local Inference Engines",
     interfaces=[
         ToolInterface(
             interface_id="koboldcpp_api",
@@ -859,7 +916,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="llamafile",
-    layer="Engines",
+    layer="Local Inference Engines",
     interfaces=[
         ToolInterface(
             interface_id="llamafile_api",
@@ -877,7 +934,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="locally_uncensored",
-    layer="Engines",
+    layer="Local Inference Engines",
     interfaces=[],
     connections=[
         Connection(
@@ -901,7 +958,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="turbollm",
-    layer="Engines",
+    layer="Local Inference Engines",
     interfaces=[
         ToolInterface(
             interface_id="turbollm_api",
@@ -924,19 +981,19 @@ _reg(StackWiring(
 
 
 # ──────────────────────────────────────────────────────────────────
-# L5: Distributed Runtime
+# L5: Distributed Runtime  →  Layer 3/4: GPU + Inference Engines (10-layer taxonomy)
 # (vLLM is already registered above — it sits at L5 in the taxonomy
 #  but is logically grouped with inference engines in the wiring.)
 # ──────────────────────────────────────────────────────────────────
 
 
 # ──────────────────────────────────────────────────────────────────
-# L6: AI Endpoints  (→ the restored "Routing" layer in the 11-layer taxonomy)
+# L6: AI Endpoints  →  Layer 5: Intelligent API Routers & Proxies (10-layer taxonomy)
 # ──────────────────────────────────────────────────────────────────
 
 _reg(StackWiring(
     tool_id="litellm",
-    layer="Routing",
+    layer="Intelligent API Routers & Proxies",
     interfaces=[
         ToolInterface(
             interface_id="openai_api",
@@ -1015,7 +1072,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="9router_proxy",
-    layer="Routing",
+    layer="Intelligent API Routers & Proxies",
     interfaces=[
         ToolInterface(
             interface_id="router_api",
@@ -1041,7 +1098,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="deep_eye",
-    layer="User Interfaces",
+    layer="Data Extraction & Pipeline Harvest",
     interfaces=[
         ToolInterface(
             interface_id="deep_eye_api",
@@ -1066,7 +1123,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="luxtts",
-    layer="User Interfaces",
+    layer="Data Extraction & Pipeline Harvest",
     interfaces=[
         ToolInterface(
             interface_id="tts_api",
@@ -1082,12 +1139,12 @@ _reg(StackWiring(
 
 
 # ──────────────────────────────────────────────────────────────────
-# L7: Data & Knowledge Pipelines
+# L7: Data & Knowledge Pipelines  →  Layer 8/9: Vector Stores + Data Extraction (10-layer taxonomy)
 # ──────────────────────────────────────────────────────────────────
 
 _reg(StackWiring(
     tool_id="chromadb",
-    layer="Knowledge Management",
+    layer="Decentralized Knowledge & Vector Stores",
     interfaces=[
         ToolInterface(
             interface_id="http_api",
@@ -1121,7 +1178,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="qdrant",
-    layer="Knowledge Management",
+    layer="Decentralized Knowledge & Vector Stores",
     interfaces=[
         ToolInterface(
             interface_id="http_api",
@@ -1151,7 +1208,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="lancedb",
-    layer="Knowledge Management",
+    layer="Decentralized Knowledge & Vector Stores",
     interfaces=[
         ToolInterface(
             interface_id="http_api",
@@ -1167,7 +1224,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="elasticsearch",
-    layer="Knowledge Management",
+    layer="Decentralized Knowledge & Vector Stores",
     interfaces=[
         ToolInterface(
             interface_id="http_api",
@@ -1184,7 +1241,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="neo4j",
-    layer="Knowledge Management",
+    layer="Decentralized Knowledge & Vector Stores",
     interfaces=[
         ToolInterface(
             interface_id="http_api",
@@ -1201,7 +1258,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="meilisearch",
-    layer="Knowledge Management",
+    layer="Decentralized Knowledge & Vector Stores",
     interfaces=[
         ToolInterface(
             interface_id="http_api",
@@ -1217,7 +1274,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="airweave",
-    layer="Knowledge Management",
+    layer="Data Extraction & Pipeline Harvest",
     interfaces=[
         ToolInterface(
             interface_id="airweave_api",
@@ -1234,7 +1291,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="parakeet",
-    layer="User Interfaces",
+    layer="Data Extraction & Pipeline Harvest",
     interfaces=[
         ToolInterface(
             interface_id="parakeet_api",
@@ -1257,7 +1314,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="turbovec",
-    layer="Knowledge Management",
+    layer="Decentralized Knowledge & Vector Stores",
     interfaces=[
         ToolInterface(
             interface_id="turbovec_api",
@@ -1280,7 +1337,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="crawl4ai",
-    layer="Knowledge Management",
+    layer="Data Extraction & Pipeline Harvest",
     interfaces=[],
     connections=[],
     context=EngineeringContext(
@@ -1294,7 +1351,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="docling",
-    layer="Knowledge Management",
+    layer="Data Extraction & Pipeline Harvest",
     interfaces=[],
     connections=[],
     context=EngineeringContext(
@@ -1306,7 +1363,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="fabric",
-    layer="Orchestrators",
+    layer="Intelligent API Routers & Proxies",
     interfaces=[],
     connections=[],
     context=EngineeringContext(
@@ -1318,7 +1375,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="graphrag",
-    layer="Knowledge Management",
+    layer="Decentralized Knowledge & Vector Stores",
     interfaces=[],
     connections=[],
     context=EngineeringContext(
@@ -1330,7 +1387,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="markitdown",
-    layer="Knowledge Management",
+    layer="Data Extraction & Pipeline Harvest",
     interfaces=[],
     connections=[],
     context=EngineeringContext(
@@ -1342,7 +1399,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="mirofish",
-    layer="Knowledge Management",
+    layer="Data Extraction & Pipeline Harvest",
     interfaces=[],
     connections=[],
     context=EngineeringContext(
@@ -1353,7 +1410,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="opendataloader",
-    layer="Knowledge Management",
+    layer="Data Extraction & Pipeline Harvest",
     interfaces=[],
     connections=[],
     context=EngineeringContext(
@@ -1364,7 +1421,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="opendataloader_pdf",
-    layer="Knowledge Management",
+    layer="Data Extraction & Pipeline Harvest",
     interfaces=[],
     connections=[],
     context=EngineeringContext(
@@ -1375,7 +1432,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="understand_anything",
-    layer="Knowledge Management",
+    layer="Data Extraction & Pipeline Harvest",
     interfaces=[],
     connections=[
         Connection(
@@ -1391,7 +1448,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="whisper",
-    layer="Knowledge Management",
+    layer="Data Extraction & Pipeline Harvest",
     interfaces=[],
     connections=[],
     context=EngineeringContext(
@@ -1403,12 +1460,12 @@ _reg(StackWiring(
 
 
 # ──────────────────────────────────────────────────────────────────
-# L8: Automation & Execution
+# L8: Automation & Execution  →  Layer 6/7: Orchestration + Agentic Engineering (10-layer taxonomy)
 # ──────────────────────────────────────────────────────────────────
 
 _reg(StackWiring(
     tool_id="n8n",
-    layer="Orchestrators",
+    layer="Human Interface & System Operations",
     interfaces=[
         ToolInterface(
             interface_id="n8n_api",
@@ -1454,7 +1511,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="nightshift",
-    layer="Orchestrators",
+    layer="Multi-Agent Orchestration Runtimes",
     interfaces=[
         ToolInterface(
             interface_id="nightshift_api",
@@ -1470,7 +1527,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="hivemind",
-    layer="Orchestrators",
+    layer="Multi-Agent Orchestration Runtimes",
     interfaces=[
         ToolInterface(
             interface_id="hivemind_api",
@@ -1495,7 +1552,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="hermes_agent",
-    layer="Orchestrators",
+    layer="Multi-Agent Orchestration Runtimes",
     interfaces=[
         ToolInterface(
             interface_id="hermes_agent_api",
@@ -1520,7 +1577,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="openhands",
-    layer="DevOps",
+    layer="Agentic Software Engineering & Sandboxes",
     interfaces=[
         ToolInterface(
             interface_id="openhands_api",
@@ -1582,7 +1639,7 @@ for _tid in [
         ))
     _reg(StackWiring(
         tool_id=_tid,
-        layer="DevOps",
+        layer=_wiring_layer(_tid),
         interfaces=[],
         connections=_conns,
         context=EngineeringContext(
@@ -1595,7 +1652,7 @@ for _tid in [
 # agno has a web interface but no deps in defaults
 _reg(StackWiring(
     tool_id="agno",
-    layer="Orchestrators",
+    layer="Multi-Agent Orchestration Runtimes",
     interfaces=[
         ToolInterface(
             interface_id="agno_web",
@@ -1611,12 +1668,12 @@ _reg(StackWiring(
 
 
 # ──────────────────────────────────────────────────────────────────
-# L9: Observability
+# L9: Observability  →  Layer 10: Human Interface & System Operations (10-layer taxonomy)
 # ──────────────────────────────────────────────────────────────────
 
 _reg(StackWiring(
     tool_id="prometheus",
-    layer="Observability",
+    layer="Human Interface & System Operations",
     interfaces=[
         ToolInterface(
             interface_id="prometheus_api",
@@ -1646,7 +1703,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="grafana",
-    layer="Observability",
+    layer="Human Interface & System Operations",
     interfaces=[
         ToolInterface(
             interface_id="grafana_web",
@@ -1695,7 +1752,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="grafana_alloy",
-    layer="Observability",
+    layer="Human Interface & System Operations",
     interfaces=[
         ToolInterface(
             interface_id="otlp_grpc",
@@ -1739,7 +1796,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="glances",
-    layer="Observability",
+    layer="Human Interface & System Operations",
     interfaces=[
         ToolInterface(
             interface_id="glances_web",
@@ -1755,7 +1812,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="opik",
-    layer="Observability",
+    layer="Human Interface & System Operations",
     interfaces=[
         ToolInterface(
             interface_id="opik_api",
@@ -1771,7 +1828,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="pulse_ai",
-    layer="Observability",
+    layer="Human Interface & System Operations",
     interfaces=[
         ToolInterface(
             interface_id="pulse_ai_api",
@@ -1787,7 +1844,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="hermes_dashboard_page",
-    layer="User Interfaces",
+    layer="Human Interface & System Operations",
     interfaces=[
         ToolInterface(
             interface_id="dashboard_api",
@@ -1812,7 +1869,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="latitude",
-    layer="Observability",
+    layer="Human Interface & System Operations",
     interfaces=[
         ToolInterface(
             interface_id="latitude_api",
@@ -1837,12 +1894,12 @@ _reg(StackWiring(
 
 
 # ──────────────────────────────────────────────────────────────────
-# L10: Intelligent Routing  (folded into "Orchestrators" in the 11-layer taxonomy)
+# L10: Intelligent Routing  →  Layer 5: Intelligent API Routers & Proxies (10-layer taxonomy)
 # ──────────────────────────────────────────────────────────────────
 
 _reg(StackWiring(
     tool_id="odysseus",
-    layer="Orchestrators",
+    layer="Multi-Agent Orchestration Runtimes",
     interfaces=[
         ToolInterface(
             interface_id="odysseus_api",
@@ -1867,7 +1924,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="glassmind",
-    layer="Orchestrators",
+    layer="Multi-Agent Orchestration Runtimes",
     interfaces=[
         ToolInterface(
             interface_id="glassmind_api",
@@ -1892,7 +1949,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="mnemo_cortex",
-    layer="Knowledge Management",
+    layer="Decentralized Knowledge & Vector Stores",
     interfaces=[
         ToolInterface(
             interface_id="mnemo_cortex_api",
@@ -1917,7 +1974,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="openbrain",
-    layer="Orchestrators",
+    layer="Multi-Agent Orchestration Runtimes",
     interfaces=[
         ToolInterface(
             interface_id="openbrain_api",
@@ -1942,7 +1999,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="everos_memory",
-    layer="Knowledge Management",
+    layer="Decentralized Knowledge & Vector Stores",
     interfaces=[
         ToolInterface(
             interface_id="everos_memory_api",
@@ -1960,7 +2017,7 @@ _reg(StackWiring(
 for _tid in ["autogen", "crewai", "openai_swarm"]:
     _reg(StackWiring(
         tool_id=_tid,
-        layer="Orchestrators",
+        layer=_wiring_layer(_tid),
         interfaces=[],
         connections=[],
         context=EngineeringContext(
@@ -1972,12 +2029,12 @@ for _tid in ["autogen", "crewai", "openai_swarm"]:
 
 
 # ──────────────────────────────────────────────────────────────────
-# L11: User Interfaces
+# L11: User Interfaces  →  Layer 10: Human Interface & System Operations (10-layer taxonomy)
 # ──────────────────────────────────────────────────────────────────
 
 _reg(StackWiring(
     tool_id="openwebui",
-    layer="User Interfaces",
+    layer="Human Interface & System Operations",
     interfaces=[
         ToolInterface(
             interface_id="openwebui_web",
@@ -2049,7 +2106,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="dify",
-    layer="Routing",
+    layer="Human Interface & System Operations",
     interfaces=[
         ToolInterface(
             interface_id="dify_web",
@@ -2112,7 +2169,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="flowise",
-    layer="User Interfaces",
+    layer="Human Interface & System Operations",
     interfaces=[
         ToolInterface(
             interface_id="flowise_web",
@@ -2147,7 +2204,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="openjarvis",
-    layer="User Interfaces",
+    layer="Human Interface & System Operations",
     interfaces=[
         ToolInterface(
             interface_id="openjarvis_web",
@@ -2196,7 +2253,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="hermes",
-    layer="User Interfaces",
+    layer="Human Interface & System Operations",
     interfaces=[
         ToolInterface(
             interface_id="hermes_web",
@@ -2222,7 +2279,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="librechat",
-    layer="User Interfaces",
+    layer="Human Interface & System Operations",
     interfaces=[
         ToolInterface(
             interface_id="librechat_web",
@@ -2254,7 +2311,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="anythingllm",
-    layer="User Interfaces",
+    layer="Human Interface & System Operations",
     interfaces=[
         ToolInterface(
             interface_id="anythingllm_web",
@@ -2271,7 +2328,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="langflow",
-    layer="Orchestrators",
+    layer="Human Interface & System Operations",
     interfaces=[
         ToolInterface(
             interface_id="langflow_web",
@@ -2288,7 +2345,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="forge",
-    layer="User Interfaces",
+    layer="Human Interface & System Operations",
     interfaces=[
         ToolInterface(
             interface_id="forge_web",
@@ -2312,7 +2369,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="invokeai",
-    layer="User Interfaces",
+    layer="Human Interface & System Operations",
     interfaces=[
         ToolInterface(
             interface_id="invokeai_web",
@@ -2336,7 +2393,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="dashy",
-    layer="User Interfaces",
+    layer="Human Interface & System Operations",
     interfaces=[
         ToolInterface(
             interface_id="dashy_web",
@@ -2365,7 +2422,7 @@ for _tid in ["hermes_desktop", "local_llm_launcher"]:
         ))
     _reg(StackWiring(
         tool_id=_tid,
-        layer="User Interfaces",
+        layer=_wiring_layer(_tid),
         interfaces=[],
         connections=_conns,
         context=EngineeringContext(
@@ -2376,12 +2433,12 @@ for _tid in ["hermes_desktop", "local_llm_launcher"]:
 
 
 # ──────────────────────────────────────────────────────────────────
-# L12: DevOps
+# L12: DevOps  →  Layer 9/10: Data Extraction + System Operations (10-layer taxonomy)
 # ──────────────────────────────────────────────────────────────────
 
 _reg(StackWiring(
     tool_id="opensandbox",
-    layer="Orchestrators",
+    layer="Host Platform & Infrastructure",
     interfaces=[
         ToolInterface(
             interface_id="opensandbox_web",
@@ -2439,7 +2496,7 @@ for _tid in [
         ))
     _reg(StackWiring(
         tool_id=_tid,
-        layer="DevOps",
+        layer=_wiring_layer(_tid),
         interfaces=[],
         connections=_conns,
         context=EngineeringContext(
@@ -2450,12 +2507,12 @@ for _tid in [
 
 
 # ──────────────────────────────────────────────────────────────────
-# L13: Knowledge Management
+# L13: Knowledge Management  →  Layer 8/10: Vector Stores + System Operations (10-layer taxonomy)
 # ──────────────────────────────────────────────────────────────────
 
 _reg(StackWiring(
     tool_id="paperlessngx",
-    layer="Knowledge Management",
+    layer="Human Interface & System Operations",
     interfaces=[
         ToolInterface(
             interface_id="paperlessngx_web",
@@ -2518,7 +2575,7 @@ for _tid in [
 ]:
     _reg(StackWiring(
         tool_id=_tid,
-        layer="Knowledge Management",
+        layer=_wiring_layer(_tid),
         interfaces=[],
         connections=[],
         context=EngineeringContext(
@@ -2560,7 +2617,7 @@ _CODING_AGENT_CTX = EngineeringContext(
 
 _reg(StackWiring(
     tool_id="opencode",
-    layer="DevOps",
+    layer="Agentic Software Engineering & Sandboxes",
     interfaces=[],
     connections=[
         Connection(
@@ -2584,7 +2641,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="gemini_cli",
-    layer="DevOps",
+    layer="Agentic Software Engineering & Sandboxes",
     interfaces=[],
     connections=[
         Connection(
@@ -2608,7 +2665,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="qwen_code",
-    layer="DevOps",
+    layer="Agentic Software Engineering & Sandboxes",
     interfaces=[],
     connections=[
         Connection(
@@ -2632,7 +2689,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="goose",
-    layer="DevOps",
+    layer="Agentic Software Engineering & Sandboxes",
     interfaces=[],
     connections=[
         Connection(
@@ -2659,7 +2716,7 @@ _reg(StackWiring(
 # it was staged.  This wiring closes that gap.
 _reg(StackWiring(
     tool_id="codex",
-    layer="DevOps",
+    layer="Agentic Software Engineering & Sandboxes",
     interfaces=[],
     connections=[
         Connection(
@@ -2683,7 +2740,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="letta",
-    layer="Orchestrators",
+    layer="Multi-Agent Orchestration Runtimes",
     interfaces=[
         ToolInterface(
             interface_id="http_api",
@@ -2745,7 +2802,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="sglang",
-    layer="Engines",
+    layer="Local Inference Engines",
     interfaces=[
         ToolInterface(
             interface_id="openai_api",
@@ -2799,7 +2856,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="jan",
-    layer="User Interfaces",
+    layer="Human Interface & System Operations",
     interfaces=[
         ToolInterface(
             interface_id="openai_api",
@@ -2835,7 +2892,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="mem0",
-    layer="Knowledge Management",
+    layer="Decentralized Knowledge & Vector Stores",
     interfaces=[],
     connections=[
         Connection(
@@ -2872,7 +2929,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="tinygrad",
-    layer="GPU Runtimes",
+    layer="GPU Acceleration & Optimization",
     interfaces=[],
     connections=[
         Connection(
@@ -3017,7 +3074,7 @@ def validate_wiring() -> list[str]:
 # ──────────────────────────────────────────────────────────────────
 _reg(StackWiring(
     tool_id="graphify",
-    layer="Orchestrators",
+    layer="Agentic Software Engineering & Sandboxes",
     interfaces=[
         ToolInterface(
             interface_id="graphify_mcp",
@@ -3119,7 +3176,7 @@ _reg(StackWiring(
 
 _reg(StackWiring(
     tool_id="meshllm",
-    layer="Routing",
+    layer="Intelligent API Routers & Proxies",
     interfaces=[
         ToolInterface(
             interface_id="openai_api",
@@ -3231,7 +3288,7 @@ _reg(StackWiring(
 # ──────────────────────────────────────────────────────────────────
 _reg(StackWiring(
     tool_id="picode",
-    layer="Routing",
+    layer="Agentic Software Engineering & Sandboxes",
     interfaces=[],
     connections=[
         Connection(
@@ -3282,7 +3339,7 @@ _reg(StackWiring(
 # ──────────────────────────────────────────────────────────────────
 _reg(StackWiring(
     tool_id="zcoder",
-    layer="DevOps",
+    layer="Agentic Software Engineering & Sandboxes",
     interfaces=[],
     connections=[
         Connection(
@@ -3324,7 +3381,7 @@ _reg(StackWiring(
 # ──────────────────────────────────────────────────────────────────
 _reg(StackWiring(
     tool_id="hermes_webui",
-    layer="User Interfaces",
+    layer="Human Interface & System Operations",
     interfaces=[
         ToolInterface(
             interface_id="hermes_webui_http",

src/ai_lsc/ui/pages/db_manager.py

@@ -46,136 +46,231 @@ except ImportError:
     _HAS_QT = False
 
 # ── Category → default Layer / Level / Role mapping ──────────────────
-# Derived from the canonical registry (11-layer taxonomy, v3.1.1b:
+# Derived from the canonical registry (10-Layer Systems Architecture
-# Routing=L5, Orchestrators=L6, Security=L7, Observability=L8,
+# Taxonomy).  When the user picks a category these fields auto-fill;
-# User Interfaces=L9, DevOps=L10, Knowledge Management=L11).
+# the user can still override afterwards.
-# When the user picks a category these fields auto-fill; the user can
-# still override afterwards.
 CATEGORY_MAP: dict[str, dict[str, object]] = {
-    "AI Agent":                     {"layer": "Orchestrators", "level": 6,  "role": "Sensory Bridge"},
+    "AI Agent": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "AI Agent"},
-    "AI Assistant Platform":        {"layer": "User Interfaces", "level": 9,  "role": "Central Intelligence"},
+    "AI Assistant Platform": {"layer": "Human Interface & System Operations", "level": 10, "role": "Central Intelligence"},
-    "AI Augmentation":              {"layer": "Orchestrators", "level": 6,  "role": "Curation"},
+    "AI Augmentation": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Curation"},
-    "AI Coding Agent":              {"layer": "DevOps", "level": 10, "role": "Coding Agent"},
+    "AI Coding Agent": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "AI Coding Agent"},
-    "AI Monitoring":                {"layer": "Observability", "level": 8,  "role": "Health Monitor"},
+    "AI Monitoring": {"layer": "Human Interface & System Operations", "level": 10, "role": "Health Monitor"},
-    "AI Observability":             {"layer": "Observability", "level": 8,  "role": "LLM Tracing"},
+    "AI Observability": {"layer": "Human Interface & System Operations", "level": 10, "role": "LLM Tracing"},
-    "AI Operating System":          {"layer": "DevOps", "level": 10,  "role": "OS Integration"},
+    "AI Operating System": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "OS Integration"},
-    "Academic References":          {"layer": "Knowledge Management", "level": 11, "role": "Reference Manager"},
+    "Academic References": {"layer": "Human Interface & System Operations", "level": 10, "role": "Reference Manager"},
-    "Agent Framework":              {"layer": "Orchestrators", "level": 6,  "role": "Multi-Agent"},
+    "Agent Daemon": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Agent Daemon"},
-    "Agent Network":                {"layer": "DevOps", "level": 10,  "role": "Discovery"},
+    "Agent Framework": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Agent Framework"},
-    "Agent OS":                     {"layer": "Orchestrators", "level": 6,  "role": "Hands"},
+    "Agent Network": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Discovery"},
-    "Agent Toolkit":                {"layer": "Orchestrators", "level": 6,  "role": "Tool Integration"},
+    "Agent OS": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Agent OS"},
-    "Agent Workflow":               {"layer": "Orchestrators", "level": 6,  "role": "Reasoning"},
+    "Agent Shell": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Agent Shell"},
-    "Algorithm Toolkit":            {"layer": "DevOps", "level": 10,  "role": "Hands"},
+    "Agent Toolkit": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Agent Toolkit"},
-    "Analytical Database":          {"layer": "Host Platform", "level": 1,  "role": "Foundation"},
+    "Agent Workflow": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Agent Workflow"},
-    "Antivirus":                    {"layer": "Security", "level": 7,  "role": "Scanner"},
+    "Agentless Deployment": {"layer": "Human Interface & System Operations", "level": 10, "role": "Agentless Deployment"},
-    "Build":                        {"layer": "Development Environment", "level": 2,  "role": "Build Tool"},
+    "Algorithm Toolkit": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Hands"},
-    "Audio Parsing":                {"layer": "Knowledge Management", "level": 11, "role": "Memory"},
+    "Alloy Telemetry": {"layer": "Human Interface & System Operations", "level": 10, "role": "Alloy Telemetry"},
-    "Auth":                         {"layer": "Security", "level": 7,  "role": "Identity"},
+    "Analytical Database": {"layer": "Host Platform & Infrastructure", "level": 1, "role": "Analytical Database"},
-    "Build Monitoring":             {"layer": "Observability", "level": 8,  "role": "Monitoring"},
+    "Antivirus": {"layer": "Human Interface & System Operations", "level": 10, "role": "Antivirus"},
-    "Cache":                        {"layer": "Host Platform", "level": 1,  "role": "Foundation"},
+    "Audio Extraction": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "Audio Extraction"},
-    "Chat":                         {"layer": "User Interfaces", "level": 9,  "role": "Face"},
+    "Audio Parsing": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "Memory"},
-    "Chat Agent Platform":          {"layer": "User Interfaces", "level": 9,  "role": "Face"},
+    "Auth": {"layer": "Host Platform & Infrastructure", "level": 1, "role": "Auth"},
-    "Chat Frontend":                {"layer": "User Interfaces", "level": 9,  "role": "Face"},
+    "Auto Recovery Daemon": {"layer": "Human Interface & System Operations", "level": 10, "role": "Auto Recovery Daemon"},
-    "Claude Code Skill":            {"layer": "Orchestrators", "level": 6,  "role": "Knowledge Graph Builder"},
+    "Build": {"layer": "Development Runtime & Environment", "level": 2, "role": "Build"},
-    "Cluster SSH":                  {"layer": "Orchestrators", "level": 6,  "role": "Coordination"},
+    "Build Monitoring": {"layer": "Development Runtime & Environment", "level": 2, "role": "Build Monitoring"},
-    "Code Analysis":                {"layer": "DevOps", "level": 10,  "role": "Inspector"},
+    "CI/CD Orchestration": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "CI/CD Orchestration"},
-    "Code Generation":              {"layer": "DevOps", "level": 10,  "role": "Hands"},
+    "CLI Pair Programmer": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "CLI Pair Programmer"},
-    "Computer Vision":              {"layer": "User Interfaces", "level": 9,  "role": "Vision"},
+    "Cache": {"layer": "Host Platform & Infrastructure", "level": 1, "role": "Cache"},
-    "Config Management":            {"layer": "DevOps", "level": 10,  "role": "Configuration Management"},
+    "Chat": {"layer": "Human Interface & System Operations", "level": 10, "role": "Face"},
-    "Container Ops":                {"layer": "Orchestrators", "level": 6,  "role": "Sandbox"},
+    "Chat Agent Platform": {"layer": "Human Interface & System Operations", "level": 10, "role": "Face"},
-    "Container Security":           {"layer": "Security", "level": 7,  "role": "Scanner"},
+    "Chat Frontend": {"layer": "Human Interface & System Operations", "level": 10, "role": "Chat Frontend"},
-    "Containers":                   {"layer": "Host Platform", "level": 1,  "role": "Container Runtime"},
+    "Claude Code Skill": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "Claude Code Skill"},
-    "Context Manager":              {"layer": "DevOps", "level": 10,  "role": "Context"},
+    "Cloud Dev Kit": {"layer": "Human Interface & System Operations", "level": 10, "role": "Cloud Dev Kit"},
-    "Cortex Memory":                {"layer": "Knowledge Management", "level": 11, "role": "Memory"},
+    "Cluster Homepage": {"layer": "Human Interface & System Operations", "level": 10, "role": "Cluster Homepage"},
-    "Dashboard":                     {"layer": "User Interfaces", "level": 9,  "role": "Face"},
+    "Cluster SSH": {"layer": "Human Interface & System Operations", "level": 10, "role": "Cluster SSH"},
-    "Data Pipeline":                {"layer": "Knowledge Management", "level": 11,  "role": "Ingestion"},
+    "Code Analysis": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "Inspector"},
-    "Data Sync":                    {"layer": "Knowledge Management", "level": 11,  "role": "Integration"},
+    "Code Generation": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "Hands"},
-    "Debugging":                    {"layer": "Development Environment", "level": 2,  "role": "Profiling"},
+    "Code Refactoring": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "Code Refactoring"},
-    "Database":                     {"layer": "Host Platform", "level": 1,  "role": "Foundation"},
+    "Codex Developer": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "Codex Developer"},
-    "Desktop Agent":                {"layer": "User Interfaces", "level": 9,  "role": "Face"},
+    "Collaborative Chat": {"layer": "Human Interface & System Operations", "level": 10, "role": "Collaborative Chat"},
-    "Dev Automation":               {"layer": "DevOps", "level": 10,  "role": "Hands"},
+    "Computer Vision": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "Vision"},
-    "Development":                  {"layer": "DevOps", "level": 10,  "role": "Hands"},
+    "Config Management": {"layer": "Human Interface & System Operations", "level": 10, "role": "Configuration Management"},
-    "Distributed Compilation":     {"layer": "Orchestrators", "level": 6,  "role": "Distribution"},
+    "Container Ops": {"layer": "Host Platform & Infrastructure", "level": 1, "role": "Sandbox"},
-    "Distributed Compute":          {"layer": "Orchestrators", "level": 6,  "role": "Scaling"},
+    "Container Security": {"layer": "Human Interface & System Operations", "level": 10, "role": "Container Security"},
-    "Document Converter":           {"layer": "Knowledge Management", "level": 11, "role": "File Parsing"},
+    "Containers": {"layer": "Host Platform & Infrastructure", "level": 1, "role": "Containers"},
-    "Document Management":          {"layer": "Knowledge Management", "level": 11, "role": "Document Archive"},
+    "Context Integrity Core": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "Context Integrity Core"},
-    "Document Understanding":       {"layer": "Knowledge Management", "level": 11, "role": "Comprehension"},
+    "Context Manager": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "Context"},
-    "Ebook Library":                {"layer": "Knowledge Management", "level": 11, "role": "Library Manager"},
+    "Coordination Protocol": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Coordination Protocol"},
-    "Ecosystem Dashboard":          {"layer": "User Interfaces", "level": 9,  "role": "Face"},
+    "Cortex Memory": {"layer": "Decentralized Knowledge & Vector Stores", "level": 8, "role": "Cortex Memory"},
-    "Efficient LLM":                {"layer": "Engines", "level": 4,  "role": "Engine"},
+    "Curation Pipeline": {"layer": "Intelligent API Routers & Proxies", "level": 5, "role": "Curation Pipeline"},
-    "File Parsing":                 {"layer": "Knowledge Management", "level": 11, "role": "Memory"},
+    "Dashboard": {"layer": "Human Interface & System Operations", "level": 10, "role": "Face"},
-    "Find Tool":                    {"layer": "Development Environment", "level": 2,  "role": "Search"},
+    "Data Ingest": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "Data Ingest"},
-    "GPU":                          {"layer": "GPU Runtimes", "level": 3,  "role": "Acceleration"},
+    "Data Pipeline": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "Ingestion"},
-    "GPU Computing":                {"layer": "Development Environment", "level": 2,  "role": "GPU Acceleration"},
+    "Data Sync": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "Integration"},
-    "Graph Database":               {"layer": "Knowledge Management", "level": 11,  "role": "Memory"},
+    "Database": {"layer": "Host Platform & Infrastructure", "level": 1, "role": "Database"},
-    "Graph RAG":                    {"layer": "Knowledge Management", "level": 11,  "role": "Knowledge Synthesis"},
+    "Datacenter Inference": {"layer": "Local Inference Engines", "level": 4, "role": "Datacenter Inference"},
-    "Homepage":                     {"layer": "User Interfaces", "level": 9,  "role": "Face"},
+    "Debugging": {"layer": "Development Runtime & Environment", "level": 2, "role": "Debugging"},
-    "IaC":                          {"layer": "DevOps", "level": 10,  "role": "Infrastructure as Code"},
+    "Desktop Agent": {"layer": "Human Interface & System Operations", "level": 10, "role": "Face"},
-    "IaC Control Plane":            {"layer": "DevOps", "level": 10,  "role": "Infrastructure as Code"},
+    "Desktop Agent Core": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Desktop Agent Core"},
-    "IaC Wrapper":                  {"layer": "DevOps", "level": 10,  "role": "Infrastructure as Code"},
+    "Desktop GUI": {"layer": "Human Interface & System Operations", "level": 10, "role": "Desktop GUI"},
-    "Image Generation":             {"layer": "User Interfaces", "level": 9,  "role": "Face"},
+    "Dev Automation": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "Hands"},
-    "Infrastructure":               {"layer": "Orchestrators", "level": 6,  "role": "Resource Manager"},
+    "Development": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "Hands"},
-    "Intrusion Prevention":         {"layer": "Security", "level": 7,  "role": "IDS"},
+    "Distributed Compilation": {"layer": "Development Runtime & Environment", "level": 2, "role": "Distributed Compilation"},
-    "Knowledge Graph":              {"layer": "DevOps", "level": 10,  "role": "Graph Builder"},
+    "Distributed Compute": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Distributed Compute"},
-    "Knowledge Graph Notes":        {"layer": "User Interfaces", "level": 9,  "role": "Face"},
+    "Distributed Search": {"layer": "Decentralized Knowledge & Vector Stores", "level": 8, "role": "Distributed Search"},
-    "LLM Evaluation":               {"layer": "Observability", "level": 8,  "role": "Evaluation"},
+    "Document Archiver": {"layer": "Human Interface & System Operations", "level": 10, "role": "Document Archiver"},
-    "Memory System":                {"layer": "Knowledge Management", "level": 11,  "role": "Memory"},
+    "Document Comprehension": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "Document Comprehension"},
-    "LLM Fine-tuning":              {"layer": "GPU Runtimes", "level": 3,  "role": "Abliteration"},
+    "Document Converter": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "File Parsing"},
-    "LLM Framework":                {"layer": "Orchestrators", "level": 6,  "role": "Orchestration"},
+    "Document Management": {"layer": "Human Interface & System Operations", "level": 10, "role": "Document Archive"},
-    "LLM GUI":                      {"layer": "User Interfaces", "level": 9,  "role": "Face"},
+    "Document Parser": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "Document Parser"},
-    "LLM Mesh":                     {"layer": "Routing", "level": 5,  "role": "API Gateway"},
+    "Document Understanding": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "Comprehension"},
-    "LLM Router":                   {"layer": "Routing", "level": 5,  "role": "API Gateway"},
+    "ETL Transformation": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "ETL Transformation"},
-    "LLM Runtime":                  {"layer": "Engines", "level": 4,  "role": "Engine"},
+    "Ebook Library": {"layer": "Human Interface & System Operations", "level": 10, "role": "Library Manager"},
-    "LLM Serving":                  {"layer": "Engines", "level": 4,  "role": "Engine"},
+    "Ecosystem Dashboard": {"layer": "Human Interface & System Operations", "level": 10, "role": "Face"},
-    "MCP Server":                   {"layer": "Orchestrators", "level": 6,  "role": "Code Audit"},
+    "Ecosystem Launcher": {"layer": "Human Interface & System Operations", "level": 10, "role": "Ecosystem Launcher"},
-    "Metrics":                      {"layer": "Observability", "level": 8,  "role": "Metrics Collector"},
+    "Efficient LLM": {"layer": "Local Inference Engines", "level": 4, "role": "Engine"},
-    "Mesh Client":                  {"layer": "Routing", "level": 5,  "role": "Coding Agent"},
+    "Enterprise Assistant": {"layer": "Human Interface & System Operations", "level": 10, "role": "Enterprise Assistant"},
-    "Mixed Precision":              {"layer": "GPU Runtimes", "level": 3,  "role": "Optimization"},
+    "Extensible Interface": {"layer": "Human Interface & System Operations", "level": 10, "role": "Extensible Interface"},
-    "Model Surgery":                {"layer": "Engines", "level": 4,  "role": "Abliteration"},
+    "File Discovery": {"layer": "Development Runtime & Environment", "level": 2, "role": "File Discovery"},
-    "Model Training":               {"layer": "Development Environment", "level": 2,  "role": "Training"},
+    "File Parsing": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "Memory"},
-    "Multi-Agent":                  {"layer": "Orchestrators", "level": 6,  "role": "Coordination"},
+    "Find Tool": {"layer": "Development Runtime & Environment", "level": 2, "role": "Search"},
-    "Networking":                   {"layer": "Host Platform", "level": 1,  "role": "Tunnel"},
+    "GGUF Runtime": {"layer": "Local Inference Engines", "level": 4, "role": "GGUF Runtime"},
-    "Notes":                        {"layer": "Knowledge Management", "level": 11, "role": "Note Taking"},
+    "GPU": {"layer": "GPU Acceleration & Optimization", "level": 3, "role": "Acceleration"},
-    "OCI Export":                   {"layer": "DevOps", "level": 10,  "role": "Runtime Packaging"},
+    "GPU Computing": {"layer": "GPU Acceleration & Optimization", "level": 3, "role": "GPU Computing"},
-    "Observability":                {"layer": "Observability", "level": 8,  "role": "Monitoring"},
+    "Gap Analyzer": {"layer": "Human Interface & System Operations", "level": 10, "role": "Gap Analyzer"},
-    "Outliner":                     {"layer": "Knowledge Management", "level": 11,  "role": "Knowledge Graph"},
+    "Graph Database": {"layer": "Decentralized Knowledge & Vector Stores", "level": 8, "role": "Graph Database"},
-    "PDF Pipeline":                 {"layer": "Knowledge Management", "level": 11,  "role": "Extraction"},
+    "Graph RAG": {"layer": "Decentralized Knowledge & Vector Stores", "level": 8, "role": "Knowledge Synthesis"},
-    "Parser":                       {"layer": "Development Environment", "level": 2,  "role": "Parsing"},
+    "Hardware Acceleration": {"layer": "GPU Acceleration & Optimization", "level": 3, "role": "Hardware Acceleration"},
-    "Persistent Memory":            {"layer": "Knowledge Management", "level": 11,  "role": "Memory"},
+    "High-Performance Vector": {"layer": "Decentralized Knowledge & Vector Stores", "level": 8, "role": "High-Performance Vector"},
-    "Pipeline":                     {"layer": "Routing", "level": 5,  "role": "Pipeline Orchestrator"},
+    "Homepage": {"layer": "Human Interface & System Operations", "level": 10, "role": "Face"},
-    "Policy Engine":                {"layer": "Security", "level": 7,  "role": "Policy"},
+    "IaC": {"layer": "Human Interface & System Operations", "level": 10, "role": "Infrastructure as Code"},
-    "Procfile Runner":              {"layer": "DevOps", "level": 10,  "role": "Process Manager"},
+    "IaC Control Plane": {"layer": "Human Interface & System Operations", "level": 10, "role": "IaC Control Plane"},
-    "Project Management":           {"layer": "DevOps", "level": 10,  "role": "Management"},
+    "IaC DRY Wrapper": {"layer": "Human Interface & System Operations", "level": 10, "role": "IaC DRY Wrapper"},
-    "Prompt Tooling":               {"layer": "DevOps", "level": 10,  "role": "Prompt Management"},
+    "IaC Wrapper": {"layer": "Human Interface & System Operations", "level": 10, "role": "Infrastructure as Code"},
-    "Provisioning":                 {"layer": "DevOps", "level": 10,  "role": "Provisioning"},
+    "Image Generation": {"layer": "Human Interface & System Operations", "level": 10, "role": "Face"},
-    "Proxy":                        {"layer": "Routing", "level": 5,  "role": "API Gateway"},
+    "Image WebUI": {"layer": "Human Interface & System Operations", "level": 10, "role": "Image WebUI"},
-    "Reasoning Engine":             {"layer": "Orchestrators", "level": 6,  "role": "Brain"},
+    "Infrastructure": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Infrastructure"},
-    "Runtime":                      {"layer": "Development Environment", "level": 2,  "role": "Build System"},
+    "Infrastructure Provision": {"layer": "Human Interface & System Operations", "level": 10, "role": "Infrastructure Provision"},
-    "Sandbox":                      {"layer": "DevOps", "level": 10,  "role": "Isolation"},
+    "Infrastructure as Code": {"layer": "Development Runtime & Environment", "level": 2, "role": "Infrastructure as Code"},
-    "Search Engine":                {"layer": "Knowledge Management", "level": 11, "role": "Memory"},
+    "Integration Library": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Integration Library"},
-    "Search Tool":                  {"layer": "Development Environment", "level": 2,  "role": "Search"},
+    "Intrusion Prevention": {"layer": "Host Platform & Infrastructure", "level": 1, "role": "Intrusion Prevention"},
-    "Shell":                        {"layer": "Development Environment", "level": 2,  "role": "Shell"},
+    "Isolation": {"layer": "Host Platform & Infrastructure", "level": 1, "role": "Isolation"},
-    "Secrets Management":           {"layer": "Security", "level": 7,  "role": "Secrets"},
+    "Knowledge Graph": {"layer": "Decentralized Knowledge & Vector Stores", "level": 8, "role": "Graph Builder"},
-    "Serverless Framework":         {"layer": "Development Environment", "level": 2,  "role": "Full-Stack Framework"},
+    "Knowledge Graph Notes": {"layer": "Human Interface & System Operations", "level": 10, "role": "Face"},
-    "Single-File LLM":              {"layer": "Engines", "level": 4,  "role": "Engine"},
+    "LLM Evaluation": {"layer": "Human Interface & System Operations", "level": 10, "role": "Evaluation"},
-    "Skill Analysis":               {"layer": "DevOps", "level": 10,  "role": "Assessment"},
+    "LLM Fine-tuning": {"layer": "GPU Acceleration & Optimization", "level": 3, "role": "Abliteration"},
-    "Skill Inspection":             {"layer": "DevOps", "level": 10,  "role": "Analysis"},
+    "LLM Framework": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Orchestration"},
-    "Spaced Repetition":            {"layer": "Knowledge Management", "level": 11,  "role": "Memory"},
+    "LLM GUI": {"layer": "Human Interface & System Operations", "level": 10, "role": "LLM GUI"},
-    "Spec Writer":                  {"layer": "DevOps", "level": 10,  "role": "Documentation"},
+    "LLM Mesh": {"layer": "Intelligent API Routers & Proxies", "level": 5, "role": "LLM Mesh"},
-    "Speech Recognition":           {"layer": "User Interfaces", "level": 9,  "role": "Senses"},
+    "LLM Observability": {"layer": "Human Interface & System Operations", "level": 10, "role": "LLM Observability"},
-    "Task Runner":                  {"layer": "DevOps", "level": 10,  "role": "Scheduler"},
+    "LLM Router": {"layer": "Intelligent API Routers & Proxies", "level": 5, "role": "API Gateway"},
-    "Telemetry":                    {"layer": "Observability", "level": 8,  "role": "Collector"},
+    "LLM Runtime": {"layer": "Local Inference Engines", "level": 4, "role": "Engine"},
-    "Terminal":                     {"layer": "Host Platform", "level": 1,  "role": "Multiplexer"},
+    "LLM Serving": {"layer": "Local Inference Engines", "level": 4, "role": "LLM Serving"},
-    "Text-to-Speech":               {"layer": "User Interfaces", "level": 9,  "role": "Voice"},
+    "Layer-wise Inference": {"layer": "Local Inference Engines", "level": 4, "role": "Layer-wise Inference"},
-    "Uncensored Models":            {"layer": "Engines", "level": 4,  "role": "Engine"},
+    "Learning Cards": {"layer": "Human Interface & System Operations", "level": 10, "role": "Learning Cards"},
-    "VCS":                          {"layer": "Host Platform", "level": 1,  "role": "Version Control"},
+    "Lexical Search": {"layer": "Decentralized Knowledge & Vector Stores", "level": 8, "role": "Lexical Search"},
-    "Vector Engine":                {"layer": "Knowledge Management", "level": 11,  "role": "Embedding"},
+    "Library Manager": {"layer": "Human Interface & System Operations", "level": 10, "role": "Library Manager"},
-    "Vector Store":                 {"layer": "Knowledge Management", "level": 11,  "role": "Memory"},
+    "Load Balancer": {"layer": "Intelligent API Routers & Proxies", "level": 5, "role": "Load Balancer"},
-    "Visualization":                {"layer": "Observability", "level": 8,  "role": "Dashboard"},
+    "Local Central Shell": {"layer": "Human Interface & System Operations", "level": 10, "role": "Local Central Shell"},
-    "Virtualization":               {"layer": "Host Platform", "level": 1,  "role": "MicroVM"},
+    "Local Declarative DSL": {"layer": "Human Interface & System Operations", "level": 10, "role": "Local Declarative DSL"},
-    "Web Crawler":                  {"layer": "Knowledge Management", "level": 11,  "role": "Data Harvesting"},
+    "Local LLM Runner": {"layer": "Local Inference Engines", "level": 4, "role": "Local LLM Runner"},
-    "Workflow":                     {"layer": "Orchestrators", "level": 6,  "role": "Visual Builder"},
+    "MCP Server": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "Code Audit"},
-    "Workflow Automation":          {"layer": "Orchestrators", "level": 6,  "role": "Workflow Orchestrator"},
+    "Markdown Converter": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "Markdown Converter"},
+    "Memory System": {"layer": "Decentralized Knowledge & Vector Stores", "level": 8, "role": "Memory System"},
+    "Mesh Client": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "Mesh Client"},
+    "Metal Provisioner": {"layer": "Human Interface & System Operations", "level": 10, "role": "Metal Provisioner"},
+    "Metric Scraper": {"layer": "Human Interface & System Operations", "level": 10, "role": "Metric Scraper"},
+    "Metrics": {"layer": "Human Interface & System Operations", "level": 10, "role": "Metrics"},
+    "Mixed Precision": {"layer": "GPU Acceleration & Optimization", "level": 3, "role": "Mixed Precision"},
+    "Model Curation": {"layer": "Local Inference Engines", "level": 4, "role": "Model Curation"},
+    "Model Manager GUI": {"layer": "Human Interface & System Operations", "level": 10, "role": "Model Manager GUI"},
+    "Model Optimization": {"layer": "GPU Acceleration & Optimization", "level": 3, "role": "Model Optimization"},
+    "Model Surgery": {"layer": "Local Inference Engines", "level": 4, "role": "Model Surgery"},
+    "Model Training": {"layer": "GPU Acceleration & Optimization", "level": 3, "role": "Training"},
+    "Multi-Agent": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Multi-Agent"},
+    "Multi-Agent Framework": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Multi-Agent Framework"},
+    "Native Inference": {"layer": "Local Inference Engines", "level": 4, "role": "Native Inference"},
+    "Networking": {"layer": "Host Platform & Infrastructure", "level": 1, "role": "Networking"},
+    "Notes": {"layer": "Human Interface & System Operations", "level": 10, "role": "Note Taking"},
+    "OCI Export": {"layer": "Host Platform & Infrastructure", "level": 1, "role": "Runtime Packaging"},
+    "Observability": {"layer": "Human Interface & System Operations", "level": 10, "role": "Observability"},
+    "Offline Journal": {"layer": "Human Interface & System Operations", "level": 10, "role": "Offline Journal"},
+    "Open-Source IaC": {"layer": "Human Interface & System Operations", "level": 10, "role": "Open-Source IaC"},
+    "Outliner": {"layer": "Human Interface & System Operations", "level": 10, "role": "Knowledge Graph"},
+    "Outliner Graph": {"layer": "Human Interface & System Operations", "level": 10, "role": "Outliner Graph"},
+    "Output Evaluator": {"layer": "Human Interface & System Operations", "level": 10, "role": "Output Evaluator"},
+    "PDF Pipeline": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "Extraction"},
+    "PDF Processing": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "PDF Processing"},
+    "Parser": {"layer": "Development Runtime & Environment", "level": 2, "role": "Parsing"},
+    "Parsing Engine": {"layer": "Development Runtime & Environment", "level": 2, "role": "Parsing Engine"},
+    "Performance Engine": {"layer": "Local Inference Engines", "level": 4, "role": "Performance Engine"},
+    "Persistent Memory": {"layer": "Decentralized Knowledge & Vector Stores", "level": 8, "role": "Persistent Memory"},
+    "Pipeline": {"layer": "Intelligent API Routers & Proxies", "level": 5, "role": "Pipeline Orchestrator"},
+    "Platform Workspace": {"layer": "Human Interface & System Operations", "level": 10, "role": "Platform Workspace"},
+    "Policy Engine": {"layer": "Human Interface & System Operations", "level": 10, "role": "Policy Engine"},
+    "Procfile Runner": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Process Manager"},
+    "Production Multi-Agent": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Production Multi-Agent"},
+    "Programmable IaC": {"layer": "Human Interface & System Operations", "level": 10, "role": "Programmable IaC"},
+    "Project Management": {"layer": "Human Interface & System Operations", "level": 10, "role": "Project Management"},
+    "Prompt Tester": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "Prompt Tester"},
+    "Prompt Tooling": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "Prompt Management"},
+    "Provisioning": {"layer": "Human Interface & System Operations", "level": 10, "role": "Provisioning"},
+    "Proxy": {"layer": "Intelligent API Routers & Proxies", "level": 5, "role": "API Gateway"},
+    "RAG Flow Canvas": {"layer": "Human Interface & System Operations", "level": 10, "role": "RAG Flow Canvas"},
+    "Reasoning Engine": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Reasoning Engine"},
+    "Reference Manager": {"layer": "Human Interface & System Operations", "level": 10, "role": "Reference Manager"},
+    "Requirement Builder": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "Requirement Builder"},
+    "Role-Playing Agent": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Role-Playing Agent"},
+    "Runtime": {"layer": "Development Runtime & Environment", "level": 2, "role": "Runtime"},
+    "Runtime Environment": {"layer": "Development Runtime & Environment", "level": 2, "role": "Runtime Environment"},
+    "Runtime Packaging": {"layer": "Host Platform & Infrastructure", "level": 1, "role": "Runtime Packaging"},
+    "Sandbox": {"layer": "Host Platform & Infrastructure", "level": 1, "role": "Isolation"},
+    "Search Engine": {"layer": "Decentralized Knowledge & Vector Stores", "level": 8, "role": "Memory"},
+    "Search Tool": {"layer": "Development Runtime & Environment", "level": 2, "role": "Search"},
+    "Secrets Management": {"layer": "Host Platform & Infrastructure", "level": 1, "role": "Secrets Management"},
+    "Serverless Database": {"layer": "Decentralized Knowledge & Vector Stores", "level": 8, "role": "Serverless Database"},
+    "Serverless Framework": {"layer": "Development Runtime & Environment", "level": 2, "role": "Full-Stack Framework"},
+    "Shell": {"layer": "Development Runtime & Environment", "level": 2, "role": "Shell"},
+    "Single-File LLM": {"layer": "Local Inference Engines", "level": 4, "role": "Engine"},
+    "Single-File Runtime": {"layer": "Local Inference Engines", "level": 4, "role": "Single-File Runtime"},
+    "Skill Analysis": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "Assessment"},
+    "Skill Auditor": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "Skill Auditor"},
+    "Skill Inspection": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "Analysis"},
+    "Sovereign Graph Editor": {"layer": "Human Interface & System Operations", "level": 10, "role": "Sovereign Graph Editor"},
+    "Sovereign Software Agent": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "Sovereign Software Agent"},
+    "Spaced Repetition": {"layer": "Human Interface & System Operations", "level": 10, "role": "Memory"},
+    "Spec Writer": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "Documentation"},
+    "Speech Recognition": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "Senses"},
+    "Speech Transcriber": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "Speech Transcriber"},
+    "Sprint Planner": {"layer": "Human Interface & System Operations", "level": 10, "role": "Sprint Planner"},
+    "Sprints Manager": {"layer": "Human Interface & System Operations", "level": 10, "role": "Sprints Manager"},
+    "Stateless Orchestration": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Stateless Orchestration"},
+    "Structured Synthesis": {"layer": "Decentralized Knowledge & Vector Stores", "level": 8, "role": "Structured Synthesis"},
+    "Studio Canvas": {"layer": "Human Interface & System Operations", "level": 10, "role": "Studio Canvas"},
+    "Synchronization Layer": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "Synchronization Layer"},
+    "System Auditor": {"layer": "Human Interface & System Operations", "level": 10, "role": "System Auditor"},
+    "System Console": {"layer": "Human Interface & System Operations", "level": 10, "role": "System Console"},
+    "Task Runner": {"layer": "Human Interface & System Operations", "level": 10, "role": "Scheduler"},
+    "Telemetry": {"layer": "Human Interface & System Operations", "level": 10, "role": "Collector"},
+    "Telemetry Monitor": {"layer": "Human Interface & System Operations", "level": 10, "role": "Telemetry Monitor"},
+    "Telemetry Visualizer": {"layer": "Human Interface & System Operations", "level": 10, "role": "Telemetry Visualizer"},
+    "Terminal": {"layer": "Host Platform & Infrastructure", "level": 1, "role": "Terminal"},
+    "Terminal Agent": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Terminal Agent"},
+    "Terminal Coding Agent": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "Terminal Coding Agent"},
+    "Text Search": {"layer": "Development Runtime & Environment", "level": 2, "role": "Text Search"},
+    "Text-to-Speech": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "Voice"},
+    "Uncensored Models": {"layer": "Local Inference Engines", "level": 4, "role": "Engine"},
+    "Unified API Gateway": {"layer": "Intelligent API Routers & Proxies", "level": 5, "role": "Unified API Gateway"},
+    "VCS": {"layer": "Development Runtime & Environment", "level": 2, "role": "VCS"},
+    "Vector Engine": {"layer": "Decentralized Knowledge & Vector Stores", "level": 8, "role": "Vector Engine"},
+    "Vector Store": {"layer": "Decentralized Knowledge & Vector Stores", "level": 8, "role": "Memory"},
+    "Virtualization": {"layer": "Host Platform & Infrastructure", "level": 1, "role": "Virtualization"},
+    "Vision describer": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "Vision describer"},
+    "Visual Agent Canvas": {"layer": "Human Interface & System Operations", "level": 10, "role": "Visual Agent Canvas"},
+    "Visualization": {"layer": "Human Interface & System Operations", "level": 10, "role": "Dashboard"},
+    "Voice Synthesis": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "Voice Synthesis"},
+    "Web Crawler": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "Data Harvesting"},
+    "Web Scraper": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "Web Scraper"},
+    "Workflow": {"layer": "Human Interface & System Operations", "level": 10, "role": "Visual Builder"},
+    "Workflow Automation": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Workflow Automation"},
 }
 
 # ── Field-constant lookups (populated once on first use) ─────────────

src/ai_lsc/ui/pages/db_manager_category_map.py

@@ -0,0 +1,226 @@
+# This file contains the fully reorganized CATEGORY_MAP for db_manager.py
+# mapped cleanly to the 10-Layer Systems Architecture.
+
+CATEGORY_MAP: dict[str, dict[str, object]] = {
+    "AI Agent": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "AI Agent"},
+    "AI Assistant Platform": {"layer": "Human Interface & System Operations", "level": 10, "role": "Central Intelligence"},
+    "AI Augmentation": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Curation"},
+    "AI Coding Agent": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "AI Coding Agent"},
+    "AI Monitoring": {"layer": "Human Interface & System Operations", "level": 10, "role": "Health Monitor"},
+    "AI Observability": {"layer": "Human Interface & System Operations", "level": 10, "role": "LLM Tracing"},
+    "AI Operating System": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "OS Integration"},
+    "Academic References": {"layer": "Human Interface & System Operations", "level": 10, "role": "Reference Manager"},
+    "Agent Daemon": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Agent Daemon"},
+    "Agent Framework": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Agent Framework"},
+    "Agent Network": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Discovery"},
+    "Agent OS": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Agent OS"},
+    "Agent Shell": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Agent Shell"},
+    "Agent Toolkit": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Agent Toolkit"},
+    "Agent Workflow": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Agent Workflow"},
+    "Agentless Deployment": {"layer": "Human Interface & System Operations", "level": 10, "role": "Agentless Deployment"},
+    "Algorithm Toolkit": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Hands"},
+    "Alloy Telemetry": {"layer": "Human Interface & System Operations", "level": 10, "role": "Alloy Telemetry"},
+    "Analytical Database": {"layer": "Host Platform & Infrastructure", "level": 1, "role": "Analytical Database"},
+    "Antivirus": {"layer": "Human Interface & System Operations", "level": 10, "role": "Antivirus"},
+    "Audio Extraction": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "Audio Extraction"},
+    "Audio Parsing": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "Memory"},
+    "Auth": {"layer": "Host Platform & Infrastructure", "level": 1, "role": "Auth"},
+    "Auto Recovery Daemon": {"layer": "Human Interface & System Operations", "level": 10, "role": "Auto Recovery Daemon"},
+    "Build": {"layer": "Development Runtime & Environment", "level": 2, "role": "Build"},
+    "Build Monitoring": {"layer": "Development Runtime & Environment", "level": 2, "role": "Build Monitoring"},
+    "CI/CD Orchestration": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "CI/CD Orchestration"},
+    "CLI Pair Programmer": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "CLI Pair Programmer"},
+    "Cache": {"layer": "Host Platform & Infrastructure", "level": 1, "role": "Cache"},
+    "Chat": {"layer": "Human Interface & System Operations", "level": 10, "role": "Face"},
+    "Chat Agent Platform": {"layer": "Human Interface & System Operations", "level": 10, "role": "Face"},
+    "Chat Frontend": {"layer": "Human Interface & System Operations", "level": 10, "role": "Chat Frontend"},
+    "Claude Code Skill": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "Claude Code Skill"},
+    "Cloud Dev Kit": {"layer": "Human Interface & System Operations", "level": 10, "role": "Cloud Dev Kit"},
+    "Cluster Homepage": {"layer": "Human Interface & System Operations", "level": 10, "role": "Cluster Homepage"},
+    "Cluster SSH": {"layer": "Human Interface & System Operations", "level": 10, "role": "Cluster SSH"},
+    "Code Analysis": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "Inspector"},
+    "Code Generation": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "Hands"},
+    "Code Refactoring": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "Code Refactoring"},
+    "Codex Developer": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "Codex Developer"},
+    "Collaborative Chat": {"layer": "Human Interface & System Operations", "level": 10, "role": "Collaborative Chat"},
+    "Computer Vision": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "Vision"},
+    "Config Management": {"layer": "Human Interface & System Operations", "level": 10, "role": "Configuration Management"},
+    "Container Ops": {"layer": "Host Platform & Infrastructure", "level": 1, "role": "Sandbox"},
+    "Container Security": {"layer": "Human Interface & System Operations", "level": 10, "role": "Container Security"},
+    "Containers": {"layer": "Host Platform & Infrastructure", "level": 1, "role": "Containers"},
+    "Context Integrity Core": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "Context Integrity Core"},
+    "Context Manager": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "Context"},
+    "Coordination Protocol": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Coordination Protocol"},
+    "Cortex Memory": {"layer": "Decentralized Knowledge & Vector Stores", "level": 8, "role": "Cortex Memory"},
+    "Curation Pipeline": {"layer": "Intelligent API Routers & Proxies", "level": 5, "role": "Curation Pipeline"},
+    "Dashboard": {"layer": "Human Interface & System Operations", "level": 10, "role": "Face"},
+    "Data Ingest": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "Data Ingest"},
+    "Data Pipeline": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "Ingestion"},
+    "Data Sync": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "Integration"},
+    "Database": {"layer": "Host Platform & Infrastructure", "level": 1, "role": "Database"},
+    "Datacenter Inference": {"layer": "Local Inference Engines", "level": 4, "role": "Datacenter Inference"},
+    "Debugging": {"layer": "Development Runtime & Environment", "level": 2, "role": "Debugging"},
+    "Desktop Agent": {"layer": "Human Interface & System Operations", "level": 10, "role": "Face"},
+    "Desktop Agent Core": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Desktop Agent Core"},
+    "Desktop GUI": {"layer": "Human Interface & System Operations", "level": 10, "role": "Desktop GUI"},
+    "Dev Automation": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "Hands"},
+    "Development": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "Hands"},
+    "Distributed Compilation": {"layer": "Development Runtime & Environment", "level": 2, "role": "Distributed Compilation"},
+    "Distributed Compute": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Distributed Compute"},
+    "Distributed Search": {"layer": "Decentralized Knowledge & Vector Stores", "level": 8, "role": "Distributed Search"},
+    "Document Archiver": {"layer": "Human Interface & System Operations", "level": 10, "role": "Document Archiver"},
+    "Document Comprehension": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "Document Comprehension"},
+    "Document Converter": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "File Parsing"},
+    "Document Management": {"layer": "Human Interface & System Operations", "level": 10, "role": "Document Archive"},
+    "Document Parser": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "Document Parser"},
+    "Document Understanding": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "Comprehension"},
+    "ETL Transformation": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "ETL Transformation"},
+    "Ebook Library": {"layer": "Human Interface & System Operations", "level": 10, "role": "Library Manager"},
+    "Ecosystem Dashboard": {"layer": "Human Interface & System Operations", "level": 10, "role": "Face"},
+    "Ecosystem Launcher": {"layer": "Human Interface & System Operations", "level": 10, "role": "Ecosystem Launcher"},
+    "Efficient LLM": {"layer": "Local Inference Engines", "level": 4, "role": "Engine"},
+    "Enterprise Assistant": {"layer": "Human Interface & System Operations", "level": 10, "role": "Enterprise Assistant"},
+    "Extensible Interface": {"layer": "Human Interface & System Operations", "level": 10, "role": "Extensible Interface"},
+    "File Discovery": {"layer": "Development Runtime & Environment", "level": 2, "role": "File Discovery"},
+    "File Parsing": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "Memory"},
+    "Find Tool": {"layer": "Development Runtime & Environment", "level": 2, "role": "Search"},
+    "GGUF Runtime": {"layer": "Local Inference Engines", "level": 4, "role": "GGUF Runtime"},
+    "GPU": {"layer": "GPU Acceleration & Optimization", "level": 3, "role": "Acceleration"},
+    "GPU Computing": {"layer": "GPU Acceleration & Optimization", "level": 3, "role": "GPU Computing"},
+    "Gap Analyzer": {"layer": "Human Interface & System Operations", "level": 10, "role": "Gap Analyzer"},
+    "Graph Database": {"layer": "Decentralized Knowledge & Vector Stores", "level": 8, "role": "Graph Database"},
+    "Graph RAG": {"layer": "Decentralized Knowledge & Vector Stores", "level": 8, "role": "Knowledge Synthesis"},
+    "Hardware Acceleration": {"layer": "GPU Acceleration & Optimization", "level": 3, "role": "Hardware Acceleration"},
+    "High-Performance Vector": {"layer": "Decentralized Knowledge & Vector Stores", "level": 8, "role": "High-Performance Vector"},
+    "Homepage": {"layer": "Human Interface & System Operations", "level": 10, "role": "Face"},
+    "IaC": {"layer": "Human Interface & System Operations", "level": 10, "role": "Infrastructure as Code"},
+    "IaC Control Plane": {"layer": "Human Interface & System Operations", "level": 10, "role": "IaC Control Plane"},
+    "IaC DRY Wrapper": {"layer": "Human Interface & System Operations", "level": 10, "role": "IaC DRY Wrapper"},
+    "IaC Wrapper": {"layer": "Human Interface & System Operations", "level": 10, "role": "Infrastructure as Code"},
+    "Image Generation": {"layer": "Human Interface & System Operations", "level": 10, "role": "Face"},
+    "Image WebUI": {"layer": "Human Interface & System Operations", "level": 10, "role": "Image WebUI"},
+    "Infrastructure": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Infrastructure"},
+    "Infrastructure Provision": {"layer": "Human Interface & System Operations", "level": 10, "role": "Infrastructure Provision"},
+    "Infrastructure as Code": {"layer": "Development Runtime & Environment", "level": 2, "role": "Infrastructure as Code"},
+    "Integration Library": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Integration Library"},
+    "Intrusion Prevention": {"layer": "Host Platform & Infrastructure", "level": 1, "role": "Intrusion Prevention"},
+    "Isolation": {"layer": "Host Platform & Infrastructure", "level": 1, "role": "Isolation"},
+    "Knowledge Graph": {"layer": "Decentralized Knowledge & Vector Stores", "level": 8, "role": "Graph Builder"},
+    "Knowledge Graph Notes": {"layer": "Human Interface & System Operations", "level": 10, "role": "Face"},
+    "LLM Evaluation": {"layer": "Human Interface & System Operations", "level": 10, "role": "Evaluation"},
+    "LLM Fine-tuning": {"layer": "GPU Acceleration & Optimization", "level": 3, "role": "Abliteration"},
+    "LLM Framework": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Orchestration"},
+    "LLM GUI": {"layer": "Human Interface & System Operations", "level": 10, "role": "LLM GUI"},
+    "LLM Mesh": {"layer": "Intelligent API Routers & Proxies", "level": 5, "role": "LLM Mesh"},
+    "LLM Observability": {"layer": "Human Interface & System Operations", "level": 10, "role": "LLM Observability"},
+    "LLM Router": {"layer": "Intelligent API Routers & Proxies", "level": 5, "role": "API Gateway"},
+    "LLM Runtime": {"layer": "Local Inference Engines", "level": 4, "role": "Engine"},
+    "LLM Serving": {"layer": "Local Inference Engines", "level": 4, "role": "LLM Serving"},
+    "Layer-wise Inference": {"layer": "Local Inference Engines", "level": 4, "role": "Layer-wise Inference"},
+    "Learning Cards": {"layer": "Human Interface & System Operations", "level": 10, "role": "Learning Cards"},
+    "Lexical Search": {"layer": "Decentralized Knowledge & Vector Stores", "level": 8, "role": "Lexical Search"},
+    "Library Manager": {"layer": "Human Interface & System Operations", "level": 10, "role": "Library Manager"},
+    "Load Balancer": {"layer": "Intelligent API Routers & Proxies", "level": 5, "role": "Load Balancer"},
+    "Local Central Shell": {"layer": "Human Interface & System Operations", "level": 10, "role": "Local Central Shell"},
+    "Local Declarative DSL": {"layer": "Human Interface & System Operations", "level": 10, "role": "Local Declarative DSL"},
+    "Local LLM Runner": {"layer": "Local Inference Engines", "level": 4, "role": "Local LLM Runner"},
+    "MCP Server": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "Code Audit"},
+    "Markdown Converter": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "Markdown Converter"},
+    "Memory System": {"layer": "Decentralized Knowledge & Vector Stores", "level": 8, "role": "Memory System"},
+    "Mesh Client": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "Mesh Client"},
+    "Metal Provisioner": {"layer": "Human Interface & System Operations", "level": 10, "role": "Metal Provisioner"},
+    "Metric Scraper": {"layer": "Human Interface & System Operations", "level": 10, "role": "Metric Scraper"},
+    "Metrics": {"layer": "Human Interface & System Operations", "level": 10, "role": "Metrics"},
+    "Mixed Precision": {"layer": "GPU Acceleration & Optimization", "level": 3, "role": "Mixed Precision"},
+    "Model Curation": {"layer": "Local Inference Engines", "level": 4, "role": "Model Curation"},
+    "Model Manager GUI": {"layer": "Human Interface & System Operations", "level": 10, "role": "Model Manager GUI"},
+    "Model Optimization": {"layer": "GPU Acceleration & Optimization", "level": 3, "role": "Model Optimization"},
+    "Model Surgery": {"layer": "Local Inference Engines", "level": 4, "role": "Model Surgery"},
+    "Model Training": {"layer": "GPU Acceleration & Optimization", "level": 3, "role": "Training"},
+    "Multi-Agent": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Multi-Agent"},
+    "Multi-Agent Framework": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Multi-Agent Framework"},
+    "Native Inference": {"layer": "Local Inference Engines", "level": 4, "role": "Native Inference"},
+    "Networking": {"layer": "Host Platform & Infrastructure", "level": 1, "role": "Networking"},
+    "Notes": {"layer": "Human Interface & System Operations", "level": 10, "role": "Note Taking"},
+    "OCI Export": {"layer": "Host Platform & Infrastructure", "level": 1, "role": "Runtime Packaging"},
+    "Observability": {"layer": "Human Interface & System Operations", "level": 10, "role": "Observability"},
+    "Offline Journal": {"layer": "Human Interface & System Operations", "level": 10, "role": "Offline Journal"},
+    "Open-Source IaC": {"layer": "Human Interface & System Operations", "level": 10, "role": "Open-Source IaC"},
+    "Outliner": {"layer": "Human Interface & System Operations", "level": 10, "role": "Knowledge Graph"},
+    "Outliner Graph": {"layer": "Human Interface & System Operations", "level": 10, "role": "Outliner Graph"},
+    "Output Evaluator": {"layer": "Human Interface & System Operations", "level": 10, "role": "Output Evaluator"},
+    "PDF Pipeline": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "Extraction"},
+    "PDF Processing": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "PDF Processing"},
+    "Parser": {"layer": "Development Runtime & Environment", "level": 2, "role": "Parsing"},
+    "Parsing Engine": {"layer": "Development Runtime & Environment", "level": 2, "role": "Parsing Engine"},
+    "Performance Engine": {"layer": "Local Inference Engines", "level": 4, "role": "Performance Engine"},
+    "Persistent Memory": {"layer": "Decentralized Knowledge & Vector Stores", "level": 8, "role": "Persistent Memory"},
+    "Pipeline": {"layer": "Intelligent API Routers & Proxies", "level": 5, "role": "Pipeline Orchestrator"},
+    "Platform Workspace": {"layer": "Human Interface & System Operations", "level": 10, "role": "Platform Workspace"},
+    "Policy Engine": {"layer": "Human Interface & System Operations", "level": 10, "role": "Policy Engine"},
+    "Procfile Runner": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Process Manager"},
+    "Production Multi-Agent": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Production Multi-Agent"},
+    "Programmable IaC": {"layer": "Human Interface & System Operations", "level": 10, "role": "Programmable IaC"},
+    "Project Management": {"layer": "Human Interface & System Operations", "level": 10, "role": "Project Management"},
+    "Prompt Tester": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "Prompt Tester"},
+    "Prompt Tooling": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "Prompt Management"},
+    "Provisioning": {"layer": "Human Interface & System Operations", "level": 10, "role": "Provisioning"},
+    "Proxy": {"layer": "Intelligent API Routers & Proxies", "level": 5, "role": "API Gateway"},
+    "RAG Flow Canvas": {"layer": "Human Interface & System Operations", "level": 10, "role": "RAG Flow Canvas"},
+    "Reasoning Engine": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Reasoning Engine"},
+    "Reference Manager": {"layer": "Human Interface & System Operations", "level": 10, "role": "Reference Manager"},
+    "Requirement Builder": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "Requirement Builder"},
+    "Role-Playing Agent": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Role-Playing Agent"},
+    "Runtime": {"layer": "Development Runtime & Environment", "level": 2, "role": "Runtime"},
+    "Runtime Environment": {"layer": "Development Runtime & Environment", "level": 2, "role": "Runtime Environment"},
+    "Runtime Packaging": {"layer": "Host Platform & Infrastructure", "level": 1, "role": "Runtime Packaging"},
+    "Sandbox": {"layer": "Host Platform & Infrastructure", "level": 1, "role": "Isolation"},
+    "Search Engine": {"layer": "Decentralized Knowledge & Vector Stores", "level": 8, "role": "Memory"},
+    "Search Tool": {"layer": "Development Runtime & Environment", "level": 2, "role": "Search"},
+    "Secrets Management": {"layer": "Host Platform & Infrastructure", "level": 1, "role": "Secrets Management"},
+    "Serverless Database": {"layer": "Decentralized Knowledge & Vector Stores", "level": 8, "role": "Serverless Database"},
+    "Serverless Framework": {"layer": "Development Runtime & Environment", "level": 2, "role": "Full-Stack Framework"},
+    "Shell": {"layer": "Development Runtime & Environment", "level": 2, "role": "Shell"},
+    "Single-File LLM": {"layer": "Local Inference Engines", "level": 4, "role": "Engine"},
+    "Single-File Runtime": {"layer": "Local Inference Engines", "level": 4, "role": "Single-File Runtime"},
+    "Skill Analysis": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "Assessment"},
+    "Skill Auditor": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "Skill Auditor"},
+    "Skill Inspection": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "Analysis"},
+    "Sovereign Graph Editor": {"layer": "Human Interface & System Operations", "level": 10, "role": "Sovereign Graph Editor"},
+    "Sovereign Software Agent": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "Sovereign Software Agent"},
+    "Spaced Repetition": {"layer": "Human Interface & System Operations", "level": 10, "role": "Memory"},
+    "Spec Writer": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "Documentation"},
+    "Speech Recognition": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "Senses"},
+    "Speech Transcriber": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "Speech Transcriber"},
+    "Sprint Planner": {"layer": "Human Interface & System Operations", "level": 10, "role": "Sprint Planner"},
+    "Sprints Manager": {"layer": "Human Interface & System Operations", "level": 10, "role": "Sprints Manager"},
+    "Stateless Orchestration": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Stateless Orchestration"},
+    "Structured Synthesis": {"layer": "Decentralized Knowledge & Vector Stores", "level": 8, "role": "Structured Synthesis"},
+    "Studio Canvas": {"layer": "Human Interface & System Operations", "level": 10, "role": "Studio Canvas"},
+    "Synchronization Layer": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "Synchronization Layer"},
+    "System Auditor": {"layer": "Human Interface & System Operations", "level": 10, "role": "System Auditor"},
+    "System Console": {"layer": "Human Interface & System Operations", "level": 10, "role": "System Console"},
+    "Task Runner": {"layer": "Human Interface & System Operations", "level": 10, "role": "Scheduler"},
+    "Telemetry": {"layer": "Human Interface & System Operations", "level": 10, "role": "Collector"},
+    "Telemetry Monitor": {"layer": "Human Interface & System Operations", "level": 10, "role": "Telemetry Monitor"},
+    "Telemetry Visualizer": {"layer": "Human Interface & System Operations", "level": 10, "role": "Telemetry Visualizer"},
+    "Terminal": {"layer": "Host Platform & Infrastructure", "level": 1, "role": "Terminal"},
+    "Terminal Agent": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Terminal Agent"},
+    "Terminal Coding Agent": {"layer": "Agentic Software Engineering & Sandboxes", "level": 7, "role": "Terminal Coding Agent"},
+    "Text Search": {"layer": "Development Runtime & Environment", "level": 2, "role": "Text Search"},
+    "Text-to-Speech": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "Voice"},
+    "Uncensored Models": {"layer": "Local Inference Engines", "level": 4, "role": "Engine"},
+    "Unified API Gateway": {"layer": "Intelligent API Routers & Proxies", "level": 5, "role": "Unified API Gateway"},
+    "VCS": {"layer": "Development Runtime & Environment", "level": 2, "role": "VCS"},
+    "Vector Engine": {"layer": "Decentralized Knowledge & Vector Stores", "level": 8, "role": "Vector Engine"},
+    "Vector Store": {"layer": "Decentralized Knowledge & Vector Stores", "level": 8, "role": "Memory"},
+    "Virtualization": {"layer": "Host Platform & Infrastructure", "level": 1, "role": "Virtualization"},
+    "Vision describer": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "Vision describer"},
+    "Visual Agent Canvas": {"layer": "Human Interface & System Operations", "level": 10, "role": "Visual Agent Canvas"},
+    "Visualization": {"layer": "Human Interface & System Operations", "level": 10, "role": "Dashboard"},
+    "Voice Synthesis": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "Voice Synthesis"},
+    "Web Crawler": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "Data Harvesting"},
+    "Web Scraper": {"layer": "Data Extraction & Pipeline Harvest", "level": 9, "role": "Web Scraper"},
+    "Workflow": {"layer": "Human Interface & System Operations", "level": 10, "role": "Visual Builder"},
+    "Workflow Automation": {"layer": "Multi-Agent Orchestration Runtimes", "level": 6, "role": "Workflow Automation"},
+}

whatremains.txt

@@ -1,10 +1,14 @@
 # AI-LSC Master Critique — What Remains
 ## Items intentionally skipped or deferred from this pass
 
-**Date**: 2026-07-07
+**Date**: 2026-07-07 (critique pass) / updated 2026-08-30 (v3.2 taxonomy migration)
 **Pass scope**: CRITICAL (C-01, C-02, C-03, C-04, C-06, C-07) + all 24 HIGH + all 42 MEDIUM + all 20 LOW
 **Pass status**: 91 of 93 findings addressed in code; 2 explicitly skipped per user instruction
 **Double-check pass**: 19/19 functional spot-checks pass; 2 latent bugs found and fixed (see "Bugs caught during double-check" below)
+**v3.2 note**: the 10-layer taxonomy migration preserved every curl|sh
+site below verbatim — the restored installer cmds (ollama, llamafile,
+qdrant, grafana_alloy, meilisearch, fabric) are byte-identical to the
+pre-migration registry, so the C-05 policy state is unchanged.
 
 ---