| name | ctmv3-workspace-activator |
| description | CTMv3 workspace activation cognitive layer. Load when entering any unfamiliar codebase, when asked to encode or document a repo for agents, when doing cold or warm start work, when setting up .github/.claude/.codex/.sovereign directories, or when building ARCHITECTURE_MAP.md, AGENTS.md, TOPOLOGY.md, or PROVENANCE.md. Do NOT load for ordinary coding tasks in a repo that is already CTM-activated.
|
| disable-model-invocation | false |
CTMv3 Workspace Activation — Cognitive Layer
Claude Code installation. This file is the semantic router. Full sub-documents are at:
../../templates/BOOT_PROTOCOL.md../../templates/DOT_TOPOLOGY.md../../templates/TOPOLOGY.md (template)../../templates/ARCHITECTURE_MAP_TEMPLATE.md../../templates/FAILURE_GRAMMAR.md (template)../../templates/PROVENANCE.md (template)
At install time these paths resolve relative to this skill's directory. If the plugin is
installed via claude plugin install, the templates directory is at the plugin root.
Paradigm: CTM (Cognitive Topology Map), not SOP (Standard Operating Procedure)
Version: v3.0
Operator: Daeron
Philosophy: A skill is not a recipe. A codebase with a CTM skill package is executable
by any agent on cold entry — not explained to the agent, but alive in the agent's hands.
IDENTITY BLOCK
What CTMv3 knows that CTMv2 did not:
- How to detect cold vs. warm entry state via .xyz directory discovery
- How to produce ARCHITECTURE_MAP.md traversal artifacts (question-oriented navigation maps)
- How to encode .github/, .claude/, .codex/, .sovereign/ as topology signals
- How to read config file spine (pyproject.toml, go.mod, manifest.json) as architectural
evidence without executing them
- How to set up agent ecosystem hooks that enforce topology contracts at the OS level
- The session state machine:
if not run → full archaeology; if run → diff and continue
What this skill still knows (CTMv2 baseline):
- Expert cognition vs. checklist simulation
- CTM package anatomy (topology, failure grammar, entry vectors, provenance)
- Daeron's recursive production system and encoding codebases within it
- Python, Go, Ada topology patterns
- Failure grammar for adversarial/OSINT domains
- Adversarially-aware skill construction
What this skill explicitly does NOT know:
- Your specific codebase (read it, don't assume it)
- Which modules are currently production-stable (check manifest.json or ask)
- Current snapshot state (check SNAPSHOT.md or manifest.json if present)
- What Daeron has already decided is wrong (check PROVENANCE.md — if absent, that's data)
- Whether the agent ecosystem integration is already present (run boot check first)
SEMANTIC ROUTER — Load This Document, Not That One
Classify task type before loading any sub-document. Load only what the task requires.
TASK TYPE → LOAD ORDER
─────────────────────────────────────────────────────────────────────
[COLD_START_REPO] — entering a codebase with no prior CTM artifacts
→ BOOT_PROTOCOL.md (run discovery) → TOPOLOGY.md → DOT_TOPOLOGY.md
→ Phase 0 full archaeology → build all artifacts
→ run: python3 -m ctmv3 activate --json (or use ctmv3-architect subagent)
[WARM_START_REPO] — resuming a session in a CTM-encoded codebase
→ BOOT_PROTOCOL.md (run warm check) → PROVENANCE.md (check lineage + session log)
→ diff current state → continue from last logged action
→ run: python3 -m ctmv3 warm --json
[BUILD_ARCHITECTURE_MAP] — producing the traversal-map artifact for a codebase
→ ARCHITECTURE_MAP_TEMPLATE.md → TOPOLOGY.md → build ARCHITECTURE_MAP.md
→ run: python3 -m ctmv3 architecture-map --json
[NEW_SKILL from scratch]
→ TOPOLOGY.md (anatomy) → build
[ENCODE existing codebase]
→ BOOT_PROTOCOL.md → TOPOLOGY.md
→ run: python3 -m ctmv3 activate --json (or use ctmv3-architect subagent)
[INTEGRATE_AGENT_ECOSYSTEM] — setting up .github/, .claude/, .codex/, .sovereign/
→ DOT_TOPOLOGY.md → BOOT_PROTOCOL.md → build ecosystem artifacts
→ run: python3 -m ctmv3 dot-init --json
[OSINT / RE / adversarial domain]
→ TOPOLOGY.md → FAILURE_GRAMMAR.md → build
[UPGRADE existing skill]
→ Read existing SKILL.md → TOPOLOGY.md → diff against CTMv3 standard → upgrade
[AGENTS.md / CLAUDE.md / constitution build]
→ TOPOLOGY.md → AGENTS_ADDENDUM.md → wrap existing agent posture
[FAILURE / something smells wrong]
→ FAILURE_GRAMMAR.md immediately, before any other action
[SESSION START in encoded repo]
→ BOOT_PROTOCOL.md → warm check → if stale: PROVENANCE.md → TOPOLOGY.md
→ session start hook runs boot automatically; use /ctmv3:status to inspect
Hard rule: Never load all sub-documents upfront. Load conditionally.
BOOT_PROTOCOL.md is mandatory for any repo entry task. It determines the branch.
FAILURE_GRAMMAR.md loads when something smells wrong — not as a precaution but as a response.
PHASE PROTOCOLS
PRE-PHASE: Boot State Check (ALWAYS before any other phase for repo tasks)
Load BOOT_PROTOCOL.md and run the discovery sequence before Phase 0.
run python3 -m ctmv3 boot --json (the session start hook does this automatically).
The boot check answers: is this a cold entry or a warm entry?
- Cold entry → full Phase 0-5 archaeology + artifact construction
- Warm entry → PROVENANCE.md diff + continuation from last session
PHASE 0: Domain Archaeology (Always First for Cold Entry)
Before writing a single line of skill, excavate the domain.
Questions that are NOT optional:
- Load-bearing concepts — What are the 3-7 concepts everything else depends on?
- Interface boundaries — Where does this domain end?
- Complexity topology — Where does hard complexity actually concentrate?
- Baked-in decisions — What architectural choices were made upstream?
- Snapshot lineage — What snapshot is this domain at?
- Hardware reality check — Daeron's primary: Ryzen 5 2400G / 12GB RAM, no GPU.
- Config file spine — What does the .xyz directory landscape look like?
PHASE 1: Topology Construction
Build TOPOLOGY.md. Mandatory sections:
- Load-Bearing Concepts
- Interface Map
- Complexity Distribution (Mermaid mandatory for 4+ nodes)
- Dependency Graph (Mermaid mandatory)
- Baked-In Decisions
- Anti-Concepts
- Config File Spine
PHASE 2: Failure Grammar Construction
Build FAILURE_GRAMMAR.md. Taxonomy of what wrong looks like before you can prove it.
Mandatory: pre-failure signatures, false success patterns.
Adversarial domains: adversarial inputs also mandatory.
PHASE 3: Entry Vector Analysis
Encode the semantic router in the new skill. Table of task type → entry point → first doc.
PHASE 4: Provenance Chain
Build PROVENANCE.md:
- Snapshot Lineage
- Architectural Decisions (Chronological)
- Rejected Alternatives (Graveyard)
- Open Questions
- Integration History
- Session Log
PHASE 5: Ecosystem Artifact Construction
Build in order (order is load-bearing — do not invert):
- ARCHITECTURE_MAP.md
- .sovereign/ (after topology artifacts exist)
- AGENTS.md
- CLAUDE.md + .claude/settings.json
- .github/copilot-instructions.md
- .github/instructions/ per-path files (DENSE nodes only)
- .github/workflows/ enforcement gates
- PROVENANCE.md Session Log update
OUTPUT CONTRACT
Eight outputs. All required. Package is incomplete if any are missing.
- Agent can answer without asking: What are the 3 things I cannot get wrong?
- Agent can recognize failure before it's provable: What does wrong smell like?
- Agent knows what was already rejected: What won't I waste time re-discovering?
- Agent knows where complexity concentrates: Where do I slow down?
- Agent knows its entry vector: Based on my task type, where do I enter?
- Agent knows the boot state: Cold entry or warm entry? Determined in < 60 seconds.
- Agent has a traversal map: ARCHITECTURE_MAP.md answers "where is X" without a guide.
- Codebase enforces itself: .github/, .sovereign/, AGENTS.md create structural enforcement.
ANTI-PATTERNS
- Step-by-step workflows (AGENTS.md quick reference handles that)
- Generic best practices (encode Daeron's actual decisions)
- Flat single-file skills for complex domains
- Skills that assume happy path (failure grammar mandatory)
- Ecosystem setup that requires operator intervention to activate
- ARCHITECTURE_MAP that summarizes instead of navigates
- .sovereign/ initialized before topology artifacts exist
REFERENCE FILES
| File | Load When |
|---|
| BOOT_PROTOCOL.md | Any repo entry task — always |
| DOT_TOPOLOGY.md | Building ecosystem artifacts, .xyz directory work |
| ARCHITECTURE_MAP_TEMPLATE.md | Building traversal maps |
| TOPOLOGY.md (template) | Building or entering any domain |
| FAILURE_GRAMMAR.md (template) | Something smells wrong, or adversarial domain |
| PROVENANCE.md (template) | Session start, lineage checks, snapshot work |
