compact-agent 1.10.1 → 1.11.1

package/resources/ecc/skills/ios-icon-gen/scripts/generate_icons.swift

@@ -0,0 +1,258 @@
+#!/usr/bin/env swift
+
+import AppKit
+import Foundation
+
+// MARK: - Configuration
+
+struct IconSpec {
+    let symbolName: String
+    let assetName: String
+    let baseSize: CGFloat
+    let color: NSColor
+    let weight: NSFont.Weight
+}
+
+func parseColor(_ hex: String) -> NSColor {
+    var hex = hex.trimmingCharacters(in: .whitespacesAndNewlines)
+    if hex.hasPrefix("#") { hex.removeFirst() }
+    guard hex.count == 6, let value = UInt64(hex, radix: 16) else {
+        return NSColor(red: 142/255, green: 142/255, blue: 147/255, alpha: 1.0)
+    }
+    return NSColor(
+        red: CGFloat((value >> 16) & 0xFF) / 255,
+        green: CGFloat((value >> 8) & 0xFF) / 255,
+        blue: CGFloat(value & 0xFF) / 255,
+        alpha: 1.0
+    )
+}
+
+func parseWeight(_ name: String) -> NSFont.Weight {
+    switch name.lowercased() {
+    case "ultralight": return .ultraLight
+    case "thin": return .thin
+    case "light": return .light
+    case "regular": return .regular
+    case "medium": return .medium
+    case "semibold": return .semibold
+    case "bold": return .bold
+    case "heavy": return .heavy
+    case "black": return .black
+    default: return .thin
+    }
+}
+
+// MARK: - Generation
+
+enum IconError: Error, CustomStringConvertible {
+    case directoryCreation(String)
+    case symbolNotFound(String)
+    case configurationFailed(String)
+    case pngCreation(String)
+    case fileWrite(String)
+
+    var description: String {
+        switch self {
+        case .directoryCreation(let msg): return msg
+        case .symbolNotFound(let msg): return msg
+        case .configurationFailed(let msg): return msg
+        case .pngCreation(let msg): return msg
+        case .fileWrite(let msg): return msg
+        }
+    }
+}
+
+func generateIcon(_ spec: IconSpec, outputDir: String) throws {
+    let dir = "\(outputDir)/\(spec.assetName).imageset"
+    do {
+        try FileManager.default.createDirectory(atPath: dir, withIntermediateDirectories: true)
+    } catch {
+        throw IconError.directoryCreation("Could not create output directory '\(dir)': \(error.localizedDescription)")
+    }
+
+    let scales: [(suffix: String, multiplier: CGFloat)] = [("", 1), ("@2x", 2), ("@3x", 3)]
+
+    for scale in scales {
+        let pixelSize = spec.baseSize * scale.multiplier
+        let imageSize = NSSize(width: pixelSize, height: pixelSize)
+
+        let config = NSImage.SymbolConfiguration(
+            pointSize: pixelSize * 0.40,
+            weight: spec.weight,
+            scale: .large
+        )
+
+        guard let symbol = NSImage(systemSymbolName: spec.symbolName, accessibilityDescription: nil) else {
+            throw IconError.symbolNotFound("SF Symbol '\(spec.symbolName)' not found. Run 'SF Symbols' app to browse available names.")
+        }
+
+        guard let configured = symbol.withSymbolConfiguration(config) else {
+            throw IconError.configurationFailed("Could not apply symbol configuration to '\(spec.symbolName)'")
+        }
+
+        let image = NSImage(size: imageSize, flipped: false) { rect in
+            let symSize = configured.size
+            let x = (rect.width - symSize.width) / 2
+            let y = (rect.height - symSize.height) / 2
+            let drawRect = NSRect(x: x, y: y, width: symSize.width, height: symSize.height)
+
+            let tinted = NSImage(size: symSize, flipped: false) { tintRect in
+                configured.draw(in: tintRect)
+                spec.color.set()
+                tintRect.fill(using: .sourceAtop)
+                return true
+            }
+
+            tinted.draw(in: drawRect, from: .zero, operation: .sourceOver, fraction: 1.0)
+            return true
+        }
+
+        guard let tiffData = image.tiffRepresentation,
+              let bitmap = NSBitmapImageRep(data: tiffData),
+              let pngData = bitmap.representation(using: .png, properties: [:]) else {
+            throw IconError.pngCreation("Failed to create PNG for \(spec.assetName)\(scale.suffix)")
+        }
+
+        let fileName = "\(spec.assetName)\(scale.suffix).png"
+        do {
+            try pngData.write(to: URL(fileURLWithPath: "\(dir)/\(fileName)"))
+        } catch {
+            throw IconError.fileWrite("Failed to write \(fileName): \(error.localizedDescription)")
+        }
+        print("  \(fileName) (\(Int(pixelSize))x\(Int(pixelSize)))")
+    }
+
+    // Write Contents.json
+    let json = """
+    {
+      "images" : [
+        {
+          "filename" : "\(spec.assetName).png",
+          "idiom" : "universal",
+          "scale" : "1x"
+        },
+        {
+          "filename" : "\(spec.assetName)@2x.png",
+          "idiom" : "universal",
+          "scale" : "2x"
+        },
+        {
+          "filename" : "\(spec.assetName)@3x.png",
+          "idiom" : "universal",
+          "scale" : "3x"
+        }
+      ],
+      "info" : {
+        "author" : "xcode",
+        "version" : 1
+      }
+    }
+    """
+    do {
+        try json.write(toFile: "\(dir)/Contents.json", atomically: true, encoding: .utf8)
+    } catch {
+        throw IconError.fileWrite("Failed to write Contents.json: \(error.localizedDescription)")
+    }
+}
+
+func requireOptionValue(_ args: [String], at index: Int, flag: String) -> String {
+    guard index < args.count else {
+        fputs("ERROR: Missing value for \(flag)\n", stderr)
+        exit(1)
+    }
+    let value = args[index]
+    if value.hasPrefix("--") {
+        fputs("ERROR: Missing value for \(flag)\n", stderr)
+        exit(1)
+    }
+    return value
+}
+
+// MARK: - CLI
+
+let args = CommandLine.arguments
+
+if args.count < 3 || args.contains("--help") || args.contains("-h") {
+    print("""
+    Usage: generate_icons.swift <sf-symbol-name> <asset-name> [options]
+
+    Options:
+      --size <pt>       Base size in points (default: 68)
+      --color <hex>     Color hex code (default: 8E8E93)
+      --weight <name>   Font weight: ultralight|thin|light|regular|medium|semibold|bold|heavy|black (default: thin)
+      --output <dir>    Output directory (default: /tmp/icons)
+
+    Examples:
+      generate_icons.swift doc.text.below.ecg editTool_expenseReport
+      generate_icons.swift person.crop.rectangle editTool_businessCard --color 007AFF --weight regular
+      generate_icons.swift receipt myReceipt --size 48 --output ./Assets.xcassets/icons
+
+    Browse SF Symbol names: open the SF Symbols app (free from Apple) or https://developer.apple.com/sf-symbols/
+    """)
+    exit(0)
+}
+
+let symbolName = args[1]
+let assetName = args[2]
+
+var baseSize: CGFloat = 68
+var colorHex = "8E8E93"
+var weightName = "thin"
+var outputDir = "/tmp/icons"
+
+var i = 3
+while i < args.count {
+    switch args[i] {
+    case "--size":
+        let raw = requireOptionValue(args, at: i + 1, flag: "--size")
+        guard let size = Double(raw), size > 0 else {
+            fputs("ERROR: --size must be a positive number\n", stderr)
+            exit(1)
+        }
+        baseSize = CGFloat(size)
+        i += 2
+        continue
+    case "--color":
+        colorHex = requireOptionValue(args, at: i + 1, flag: "--color")
+        let stripped = colorHex.hasPrefix("#") ? String(colorHex.dropFirst()) : colorHex
+        guard stripped.count == 6, UInt64(stripped, radix: 16) != nil else {
+            fputs("ERROR: --color must be a 6-digit hex code (e.g. 007AFF)\n", stderr)
+            exit(1)
+        }
+        i += 2
+        continue
+    case "--weight":
+        weightName = requireOptionValue(args, at: i + 1, flag: "--weight")
+        let validWeights = ["ultralight", "thin", "light", "regular", "medium", "semibold", "bold", "heavy", "black"]
+        guard validWeights.contains(weightName.lowercased()) else {
+            fputs("ERROR: --weight must be one of: \(validWeights.joined(separator: ", "))\n", stderr)
+            exit(1)
+        }
+        i += 2
+        continue
+    case "--output":
+        outputDir = requireOptionValue(args, at: i + 1, flag: "--output")
+        i += 2
+        continue
+    default:
+        fputs("WARNING: Unknown option \(args[i])\n", stderr)
+    }
+    i += 1
+}
+
+let spec = IconSpec(
+    symbolName: symbolName,
+    assetName: assetName,
+    baseSize: baseSize,
+    color: parseColor(colorHex),
+    weight: parseWeight(weightName)
+)
+
+print("Generating \(assetName) from SF Symbol '\(symbolName)':")
+do {
+    try generateIcon(spec, outputDir: outputDir)
+    print("Output: \(outputDir)/\(assetName).imageset/")
+} catch {
+    fputs("ERROR: \(error)\n", stderr)
+    exit(1)
+}

