kodelyth-ecc 2.17.0 → 2.19.0

package/.kimi/skills/lead-intelligence/agents/outreach-drafter.md

@@ -0,0 +1,98 @@
+---
+name: outreach-drafter
+description: Generates personalized outreach messages for qualified leads. Creates warm intro requests, cold emails, X DMs, and follow-up sequences using enriched profile data.
+tools:
+  - Read
+  - Grep
+model: sonnet
+---
+
+# Outreach Drafter Agent
+
+You generate personalized outreach messages using enriched lead data.
+
+## Task
+
+Given enriched prospect profiles and warm path data, draft outreach messages that are short, specific, and actionable.
+
+## Message Types
+
+### 1. Warm Intro Request (to mutual)
+
+Template structure:
+- Greeting (first name, casual)
+- The ask (1 sentence — can you intro me to [target])
+- Why it's relevant (1 sentence — what you're building and why target cares)
+- Offer to send forwardable blurb
+- Sign off
+
+Max length: 60 words.
+
+### 2. Cold Email (to target directly)
+
+Template structure:
+- Subject: specific, under 8 words
+- Opener: reference something specific about them (recent post, announcement, thesis)
+- Pitch: what you do and why they specifically should care (2 sentences max)
+- Ask: one concrete low-friction next step
+- Sign off with one credibility anchor
+
+Max length: 80 words.
+
+### 3. X DM (to target)
+
+Even shorter than email. 2-3 sentences max.
+- Reference a specific post or take of theirs
+- One line on why you're reaching out
+- Clear ask
+
+Max length: 40 words.
+
+### 4. Follow-Up Sequence
+
+- Day 4-5: short follow-up with one new data point
+- Day 10-12: final follow-up with a clean close
+- No more than 3 total touches unless user specifies otherwise
+
+## Writing Rules
+
+1. **Personalize or don't send.** Every message must reference something specific to the recipient.
+2. **Short sentences.** No compound sentences with multiple clauses.
+3. **Lowercase casual.** Match modern professional communication style.
+4. **No AI slop.** Never use: "game-changer", "deep dive", "the key insight", "leverage", "synergy", "at the forefront of".
+5. **Data over adjectives.** Use specific numbers, names, and facts instead of generic praise.
+6. **One ask per message.** Never combine multiple requests.
+7. **No fake familiarity.** Don't say "loved your talk" unless you can cite which talk.
+
+## Personalization Sources (from enrichment data)
+
+Use these hooks in order of preference:
+1. Their recent post or take you genuinely agree with
+2. A mutual connection who can vouch
+3. Their company's recent milestone (funding, launch, hire)
+4. A specific piece of their thesis or writing
+5. Shared event attendance or community membership
+
+## Output Format
+
+```
+TO: [name] ([email or @handle])
+VIA: [direct / warm intro through @mutual]
+TYPE: [cold email / DM / intro request]
+
+Subject: [if email]
+
+[message body]
+
+---
+Personalization notes:
+- Referenced: [what specific thing was used]
+- Warm path: [how connected]
+- Confidence: [high/medium/low]
+```
+
+## Constraints
+
+- Never generate messages that could be mistaken for spam.
+- Never include false claims about the user's product or traction.
+- If enrichment data is thin, flag the message as "needs manual personalization" rather than faking specifics.

package/.kimi/skills/lead-intelligence/agents/signal-scorer.md

