framework-context

# Framework Context ## Overview Provide a consistent, source-anchored model of this framework so agents can reason about system-level behavior without guessing. ## When to Use - System-level reflection or metacognitive assessment - Planning tasks that depend on routing/memory/workflow architecture - Capability-gap analysis before recommending ecosystem evolution ## Iron Laws 1. **ALWAYS** load framework context before any system-level reflection, planning, or capability-gap analysis — reasoning about architecture without grounding produces hallucinated paths and phantom agents. 2. **NEVER** fabricate file paths or agent names that are not confirmed by reading canonical sources — invented paths break downstream agents that try to use them. 3. **ALWAYS** scope the context load to only what the consuming task needs (`memory`, `agents`, `workflows`, `hooks`, or `all`) — loading all sources for a narrow task wastes tokens and buries relevant signals. 4. **NEVER** write or modify framework files from within this skill — framework-context is read-only; mutations require the appropriate creator/updater skill. 5. **ALWAYS** report missing sources explicitly as `missing source: <path>` rather than silently omitting a section — silent omissions cause downstream agents to make decisions on incomplete context. ## Anti-Patterns | Anti-Pattern | Why It Fails | Correct Approach | | ------------------------------------------------- | ---------------------------------------------------------------- | -------------------------------------------------------------------------- | | Skipping context load before reflection | Reflection uses stale or hallucinated routing/memory assumptions | Always invoke framework-context first; never reflect from memory alone | | Loading full `all` scope for a narrow task | Token budget consumed by irrelevant sections; key signal buried | Pass `--scope memory` or `--scope agents` to limit output to what's needed | | Inferring file paths from naming conventions | Paths change; inferred paths break agent pipelines | Always read canonical sources and report actual paths found | | Writing to framework files inside this skill | Bypasses creator workflow and post-creation integration steps | Use appropriate creator/updater skill for any write operations | | Silently omitting sections when source is missing | Consumer assumes context is complete; makes decisions on gaps | Report `missing source: <path>` explicitly for every unresolvable section | <identity> Framework grounding skill for memory architecture, routing, workflows, hooks, and directory layout. </identity> <capabilities> - Produce scoped context summaries (`memory`, `agents`, `workflows`, `hooks`, `all`) - Anchor every section to concrete repository paths - Standardize framework context output for reflection/planning consumers </capabilities> <instructions> <execution_process> ### Step 0: Resolve Scope - Accept `scope` argument: `memory | agents | workflows | hooks | all` - Default to `all` ### Step 1: Load Canonical Sources Read only what is required by scope: - Memory: `.claude/docs/MEMORY_SYSTEM.md` - Agent registry/routing: `.claude/context/agent-registry.json`, `.claude/lib/routing/routing-table.cjs` - Reflection flow hooks: `.claude/hooks/reflection/reflection-queue-processor.cjs`, `.claude/hooks/reflection/reflection-step0-guard.cjs` - Workflow catalog: `.claude/docs/@ENTERPRISE_WORKFLOWS.md` - Global framework references: `.claude/CLAUDE.md` ### Step 2: Emit Structured Context Output sections in this exact order: 1. **Memory System** 2. **Agents and Routing** 3. **Workflows** 4. **Hooks** 5. **Directory Layout** Each section must include: - 2-6 concise bullets - At least one concrete path reference - Behavior notes (what triggers what) ### Step 3: Scope Filter - If `scope != all`, return only relevant section(s) - Never fabricate unknown paths or flows - If a source is missing, state `missing source: <path>` ### Step 3: Output Return markdown only; do not write framework files from this skill. </execution_process> </instructions> <examples> <usage_example> **Example Invocations**: ```javascript // Full framework model Skill({ skill: 'framework-context' }); // Memory-only context for reflection prep Skill({ skill: 'framework-context', args: '--scope memory' }); // Workflow/hook-only context for integration analysis Skill({ skill: 'framework-context', args: '--scope workflows' }); ``` </usage_example> </examples> ## Memory Protocol (MANDATORY) **Before starting:** ```powershell Get-Content .claude/context/memory/learnings.md -TotalCount 120 ``` **After completing:** - New framework-context pattern -> `.claude/context/memory/learnings.md` - Broken/ambiguous framework mapping -> `.claude/context/memory/issues.md` - Architectural interpretation decision -> `.claude/context/memory/decisions.md` > ASSUME INTERRUPTION: Your context may reset. If it's not in memory, it didn't happen.