gkt-node 3.3.0

package/assets/.agent/skills/context-manager/scripts/minify.py

@@ -0,0 +1,82 @@
+#!/usr/bin/env python3
+"""
+Context Manager — Minify code for LLM Context.
+
+Usage:
+    python minify.py <file_path> [--remove-comments] [--remove-empty-lines]
+"""
+
+import argparse
+import re
+import sys
+from pathlib import Path
+
+def remove_comments_python(source):
+    # Remove single line comments
+    source = re.sub(r'#.*', '', source)
+    # Remove docstrings (simple approximation, not perfect)
+    # source = re.sub(r'""".*?"""', '', source, flags=re.DOTALL) 
+    # source = re.sub(r"'''.*?'''", '', source, flags=re.DOTALL)
+    # Docstring removal via regex is dangerous, skipping for safety
+    return source
+
+def remove_comments_js(source):
+    # Remove // comments
+    source = re.sub(r'//.*', '', source)
+    # Remove /* */ comments
+    source = re.sub(r'/\*.*?\*/', '', source, flags=re.DOTALL)
+    return source
+
+def minify_file(file_path, remove_comments=True, remove_empty=True):
+    path = Path(file_path)
+    if not path.exists():
+        print(f"Error: File {file_path} not found.")
+        sys.exit(1)
+
+    with open(path, 'r', encoding='utf-8') as f:
+        content = f.read()
+
+    original_len = len(content)
+
+    if remove_comments:
+        if path.suffix in ['.py']:
+            content = remove_comments_python(content)
+        elif path.suffix in ['.js', '.ts', '.jsx', '.tsx', '.css', '.java', '.c', '.cpp']:
+            content = remove_comments_js(content)
+    
+    lines = content.split('\n')
+    cleaned_lines = []
+    for line in lines:
+        stripped = line.strip()
+        if remove_empty and not stripped:
+            continue
+        # Preserve indentation but maybe reduce it? For now, keep indentation logic simple
+        # Just creating a "dense" version
+        cleaned_lines.append(line) # Keep indentation for readability/python correctness
+
+    final_content = "\n".join(cleaned_lines)
+    
+    # Remove multi-line empty blocks again just in case
+    if remove_empty:
+        final_content = re.sub(r'\n\s*\n', '\n', final_content)
+
+    new_len = len(final_content)
+    saved = original_len - new_len
+    percent = (saved / original_len) * 100 if original_len > 0 else 0
+
+    print(f"📉 Minified {path.name}: {original_len} -> {new_len} chars (Saved {percent:.1f}%)")
+    print("-" * 40)
+    print(final_content)
+    print("-" * 40)
+
+def main():
+    parser = argparse.ArgumentParser(description="Minify code for LLM context")
+    parser.add_argument("file", help="File to minify")
+    parser.add_argument("--no-comments", action="store_false", dest="remove_comments", help="Keep comments")
+    parser.add_argument("--no-empty", action="store_false", dest="remove_empty", help="Keep empty lines")
+    
+    args = parser.parse_args()
+    minify_file(args.file, args.remove_comments, args.remove_empty)
+
+if __name__ == "__main__":
+    main()

package/assets/.agent/skills/context-optimization/SKILL.md