@@ -0,0 +1,60 @@
+---
+name: signal-scorer
+description: Searches and ranks prospects by relevance signals across X, Exa, and LinkedIn. Assigns weighted scores based on role, industry, activity, influence, and location.
+tools:
+  - Bash
+  - Read
+  - Grep
+  - Glob
+  - WebSearch
+  - WebFetch
+model: sonnet
+---
+
+# Signal Scorer Agent
+
+You are a lead intelligence agent that finds and scores high-value prospects.
+
+## Task
+
+Given target verticals, roles, and locations from the user, search for the highest-signal people using available tools.
+
+## Scoring Rubric
+
+| Signal | Weight | How to Assess |
+|--------|--------|---------------|
+| Role/title alignment | 30% | Is this person a decision maker in the target space? |
+| Industry match | 25% | Does their company/work directly relate to target vertical? |
+| Recent activity | 20% | Have they posted, published, or spoken about the topic recently? |
+| Influence | 10% | Follower count, publication reach, speaking engagements |
+| Location proximity | 10% | Same city/timezone as the user? |
+| Engagement overlap | 5% | Have they interacted with the user's content or network? |
+
+## Search Strategy
+
+1. Use Exa web search with category filters for company and person discovery
+2. Use X API search for active voices in the target verticals
+3. Cross-reference to deduplicate and merge profiles
+4. Score each prospect on the 0-100 scale using the rubric above
+5. Return the top N prospects sorted by score
+
+## Output Format
+
+Return a structured list:
+
+```
+PROSPECT #1 (Score: 94)
+  Name: [full name]
+  Handle: @[x_handle]
+  Role: [current title] @ [company]
+  Location: [city]
+  Industry: [vertical match]
+  Recent Signal: [what they posted/did recently that's relevant]
+  Score Breakdown: role=28/30, industry=24/25, activity=20/20, influence=8/10, location=10/10, engagement=4/5
+```
+
+## Constraints
+
+- Do not fabricate profile data. Only report what you can verify from search results.
+- If a person appears in multiple sources, merge into one entry.
+- Flag low-confidence scores where data is sparse.

package/.kimi/skills/liquid-glass-design/SKILL.md