package/resources/ecc/skills/ios-icon-gen/scripts/iconify_gen.sh

@@ -0,0 +1,235 @@
+#!/bin/bash
+#
+# Generate iOS icon imagesets from Iconify API (275k+ open source icons)
+# Uses: curl (download SVG) + sips (SVG->PNG conversion, built into macOS)
+#
+# Usage:
+#   iconify_gen.sh <icon-id> <asset-name> [options]
+#   iconify_gen.sh search <query> [--prefix <collection>] [--limit <n>]
+#
+# Examples:
+#   iconify_gen.sh mdi:receipt-text-outline myExpenseIcon
+#   iconify_gen.sh search "business card"
+#   iconify_gen.sh search receipt --prefix mdi
+
+set -euo pipefail
+
+API_BASE="https://api.iconify.design"
+readonly CURL_OPTS=(--fail --silent --show-error --connect-timeout 10 --max-time 30)
+
+# Defaults
+SIZE=68
+COLOR="8E8E93"
+OUTPUT="/tmp/icons"
+LIMIT=20
+
+require_value() {
+    local flag="$1"
+    local value="${2-}"
+    if [[ -z "$value" || "$value" == --* ]]; then
+        echo "ERROR: ${flag} requires a value" >&2
+        exit 1
+    fi
+}
+
+usage() {
+    cat <<'EOF'
+Usage:
+  iconify_gen.sh <icon-id> <asset-name> [options]    Generate an icon imageset
+  iconify_gen.sh search <query> [options]             Search for icons
+  iconify_gen.sh preview <icon-id>                    Download preview SVG
+  iconify_gen.sh collections                          List popular icon collections
+
+Generate Options:
+  --size <pt>       Base size in points (default: 68)
+  --color <hex>     Color hex without # (default: 8E8E93)
+  --output <dir>    Output directory (default: /tmp/icons)
+
+Search Options:
+  --prefix <name>   Filter by collection (e.g., mdi, lucide, tabler, ph)
+  --limit <n>       Max results (default: 20)
+
+Icon ID Format: <collection>:<icon-name>
+  Examples: mdi:receipt-text-outline, lucide:credit-card, ph:address-book
+
+Popular Collections:
+  mdi      Material Design Icons (7400+ icons)
+  lucide   Lucide (1700+ icons)
+  tabler   Tabler Icons (6000+ icons)
+  ph       Phosphor (9000+ icons)
+  ri       Remix Icon (2800+ icons)
+  carbon   Carbon (2100+ icons)
+EOF
+    exit 0
+}
+
+search_icons() {
+    local query="$1"
+    shift
+    local prefix=""
+
+    while [[ $# -gt 0 ]]; do
+        case "$1" in
+            --prefix) require_value --prefix "${2-}"; prefix="$2"; shift 2 ;;
+            --limit) require_value --limit "${2-}"; LIMIT="$2"; shift 2 ;;
+            *) shift ;;
+        esac
+    done
+
+    local encoded_query
+    encoded_query="$(python3 -c "import urllib.parse, sys; print(urllib.parse.quote(sys.argv[1]))" "$query")"
+    local url="${API_BASE}/search?query=${encoded_query}&limit=${LIMIT}"
+    if [[ -n "$prefix" ]]; then
+        url="${url}&prefix=${prefix}"
+    fi
+
+    local response
+    response=$(curl "${CURL_OPTS[@]}" "$url") || { echo "ERROR: Search request failed"; exit 1; }
+
+    local total
+    total=$(echo "$response" | python3 -c "import sys,json; print(json.load(sys.stdin).get('total',0))")
+
+    echo "Found ${total} icons for '${query}':"
+    echo ""
+    echo "$response" | python3 -c "
+import sys, json
+data = json.load(sys.stdin)
+for icon in data.get('icons', []):
+    print(f'  {icon}')
+"
+    echo ""
+    echo "Generate with: iconify_gen.sh <icon-id> <asset-name>"
+    echo "Preview with:  iconify_gen.sh preview <icon-id>"
+}
+
+list_collections() {
+    echo "Popular Iconify collections:"
+    echo ""
+    local resp
+    resp=$(curl "${CURL_OPTS[@]}" "${API_BASE}/collections") || { echo "ERROR: Failed to fetch collections list"; exit 1; }
+    echo "$resp" | python3 -c "
+import sys, json
+data = json.load(sys.stdin)
+popular = ['mdi','lucide','tabler','ph','ri','carbon','solar','heroicons','bi','octicon','ion','fe','charm','ci','iconoir','basil','uil','mingcute','flowbite','mynaui']
+for k in popular:
+    if k in data:
+        v = data[k]
+        name = v.get('name','')
+        total = v.get('total',0)
+        print(f'  {k:12s} {name} ({total} icons)')
+"
+    echo ""
+    echo "Full list: https://icon-sets.iconify.design/"
+}
+
+preview_icon() {
+    local icon_id="$1"
+    local collection="${icon_id%%:*}"
+    local name="${icon_id#*:}"
+    local url="${API_BASE}/${collection}/${name}.svg?width=136&height=136&color=%23${COLOR}"
+    local outfile="/tmp/iconify_preview_${collection}_${name}.svg"
+
+    curl "${CURL_OPTS[@]}" "$url" -o "$outfile" || { echo "ERROR: Icon '${icon_id}' not found"; exit 1; }
+    echo "Preview SVG: ${outfile}"
+    echo "URL: ${url}"
+
+    # Also convert to PNG for visual check
+    local pngfile="/tmp/iconify_preview_${collection}_${name}.png"
+    sips -s format png "$outfile" --out "$pngfile" >/dev/null 2>&1 || echo "WARNING: sips conversion failed; PNG may be incorrect"
+    echo "Preview PNG: ${pngfile}"
+}
+
+generate_icon() {
+    local icon_id="$1"
+    local asset_name="$2"
+    shift 2
+
+    while [[ $# -gt 0 ]]; do
+        case "$1" in
+            --size) require_value --size "${2-}"; SIZE="$2"; shift 2 ;;
+            --color) require_value --color "${2-}"; COLOR="$2"; shift 2 ;;
+            --output) require_value --output "${2-}"; OUTPUT="$2"; shift 2 ;;
+            *) shift ;;
+        esac
+    done
+
+    local collection="${icon_id%%:*}"
+    local name="${icon_id#*:}"
+    local imageset_dir="${OUTPUT}/${asset_name}.imageset"
+
+    mkdir -p "$imageset_dir"
+
+    echo "Generating ${asset_name} from Iconify '${icon_id}':"
+
+    local scales=("1:${SIZE}" "2:$((SIZE * 2))" "3:$((SIZE * 3))")
+
+    for scale_info in "${scales[@]}"; do
+        local scale="${scale_info%%:*}"
+        local px="${scale_info#*:}"
+        local suffix=""
+        [[ "$scale" != "1" ]] && suffix="@${scale}x"
+
+        local svg_url="${API_BASE}/${collection}/${name}.svg?width=${px}&height=${px}&color=%23${COLOR}"
+        local svg_file="${imageset_dir}/${asset_name}${suffix}.svg"
+        local png_file="${imageset_dir}/${asset_name}${suffix}.png"
+
+        curl "${CURL_OPTS[@]}" "$svg_url" -o "$svg_file" || { echo "ERROR: Failed to download icon '${icon_id}'"; exit 1; }
+        sips -s format png "$svg_file" --out "$png_file" >/dev/null 2>&1 || echo "WARNING: sips conversion may have failed for ${svg_file}"
+        rm "$svg_file"
+
+        echo "  ${asset_name}${suffix}.png (${px}x${px})"
+    done
+
+    # Write Contents.json
+    cat > "${imageset_dir}/Contents.json" <<JSONEOF
+{
+  "images" : [
+    {
+      "filename" : "${asset_name}.png",
+      "idiom" : "universal",
+      "scale" : "1x"
+    },
+    {
+      "filename" : "${asset_name}@2x.png",
+      "idiom" : "universal",
+      "scale" : "2x"
+    },
+    {
+      "filename" : "${asset_name}@3x.png",
+      "idiom" : "universal",
+      "scale" : "3x"
+    }
+  ],
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}
+JSONEOF
+
+    echo "Output: ${imageset_dir}/"
+}
+
+# Main
+[[ $# -eq 0 ]] && usage
+[[ "$1" == "--help" || "$1" == "-h" ]] && usage
+
+case "$1" in
+    search)
+        shift
+        [[ $# -eq 0 ]] && { echo "Usage: iconify_gen.sh search <query>"; exit 1; }
+        search_icons "$@"
+        ;;
+    preview)
+        shift
+        [[ $# -eq 0 ]] && { echo "Usage: iconify_gen.sh preview <icon-id>"; exit 1; }
+        preview_icon "$1"
+        ;;
+    collections)
+        list_collections
+        ;;
+    *)
+        [[ $# -lt 2 ]] && { echo "Usage: iconify_gen.sh <icon-id> <asset-name> [options]"; exit 1; }
+        generate_icon "$@"
+        ;;
+esac

package/resources/ecc/skills/iterative-retrieval/SKILL.md

@@ -0,0 +1,211 @@
+---
+name: iterative-retrieval
+description: Pattern for progressively refining context retrieval to solve the subagent context problem
+origin: ECC
+---
+
+# Iterative Retrieval Pattern
+
+Solves the "context problem" in multi-agent workflows where subagents don't know what context they need until they start working.
+
+## When to Activate
+
+- Spawning subagents that need codebase context they cannot predict upfront
+- Building multi-agent workflows where context is progressively refined
+- Encountering "context too large" or "missing context" failures in agent tasks
+- Designing RAG-like retrieval pipelines for code exploration
+- Optimizing token usage in agent orchestration
+
+## The Problem
+
+Subagents are spawned with limited context. They don't know:
+- Which files contain relevant code
+- What patterns exist in the codebase
+- What terminology the project uses
+
+Standard approaches fail:
+- **Send everything**: Exceeds context limits
+- **Send nothing**: Agent lacks critical information
+- **Guess what's needed**: Often wrong
+
+## The Solution: Iterative Retrieval
+
+A 4-phase loop that progressively refines context:
+
+```
+┌─────────────────────────────────────────────┐
+│                                             │
+│   ┌──────────┐      ┌──────────┐            │
+│   │ DISPATCH │─────│ EVALUATE │            │
+│   └──────────┘      └──────────┘            │
+│        ▲                  │                 │
+│        │                  ▼                 │
+│   ┌──────────┐      ┌──────────┐            │
+│   │   LOOP   │─────│  REFINE  │            │
+│   └──────────┘      └──────────┘            │
+│                                             │
+│        Max 3 cycles, then proceed           │
+└─────────────────────────────────────────────┘
+```
+
+### Phase 1: DISPATCH
+
+Initial broad query to gather candidate files:
+
+```javascript
+// Start with high-level intent
+const initialQuery = {
+  patterns: ['src/**/*.ts', 'lib/**/*.ts'],
+  keywords: ['authentication', 'user', 'session'],
+  excludes: ['*.test.ts', '*.spec.ts']
+};
+
+// Dispatch to retrieval agent
+const candidates = await retrieveFiles(initialQuery);
+```
+
+### Phase 2: EVALUATE
+
+Assess retrieved content for relevance:
+
+```javascript
+function evaluateRelevance(files, task) {
+  return files.map(file => ({
+    path: file.path,
+    relevance: scoreRelevance(file.content, task),
+    reason: explainRelevance(file.content, task),
+    missingContext: identifyGaps(file.content, task)
+  }));
+}
+```
+
+Scoring criteria:
+- **High (0.8-1.0)**: Directly implements target functionality
+- **Medium (0.5-0.7)**: Contains related patterns or types
+- **Low (0.2-0.4)**: Tangentially related
+- **None (0-0.2)**: Not relevant, exclude
+
+### Phase 3: REFINE
+
+Update search criteria based on evaluation:
+
+```javascript
+function refineQuery(evaluation, previousQuery) {
+  return {
+    // Add new patterns discovered in high-relevance files
+    patterns: [...previousQuery.patterns, ...extractPatterns(evaluation)],
+
+    // Add terminology found in codebase
+    keywords: [...previousQuery.keywords, ...extractKeywords(evaluation)],
+
+    // Exclude confirmed irrelevant paths
+    excludes: [...previousQuery.excludes, ...evaluation
+      .filter(e => e.relevance < 0.2)
+      .map(e => e.path)
+    ],
+
+    // Target specific gaps
+    focusAreas: evaluation
+      .flatMap(e => e.missingContext)
+      .filter(unique)
+  };
+}
+```
+
+### Phase 4: LOOP
+
+Repeat with refined criteria (max 3 cycles):
+
+```javascript
+async function iterativeRetrieve(task, maxCycles = 3) {
+  let query = createInitialQuery(task);
+  let bestContext = [];
+
+  for (let cycle = 0; cycle < maxCycles; cycle++) {
+    const candidates = await retrieveFiles(query);
+    const evaluation = evaluateRelevance(candidates, task);
+
+    // Check if we have sufficient context
+    const highRelevance = evaluation.filter(e => e.relevance >= 0.7);
+    if (highRelevance.length >= 3 && !hasCriticalGaps(evaluation)) {
+      return highRelevance;
+    }
+
+    // Refine and continue
+    query = refineQuery(evaluation, query);
+    bestContext = mergeContext(bestContext, highRelevance);
+  }
+
+  return bestContext;
+}
+```
+
+## Practical Examples
+
+### Example 1: Bug Fix Context
+
+```
+Task: "Fix the authentication token expiry bug"
+
+Cycle 1:
+  DISPATCH: Search for "token", "auth", "expiry" in src/**
+  EVALUATE: Found auth.ts (0.9), tokens.ts (0.8), user.ts (0.3)
+  REFINE: Add "refresh", "jwt" keywords; exclude user.ts
+
+Cycle 2:
+  DISPATCH: Search refined terms
+  EVALUATE: Found session-manager.ts (0.95), jwt-utils.ts (0.85)
+  REFINE: Sufficient context (2 high-relevance files)
+
+Result: auth.ts, tokens.ts, session-manager.ts, jwt-utils.ts
+```
+
+### Example 2: Feature Implementation
+
+```
+Task: "Add rate limiting to API endpoints"
+
+Cycle 1:
+  DISPATCH: Search "rate", "limit", "api" in routes/**
+  EVALUATE: No matches - codebase uses "throttle" terminology
+  REFINE: Add "throttle", "middleware" keywords
+
+Cycle 2:
+  DISPATCH: Search refined terms
+  EVALUATE: Found throttle.ts (0.9), middleware/index.ts (0.7)
+  REFINE: Need router patterns
+
+Cycle 3:
+  DISPATCH: Search "router", "express" patterns
+  EVALUATE: Found router-setup.ts (0.8)
+  REFINE: Sufficient context
+
+Result: throttle.ts, middleware/index.ts, router-setup.ts
+```
+
+## Integration with Agents
+
+Use in agent prompts:
+
+```markdown
+When retrieving context for this task:
+1. Start with broad keyword search
+2. Evaluate each file's relevance (0-1 scale)
+3. Identify what context is still missing
+4. Refine search criteria and repeat (max 3 cycles)
+5. Return files with relevance >= 0.7
+```
+
+## Best Practices
+
+1. **Start broad, narrow progressively** - Don't over-specify initial queries
+2. **Learn codebase terminology** - First cycle often reveals naming conventions
+3. **Track what's missing** - Explicit gap identification drives refinement
+4. **Stop at "good enough"** - 3 high-relevance files beats 10 mediocre ones
+5. **Exclude confidently** - Low-relevance files won't become relevant
+
+## Related
+
+- [The Longform Guide](https://x.com/affaanmustafa/status/2014040193557471352) - Subagent orchestration section
+- `continuous-learning` skill - For patterns that improve over time
+- Agent definitions bundled with ECC (manual install path: `agents/`)