@@ -0,0 +1,186 @@
+---
+name: context-optimization
+description: "Apply compaction, masking, and caching strategies"
+source: "https://github.com/muratcankoylan/Agent-Skills-for-Context-Engineering/tree/main/skills/context-optimization"
+risk: safe
+---
+
+## When to Use This Skill
+
+Apply compaction, masking, and caching strategies
+
+Use this skill when working with apply compaction, masking, and caching strategies.
+# Context Optimization Techniques
+
+Context optimization extends the effective capacity of limited context windows through strategic compression, masking, caching, and partitioning. The goal is not to magically increase context windows but to make better use of available capacity. Effective optimization can double or triple effective context capacity without requiring larger models or longer contexts.
+
+## When to Activate
+
+Activate this skill when:
+- Context limits constrain task complexity
+- Optimizing for cost reduction (fewer tokens = lower costs)
+- Reducing latency for long conversations
+- Implementing long-running agent systems
+- Needing to handle larger documents or conversations
+- Building production systems at scale
+
+## Core Concepts
+
+Context optimization extends effective capacity through four primary strategies: compaction (summarizing context near limits), observation masking (replacing verbose outputs with references), KV-cache optimization (reusing cached computations), and context partitioning (splitting work across isolated contexts).
+
+The key insight is that context quality matters more than quantity. Optimization preserves signal while reducing noise. The art lies in selecting what to keep versus what to discard, and when to apply each technique.
+
+## Detailed Topics
+
+### Compaction Strategies
+
+**What is Compaction**
+Compaction is the practice of summarizing context contents when approaching limits, then reinitializing a new context window with the summary. This distills the contents of a context window in a high-fidelity manner, enabling the agent to continue with minimal performance degradation.
+
+Compaction typically serves as the first lever in context optimization. The art lies in selecting what to keep versus what to discard.
+
+**Compaction Implementation**
+Compaction works by identifying sections that can be compressed, generating summaries that capture essential points, and replacing full content with summaries. Priority for compression goes to tool outputs (replace with summaries), old turns (summarize early conversation), retrieved docs (summarize if recent versions exist), and never compress system prompt.
+
+**Summary Generation**
+Effective summaries preserve different elements depending on message type:
+
+Tool outputs: Preserve key findings, metrics, and conclusions. Remove verbose raw output.
+
+Conversational turns: Preserve key decisions, commitments, and context shifts. Remove filler and back-and-forth.
+
+Retrieved documents: Preserve key facts and claims. Remove supporting evidence and elaboration.
+
+### Observation Masking
+
+**The Observation Problem**
+Tool outputs can comprise 80%+ of token usage in agent trajectories. Much of this is verbose output that has already served its purpose. Once an agent has used a tool output to make a decision, keeping the full output provides diminishing value while consuming significant context.
+
+Observation masking replaces verbose tool outputs with compact references. The information remains accessible if needed but does not consume context continuously.
+
+**Masking Strategy Selection**
+Not all observations should be masked equally:
+
+Never mask: Observations critical to current task, observations from the most recent turn, observations used in active reasoning.
+
+Consider masking: Observations from 3+ turns ago, verbose outputs with key points extractable, observations whose purpose has been served.
+
+Always mask: Repeated outputs, boilerplate headers/footers, outputs already summarized in conversation.
+
+### KV-Cache Optimization
+
+**Understanding KV-Cache**
+The KV-cache stores Key and Value tensors computed during inference, growing linearly with sequence length. Caching the KV-cache across requests sharing identical prefixes avoids recomputation.
+
+Prefix caching reuses KV blocks across requests with identical prefixes using hash-based block matching. This dramatically reduces cost and latency for requests with common prefixes like system prompts.
+
+**Cache Optimization Patterns**
+Optimize for caching by reordering context elements to maximize cache hits. Place stable elements first (system prompt, tool definitions), then frequently reused elements, then unique elements last.
+
+Design prompts to maximize cache stability: avoid dynamic content like timestamps, use consistent formatting, keep structure stable across sessions.
+
+### Context Partitioning
+
+**Sub-Agent Partitioning**
+The most aggressive form of context optimization is partitioning work across sub-agents with isolated contexts. Each sub-agent operates in a clean context focused on its subtask without carrying accumulated context from other subtasks.
+
+This approach achieves separation of concerns—the detailed search context remains isolated within sub-agents while the coordinator focuses on synthesis and analysis.
+
+**Result Aggregation**
+Aggregate results from partitioned subtasks by validating all partitions completed, merging compatible results, and summarizing if still too large.
+
+### Budget Management
+
+**Context Budget Allocation**
+Design explicit context budgets. Allocate tokens to categories: system prompt, tool definitions, retrieved docs, message history, and reserved buffer. Monitor usage against budget and trigger optimization when approaching limits.
+
+**Trigger-Based Optimization**
+Monitor signals for optimization triggers: token utilization above 80%, degradation indicators, and performance drops. Apply appropriate optimization techniques based on context composition.
+
+## Practical Guidance
+
+### Optimization Decision Framework
+
+When to optimize:
+- Context utilization exceeds 70%
+- Response quality degrades as conversations extend
+- Costs increase due to long contexts
+- Latency increases with conversation length
+
+What to apply:
+- Tool outputs dominate: observation masking
+- Retrieved documents dominate: summarization or partitioning
+- Message history dominates: compaction with summarization
+- Multiple components: combine strategies
+
+### Performance Considerations
+
+Compaction should achieve 50-70% token reduction with less than 5% quality degradation. Masking should achieve 60-80% reduction in masked observations. Cache optimization should achieve 70%+ hit rate for stable workloads.
+
+Monitor and iterate on optimization strategies based on measured effectiveness.
+
+## Examples
+
+**Example 1: Compaction Trigger**
+```python
+if context_tokens / context_limit > 0.8:
+    context = compact_context(context)
+```
+
+**Example 2: Observation Masking**
+```python
+if len(observation) > max_length:
+    ref_id = store_observation(observation)
+    return f"[Obs:{ref_id} elided. Key: {extract_key(observation)}]"
+```
+
+**Example 3: Cache-Friendly Ordering**
+```python
+# Stable content first
+context = [system_prompt, tool_definitions]  # Cacheable
+context += [reused_templates]  # Reusable
+context += [unique_content]  # Unique
+```
+
+## Guidelines
+
+1. Measure before optimizing—know your current state
+2. Apply compaction before masking when possible
+3. Design for cache stability with consistent prompts
+4. Partition before context becomes problematic
+5. Monitor optimization effectiveness over time
+6. Balance token savings against quality preservation
+7. Test optimization at production scale
+8. Implement graceful degradation for edge cases
+
+## Integration
+
+This skill builds on context-fundamentals and context-degradation. It connects to:
+
+- multi-agent-patterns - Partitioning as isolation
+- evaluation - Measuring optimization effectiveness
+- memory-systems - Offloading context to memory
+
+## References
+
+Internal reference:
+- [Optimization Techniques Reference](./references/optimization_techniques.md) - Detailed technical reference
+
+Related skills in this collection:
+- context-fundamentals - Context basics
+- context-degradation - Understanding when to optimize
+- evaluation - Measuring optimization
+
+External resources:
+- Research on context window limitations
+- KV-cache optimization techniques
+- Production engineering guides
+
+---
+
+## Skill Metadata
+
+**Created**: 2025-12-20
+**Last Updated**: 2025-12-20
+**Author**: Agent Skills for Context Engineering Contributors
+**Version**: 1.0.0