@@ -0,0 +1,279 @@
+---
+name: liquid-glass-design
+description: iOS 26 Liquid Glass design system — dynamic glass material with blur, reflection, and interactive morphing for SwiftUI, UIKit, and WidgetKit.
+---
+
+# Liquid Glass Design System (iOS 26)
+
+Patterns for implementing Apple's Liquid Glass — a dynamic material that blurs content behind it, reflects color and light from surrounding content, and reacts to touch and pointer interactions. Covers SwiftUI, UIKit, and WidgetKit integration.
+
+## When to Activate
+
+- Building or updating apps for iOS 26+ with the new design language
+- Implementing glass-style buttons, cards, toolbars, or containers
+- Creating morphing transitions between glass elements
+- Applying Liquid Glass effects to widgets
+- Migrating existing blur/material effects to the new Liquid Glass API
+
+## Core Pattern — SwiftUI
+
+### Basic Glass Effect
+
+The simplest way to add Liquid Glass to any view:
+
+```swift
+Text("Hello, World!")
+    .font(.title)
+    .padding()
+    .glassEffect()  // Default: regular variant, capsule shape
+```
+
+### Customizing Shape and Tint
+
+```swift
+Text("Hello, World!")
+    .font(.title)
+    .padding()
+    .glassEffect(.regular.tint(.orange).interactive(), in: .rect(cornerRadius: 16.0))
+```
+
+Key customization options:
+- `.regular` — standard glass effect
+- `.tint(Color)` — add color tint for prominence
+- `.interactive()` — react to touch and pointer interactions
+- Shape: `.capsule` (default), `.rect(cornerRadius:)`, `.circle`
+
+### Glass Button Styles
+
+```swift
+Button("Click Me") { /* action */ }
+    .buttonStyle(.glass)
+
+Button("Important") { /* action */ }
+    .buttonStyle(.glassProminent)
+```
+
+### GlassEffectContainer for Multiple Elements
+
+Always wrap multiple glass views in a container for performance and morphing:
+
+```swift
+GlassEffectContainer(spacing: 40.0) {
+    HStack(spacing: 40.0) {
+        Image(systemName: "scribble.variable")
+            .frame(width: 80.0, height: 80.0)
+            .font(.system(size: 36))
+            .glassEffect()
+
+        Image(systemName: "eraser.fill")
+            .frame(width: 80.0, height: 80.0)
+            .font(.system(size: 36))
+            .glassEffect()
+    }
+}
+```
+
+The `spacing` parameter controls merge distance — closer elements blend their glass shapes together.
+
+### Uniting Glass Effects
+
+Combine multiple views into a single glass shape with `glassEffectUnion`:
+
+```swift
+@Namespace private var namespace
+
+GlassEffectContainer(spacing: 20.0) {
+    HStack(spacing: 20.0) {
+        ForEach(symbolSet.indices, id: \.self) { item in
+            Image(systemName: symbolSet[item])
+                .frame(width: 80.0, height: 80.0)
+                .glassEffect()
+                .glassEffectUnion(id: item < 2 ? "group1" : "group2", namespace: namespace)
+        }
+    }
+}
+```
+
+### Morphing Transitions
+
+Create smooth morphing when glass elements appear/disappear:
+
+```swift
+@State private var isExpanded = false
+@Namespace private var namespace
+
+GlassEffectContainer(spacing: 40.0) {
+    HStack(spacing: 40.0) {
+        Image(systemName: "scribble.variable")
+            .frame(width: 80.0, height: 80.0)
+            .glassEffect()
+            .glassEffectID("pencil", in: namespace)
+
+        if isExpanded {
+            Image(systemName: "eraser.fill")
+                .frame(width: 80.0, height: 80.0)
+                .glassEffect()
+                .glassEffectID("eraser", in: namespace)
+        }
+    }
+}
+
+Button("Toggle") {
+    withAnimation { isExpanded.toggle() }
+}
+.buttonStyle(.glass)
+```
+
+### Extending Horizontal Scrolling Under Sidebar
+
+To allow horizontal scroll content to extend under a sidebar or inspector, ensure the `ScrollView` content reaches the leading/trailing edges of the container. The system automatically handles the under-sidebar scrolling behavior when the layout extends to the edges — no additional modifier is needed.
+
+## Core Pattern — UIKit
+
+### Basic UIGlassEffect
+
+```swift
+let glassEffect = UIGlassEffect()
+glassEffect.tintColor = UIColor.systemBlue.withAlphaComponent(0.3)
+glassEffect.isInteractive = true
+
+let visualEffectView = UIVisualEffectView(effect: glassEffect)
+visualEffectView.translatesAutoresizingMaskIntoConstraints = false
+visualEffectView.layer.cornerRadius = 20
+visualEffectView.clipsToBounds = true
+
+view.addSubview(visualEffectView)
+NSLayoutConstraint.activate([
+    visualEffectView.centerXAnchor.constraint(equalTo: view.centerXAnchor),
+    visualEffectView.centerYAnchor.constraint(equalTo: view.centerYAnchor),
+    visualEffectView.widthAnchor.constraint(equalToConstant: 200),
+    visualEffectView.heightAnchor.constraint(equalToConstant: 120)
+])
+
+// Add content to contentView
+let label = UILabel()
+label.text = "Liquid Glass"
+label.translatesAutoresizingMaskIntoConstraints = false
+visualEffectView.contentView.addSubview(label)
+NSLayoutConstraint.activate([
+    label.centerXAnchor.constraint(equalTo: visualEffectView.contentView.centerXAnchor),
+    label.centerYAnchor.constraint(equalTo: visualEffectView.contentView.centerYAnchor)
+])
+```
+
+### UIGlassContainerEffect for Multiple Elements
+
+```swift
+let containerEffect = UIGlassContainerEffect()
+containerEffect.spacing = 40.0
+
+let containerView = UIVisualEffectView(effect: containerEffect)
+
+let firstGlass = UIVisualEffectView(effect: UIGlassEffect())
+let secondGlass = UIVisualEffectView(effect: UIGlassEffect())
+
+containerView.contentView.addSubview(firstGlass)
+containerView.contentView.addSubview(secondGlass)
+```
+
+### Scroll Edge Effects
+
+```swift
+scrollView.topEdgeEffect.style = .automatic
+scrollView.bottomEdgeEffect.style = .hard
+scrollView.leftEdgeEffect.isHidden = true
+```
+
+### Toolbar Glass Integration
+
+```swift
+let favoriteButton = UIBarButtonItem(image: UIImage(systemName: "heart"), style: .plain, target: self, action: #selector(favoriteAction))
+favoriteButton.hidesSharedBackground = true  // Opt out of shared glass background
+```
+
+## Core Pattern — WidgetKit
+
+### Rendering Mode Detection
+
+```swift
+struct MyWidgetView: View {
+    @Environment(\.widgetRenderingMode) var renderingMode
+
+    var body: some View {
+        if renderingMode == .accented {
+            // Tinted mode: white-tinted, themed glass background
+        } else {
+            // Full color mode: standard appearance
+        }
+    }
+}
+```
+
+### Accent Groups for Visual Hierarchy
+
+```swift
+HStack {
+    VStack(alignment: .leading) {
+        Text("Title")
+            .widgetAccentable()  // Accent group
+        Text("Subtitle")
+            // Primary group (default)
+    }
+    Image(systemName: "star.fill")
+        .widgetAccentable()  // Accent group
+}
+```
+
+### Image Rendering in Accented Mode
+
+```swift
+Image("myImage")
+    .widgetAccentedRenderingMode(.monochrome)
+```
+
+### Container Background
+
+```swift
+VStack { /* content */ }
+    .containerBackground(for: .widget) {
+        Color.blue.opacity(0.2)
+    }
+```
+
+## Key Design Decisions
+
+| Decision | Rationale |
+|----------|-----------|
+| GlassEffectContainer wrapping | Performance optimization, enables morphing between glass elements |
+| `spacing` parameter | Controls merge distance — fine-tune how close elements must be to blend |
+| `@Namespace` + `glassEffectID` | Enables smooth morphing transitions on view hierarchy changes |
+| `interactive()` modifier | Explicit opt-in for touch/pointer reactions — not all glass should respond |
+| UIGlassContainerEffect in UIKit | Same container pattern as SwiftUI for consistency |
+| Accented rendering mode in widgets | System applies tinted glass when user selects tinted Home Screen |
+
+## Best Practices
+
+- **Always use GlassEffectContainer** when applying glass to multiple sibling views — it enables morphing and improves rendering performance
+- **Apply `.glassEffect()` after** other appearance modifiers (frame, font, padding)
+- **Use `.interactive()`** only on elements that respond to user interaction (buttons, toggleable items)
+- **Choose spacing carefully** in containers to control when glass effects merge
+- **Use `withAnimation`** when changing view hierarchies to enable smooth morphing transitions
+- **Test across appearances** — light mode, dark mode, and accented/tinted modes
+- **Ensure accessibility contrast** — text on glass must remain readable
+
+## Anti-Patterns to Avoid
+
+- Using multiple standalone `.glassEffect()` views without a GlassEffectContainer
+- Nesting too many glass effects — degrades performance and visual clarity
+- Applying glass to every view — reserve for interactive elements, toolbars, and cards
+- Forgetting `clipsToBounds = true` in UIKit when using corner radii
+- Ignoring accented rendering mode in widgets — breaks tinted Home Screen appearance
+- Using opaque backgrounds behind glass — defeats the translucency effect
+
+## When to Use
+
+- Navigation bars, toolbars, and tab bars with the new iOS 26 design
+- Floating action buttons and card-style containers
+- Interactive controls that need visual depth and touch feedback
+- Widgets that should integrate with the system's Liquid Glass appearance
+- Morphing transitions between related UI states

package/.kimi/skills/llm-trading-agent-security/SKILL.md

@@ -0,0 +1,146 @@
+---
+name: llm-trading-agent-security
+description: Security patterns for autonomous trading agents with wallet or transaction authority. Covers prompt injection, spend limits, pre-send simulation, circuit breakers, MEV protection, and key handling.
+origin: ECC direct-port adaptation
+version: "1.0.0"
+---
+
+# LLM Trading Agent Security
+
+Autonomous trading agents have a harsher threat model than normal LLM apps: an injection or bad tool path can turn directly into asset loss.
+
+## When to Use
+
+- Building an AI agent that signs and sends transactions
+- Auditing a trading bot or on-chain execution assistant
+- Designing wallet key management for an agent
+- Giving an LLM access to order placement, swaps, or treasury operations
+
+## How It Works
+
+Layer the defenses. No single check is enough. Treat prompt hygiene, spend policy, simulation, execution limits, and wallet isolation as independent controls.
+
+## Examples
+
+### Treat prompt injection as a financial attack
+
+```python
+import re
+
+INJECTION_PATTERNS = [
+    r'ignore (previous|all) instructions',
+    r'new (task|directive|instruction)',
+    r'system prompt',
+    r'send .{0,50} to 0x[0-9a-fA-F]{40}',
+    r'transfer .{0,50} to',
+    r'approve .{0,50} for',
+]
+
+def sanitize_onchain_data(text: str) -> str:
+    for pattern in INJECTION_PATTERNS:
+        if re.search(pattern, text, re.IGNORECASE):
+            raise ValueError(f"Potential prompt injection: {text[:100]}")
+    return text
+```
+
+Do not blindly inject token names, pair labels, webhooks, or social feeds into an execution-capable prompt.
+
+### Hard spend limits
+
+```python
+from decimal import Decimal
+
+MAX_SINGLE_TX_USD = Decimal("500")
+MAX_DAILY_SPEND_USD = Decimal("2000")
+
+class SpendLimitError(Exception):
+    pass
+
+class SpendLimitGuard:
+    def check_and_record(self, usd_amount: Decimal) -> None:
+        if usd_amount > MAX_SINGLE_TX_USD:
+            raise SpendLimitError(f"Single tx ${usd_amount} exceeds max ${MAX_SINGLE_TX_USD}")
+
+        daily = self._get_24h_spend()
+        if daily + usd_amount > MAX_DAILY_SPEND_USD:
+            raise SpendLimitError(f"Daily limit: ${daily} + ${usd_amount} > ${MAX_DAILY_SPEND_USD}")
+
+        self._record_spend(usd_amount)
+```
+
+### Simulate before sending
+
+```python
+class SlippageError(Exception):
+    pass
+
+async def safe_execute(self, tx: dict, expected_min_out: int | None = None) -> str:
+    sim_result = await self.w3.eth.call(tx)
+
+    if expected_min_out is None:
+        raise ValueError("min_amount_out is required before send")
+
+    actual_out = decode_uint256(sim_result)
+    if actual_out < expected_min_out:
+        raise SlippageError(f"Simulation: {actual_out} < {expected_min_out}")
+
+    signed = self.account.sign_transaction(tx)
+    return await self.w3.eth.send_raw_transaction(signed.raw_transaction)
+```
+
+### Circuit breaker
+
+```python
+class TradingCircuitBreaker:
+    MAX_CONSECUTIVE_LOSSES = 3
+    MAX_HOURLY_LOSS_PCT = 0.05
+
+    def check(self, portfolio_value: float) -> None:
+        if self.consecutive_losses >= self.MAX_CONSECUTIVE_LOSSES:
+            self.halt("Too many consecutive losses")
+
+        if self.hour_start_value <= 0:
+            self.halt("Invalid hour_start_value")
+            return
+
+        hourly_pnl = (portfolio_value - self.hour_start_value) / self.hour_start_value
+        if hourly_pnl < -self.MAX_HOURLY_LOSS_PCT:
+            self.halt(f"Hourly PnL {hourly_pnl:.1%} below threshold")
+```
+
+### Wallet isolation
+
+```python
+import os
+from eth_account import Account
+
+private_key = os.environ.get("TRADING_WALLET_PRIVATE_KEY")
+if not private_key:
+    raise EnvironmentError("TRADING_WALLET_PRIVATE_KEY not set")
+
+account = Account.from_key(private_key)
+```
+
+Use a dedicated hot wallet with only the required session funds. Never point the agent at a primary treasury wallet.
+
+### MEV and deadline protection
+
+```python
+import time
+
+PRIVATE_RPC = "https://rpc.flashbots.net"
+MAX_SLIPPAGE_BPS = {"stable": 10, "volatile": 50}
+deadline = int(time.time()) + 60
+```
+
+## Pre-Deploy Checklist
+
+- External data is sanitized before entering the LLM context
+- Spend limits are enforced independently from model output
+- Transactions are simulated before send
+- `min_amount_out` is mandatory
+- Circuit breakers halt on drawdown or invalid state
+- Keys come from env or a secret manager, never code or logs
+- Private mempool or protected routing is used when appropriate
+- Slippage and deadlines are set per strategy
+- All agent decisions are audit-logged, not just successful sends