package/assets/.agent/skills/context-router/SKILL.md

@@ -0,0 +1,42 @@
+---
+name: context-router
+description: Universal query router for all skills' data. Retrieves only relevant data to save tokens.
+---
+
+# Context Router — Smart Context Protocol
+
+## Purpose
+Instead of reading entire data files (hundreds of lines), agents call the Context Router to retrieve **only the specific data they need**. This dramatically reduces token consumption.
+
+## Usage
+
+```bash
+# Search across ALL skill data files for a keyword:
+python .agent/skills/context-router/scripts/context_router.py --query "fintech"
+
+# Search within a specific skill's data:
+python .agent/skills/context-router/scripts/context_router.py --skill meta-thinker --query "SCAMPER"
+
+# List all available data sources:
+python .agent/skills/context-router/scripts/context_router.py --list
+
+# Get a specific item by ID from a skill:
+python .agent/skills/context-router/scripts/context_router.py --skill meta-thinker --source industry_database --id fintech
+```
+
+## How It Works
+1. **Agent has a question** → calls Context Router with a query.
+2. **Context Router scans** the relevant data files (JSON) using keyword matching.
+3. **Returns only matching entries** — not the entire file.
+4. **Agent gets focused context** → better answers, fewer tokens.
+
+## Supported Data Sources
+The router automatically discovers all `.json` files under `.agent/skills/*/data/`.
+
+## When to Use
+- **Always** before reading a raw data file directly.
+- When you need specific information from a skill (e.g., "what monetization models fit SaaS?").
+- When Leader needs to gather context for a specific domain before delegating.
+
+## Integration
+All agents should prefer `context_router.py --query "..."` over reading raw JSON files.

package/assets/.agent/skills/context-router/scripts/context_router.py

@@ -0,0 +1,185 @@
+#!/usr/bin/env python3
+"""
+Context Router — Universal data query router for all skills.
+
+Searches across skill data files and returns only matching entries,
+dramatically reducing token consumption.
+
+Usage:
+    python context_router.py --query "fintech"
+    python context_router.py --skill meta-thinker --query "SCAMPER"
+    python context_router.py --skill meta-thinker --source industry_database --id fintech
+    python context_router.py --list
+"""
+
+import argparse
+import json
+import os
+import sys
+
+SKILLS_DIR = os.path.join(os.path.dirname(__file__), "..", "..", "..")
+
+
+def discover_data_sources(skills_dir):
+    """Find all JSON data files across all skills."""
+    sources = {}
+    skills_path = os.path.join(skills_dir, "skills")
+    if not os.path.isdir(skills_path):
+        return sources
+
+    for skill_name in sorted(os.listdir(skills_path)):
+        data_dir = os.path.join(skills_path, skill_name, "data")
+        if not os.path.isdir(data_dir):
+            continue
+        for fname in sorted(os.listdir(data_dir)):
+            if fname.endswith(".json"):
+                source_name = fname.replace(".json", "")
+                key = f"{skill_name}/{source_name}"
+                sources[key] = os.path.join(data_dir, fname)
+    return sources
+
+
+def load_json(filepath):
+    """Load a JSON file safely."""
+    try:
+        with open(filepath, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except (json.JSONDecodeError, FileNotFoundError):
+        return None
+
+
+def search_in_value(value, query):
+    """Recursively check if query appears in a JSON value."""
+    query_lower = query.lower()
+    if isinstance(value, str):
+        return query_lower in value.lower()
+    elif isinstance(value, list):
+        return any(search_in_value(item, query) for item in value)
+    elif isinstance(value, dict):
+        return any(search_in_value(v, query) for v in value.values())
+    return False
+
+
+def search_data(data, query):
+    """Search within a JSON data structure and return matching entries."""
+    results = []
+
+    if isinstance(data, list):
+        for item in data:
+            if search_in_value(item, query):
+                results.append(item)
+    elif isinstance(data, dict):
+        for key, value in data.items():
+            if search_in_value(key, query) or search_in_value(value, query):
+                results.append({key: value})
+    return results
+
+
+def get_by_id(data, item_id):
+    """Get a specific item by its 'id' field."""
+    if isinstance(data, list):
+        for item in data:
+            if isinstance(item, dict) and item.get("id") == item_id:
+                return item
+    elif isinstance(data, dict):
+        if item_id in data:
+            return {item_id: data[item_id]}
+    return None
+
+
+def list_sources(sources):
+    """Print all available data sources."""
+    print("📂 Available Data Sources:")
+    print(f"{'Source':<45} {'File'}")
+    print("-" * 80)
+    current_skill = ""
+    for key, path in sorted(sources.items()):
+        skill = key.split("/")[0]
+        if skill != current_skill:
+            current_skill = skill
+            print(f"\n  [{skill}]")
+        source = key.split("/")[1]
+        size = os.path.getsize(path)
+        print(f"    {source:<40} ({size:,} bytes)")
+    print(f"\nTotal: {len(sources)} data sources")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Smart Context Router — Query skill data efficiently")
+    parser.add_argument("--query", "-q", help="Search query (keyword)")
+    parser.add_argument("--skill", "-s", help="Filter by skill name")
+    parser.add_argument("--source", help="Specific data source name (without .json)")
+    parser.add_argument("--id", help="Get specific item by ID")
+    parser.add_argument("--list", "-l", action="store_true", help="List all data sources")
+    parser.add_argument("--max-results", type=int, default=5, help="Max results per source (default: 5)")
+    parser.add_argument("--compact", action="store_true", help="Compact JSON output (no indentation)")
+
+    args = parser.parse_args()
+
+    # Resolve skills directory
+    agent_dir = SKILLS_DIR
+    if not os.path.isdir(os.path.join(agent_dir, "skills")):
+        # Try from .agent directory
+        agent_dir = os.path.join(os.getcwd(), ".agent")
+        if not os.path.isdir(os.path.join(agent_dir, "skills")):
+            print("Error: Cannot find .agent/skills/ directory.", file=sys.stderr)
+            sys.exit(1)
+
+    sources = discover_data_sources(agent_dir)
+
+    if args.list:
+        list_sources(sources)
+        return
+
+    if not args.query and not args.id:
+        parser.print_help()
+        return
+
+    # Filter sources
+    filtered = {}
+    for key, path in sources.items():
+        skill_name = key.split("/")[0]
+        source_name = key.split("/")[1]
+        if args.skill and skill_name != args.skill:
+            continue
+        if args.source and source_name != args.source:
+            continue
+        filtered[key] = path
+
+    if not filtered:
+        print(f"No data sources found matching filters.", file=sys.stderr)
+        sys.exit(1)
+
+    # Search or get by ID
+    indent = None if args.compact else 2
+    total_results = 0
+
+    for key, path in sorted(filtered.items()):
+        data = load_json(path)
+        if data is None:
+            continue
+
+        if args.id:
+            result = get_by_id(data, args.id)
+            if result:
+                print(f"\n🎯 [{key}] ID: {args.id}")
+                print(json.dumps(result, indent=indent, ensure_ascii=False))
+                total_results += 1
+        elif args.query:
+            results = search_data(data, args.query)
+            if results:
+                shown = results[:args.max_results]
+                print(f"\n🔍 [{key}] {len(results)} match(es)" +
+                      (f" (showing top {args.max_results})" if len(results) > args.max_results else ""))
+                print(json.dumps(shown, indent=indent, ensure_ascii=False))
+                total_results += len(results)
+
+    if total_results == 0:
+        target = args.id or args.query
+        print(f"No results found for: '{target}'")
+    else:
+        print(f"\n📊 Total: {total_results} result(s)")
+
+
+if __name__ == "__main__":
+    main()

package/assets/.agent/skills/context-window-management/SKILL.md

@@ -0,0 +1,53 @@
+---
+name: context-window-management
+description: "Strategies for managing LLM context windows including summarization, trimming, routing, and avoiding context rot Use when: context window, token limit, context management, context engineering, long context."
+source: vibeship-spawner-skills (Apache 2.0)
+---
+
+# Context Window Management
+
+You're a context engineering specialist who has optimized LLM applications handling
+millions of conversations. You've seen systems hit token limits, suffer context rot,
+and lose critical information mid-dialogue.
+
+You understand that context is a finite resource with diminishing returns. More tokens
+doesn't mean better results—the art is in curating the right information. You know
+the serial position effect, the lost-in-the-middle problem, and when to summarize
+versus when to retrieve.
+
+Your cor
+
+## Capabilities
+
+- context-engineering
+- context-summarization
+- context-trimming
+- context-routing
+- token-counting
+- context-prioritization
+
+## Patterns
+
+### Tiered Context Strategy
+
+Different strategies based on context size
+
+### Serial Position Optimization
+
+Place important content at start and end
+
+### Intelligent Summarization
+
+Summarize by importance, not just recency
+
+## Anti-Patterns
+
+### ❌ Naive Truncation
+
+### ❌ Ignoring Token Costs
+
+### ❌ One-Size-Fits-All
+
+## Related Skills
+
+Works well with: `rag-implementation`, `conversation-memory`, `prompt-caching`, `llm-npc-dialogue`

package/assets/.agent/skills/conversation-memory/SKILL.md

@@ -0,0 +1,61 @@
+---
+name: conversation-memory
+description: "Persistent memory systems for LLM conversations including short-term, long-term, and entity-based memory Use when: conversation memory, remember, memory persistence, long-term memory, chat history."
+source: vibeship-spawner-skills (Apache 2.0)
+---
+
+# Conversation Memory
+
+You're a memory systems specialist who has built AI assistants that remember
+users across months of interactions. You've implemented systems that know when
+to remember, when to forget, and how to surface relevant memories.
+
+You understand that memory is not just storage—it's about retrieval, relevance,
+and context. You've seen systems that remember everything (and overwhelm context)
+and systems that forget too much (frustrating users).
+
+Your core principles:
+1. Memory types differ—short-term, lo
+
+## Capabilities
+
+- short-term-memory
+- long-term-memory
+- entity-memory
+- memory-persistence
+- memory-retrieval
+- memory-consolidation
+
+## Patterns
+
+### Tiered Memory System
+
+Different memory tiers for different purposes
+
+### Entity Memory
+
+Store and update facts about entities
+
+### Memory-Aware Prompting
+
+Include relevant memories in prompts
+
+## Anti-Patterns
+
+### ❌ Remember Everything
+
+### ❌ No Memory Retrieval
+
+### ❌ Single Memory Store
+
+## ⚠️ Sharp Edges
+
+| Issue | Severity | Solution |
+|-------|----------|----------|
+| Memory store grows unbounded, system slows | high | // Implement memory lifecycle management |
+| Retrieved memories not relevant to current query | high | // Intelligent memory retrieval |
+| Memories from one user accessible to another | critical | // Strict user isolation in memory |
+
+## Related Skills
+
+Works well with: `context-window-management`, `rag-implementation`, `prompt-caching`, `llm-npc-dialogue`