pantheon-opencode 1.0.0

package/scripts/generate-prompts.sh

@@ -0,0 +1,222 @@
+#!/usr/bin/env bash
+# generate-prompts.sh — Generate dynamic prompt templates for Pantheon
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PANTHEON_DIR="$(dirname "$SCRIPT_DIR")"
+
+# ── Read active plan ─────────────────────────────────────────────────────────
+PLAN_FILE="$PANTHEON_DIR/platform/plans/plan-active.json"
+if [[ -f "$PLAN_FILE" ]]; then
+    PLAN=$(jq -r '.plan // "unknown"' "$PLAN_FILE")
+    SERVICE=$(jq -r '.service // "unknown"' "$PLAN_FILE")
+    TIER=$(jq -r '.tier // "unknown"' "$PLAN_FILE")
+    PRICE=$(jq -r '.price // "unknown"' "$PLAN_FILE")
+    MONTHLY_REQUESTS=$(jq -r '.limits.monthlyRequests // "unlimited"' "$PLAN_FILE")
+
+    # Build tier-to-model map
+    TIER_MAP=$(jq -r '
+        to_entries[]
+        | select(.key | IN("free","fast","default","premium"))
+        | "  \(.key): \(.value)"
+    ' "$PLAN_FILE" 2>/dev/null || echo "  (unable to parse tiers)")
+
+    # Build agent overrides map
+    AGENT_OVERRIDES=$(jq -r '
+        .agent_overrides // {}
+        | to_entries[]
+        | "  \(.key): \(.value)"
+    ' "$PLAN_FILE" 2>/dev/null || true)
+else
+    PLAN="default"
+    SERVICE="opencode"
+    TIER="default"
+    PRICE="unknown"
+    MONTHLY_REQUESTS="unlimited"
+    TIER_MAP="  default: unknown"
+    AGENT_OVERRIDES=""
+fi
+
+# ── List agents ──────────────────────────────────────────────────────────────
+AGENTS_DIR="$PANTHEON_DIR/platform/opencode/agents"
+AGENTS_LIST=""
+if [[ -d "$AGENTS_DIR" ]]; then
+    AGENTS_LIST=$(ls "$AGENTS_DIR"/*.md 2>/dev/null | xargs -n1 basename | sed 's/\.md$//' | sort | paste -sd ', ' -)
+fi
+
+# ── Create dynamic prompts directory ─────────────────────────────────────────
+DYNAMIC_DIR="$PANTHEON_DIR/prompts/dynamic"
+mkdir -p "$DYNAMIC_DIR"
+
+# ── Helper: extract description from agent frontmatter ───────────────────────
+extract_description() {
+    local file="$1"
+    # Grab the first 'description:' line inside the first YAML frontmatter block
+    sed -n '/^---$/,/^---$/p' "$file" 2>/dev/null \
+        | grep -m1 '^description:' \
+        | sed 's/^description:[[:space:]]*//; s/^"//; s/"$//; s/^'"'"'//; s/'"'"'$//' \
+        || echo "No description available"
+}
+
+# ── Generate Agora Prompt ─────────────────────────────────────────────────────
+AGORA_FILE="$DYNAMIC_DIR/agora-generated.txt"
+cat > "$AGORA_FILE" << EOF
+# =============================================================================
+# Dynamic Agora Prompt
+# Generated: $(date -u +"%Y-%m-%dT%H:%M:%SZ")
+# Plan: $PLAN
+# Service: $SERVICE
+# Tier: $TIER
+# Price: $PRICE
+# Monthly Requests: $MONTHLY_REQUESTS
+# =============================================================================
+
+You are convening an agora with access to these specialists: $AGENTS_LIST
+
+## Platform Capabilities
+EOF
+
+if [[ -n "$TIER_MAP" ]]; then
+    echo "Model Tiers:" >> "$AGORA_FILE"
+    echo "$TIER_MAP" >> "$AGORA_FILE"
+    echo "" >> "$AGORA_FILE"
+fi
+
+if [[ -n "$AGENT_OVERRIDES" ]]; then
+    echo "Agent Overrides:" >> "$AGORA_FILE"
+    echo "$AGENT_OVERRIDES" >> "$AGORA_FILE"
+    echo "" >> "$AGORA_FILE"
+fi
+
+cat >> "$AGORA_FILE" << EOF
+## Instructions
+1. Select 3-5 relevant agents based on the question domain
+2. Dispatch them in parallel with the same question
+3. Synthesize their perspectives into a single recommendation
+4. Include confidence level and next steps
+
+## Available Specialists
+EOF
+
+for agent_file in "$AGENTS_DIR"/*.md; do
+    [[ -f "$agent_file" ]] || continue
+    agent_name=$(basename "$agent_file" .md)
+    description=$(extract_description "$agent_file")
+    printf -- "- @%s: %s\n" "$agent_name" "$description" >> "$AGORA_FILE"
+done
+
+# ── Generate Orchestration Prompt ────────────────────────────────────────────
+ORCH_FILE="$DYNAMIC_DIR/orchestrate-generated.txt"
+cat > "$ORCH_FILE" << EOF
+# =============================================================================
+# Dynamic Orchestration Prompt
+# Generated: $(date -u +"%Y-%m-%dT%H:%M:%SZ")
+# Plan: $PLAN
+# Service: $SERVICE
+# Tier: $TIER
+# Price: $PRICE
+# Monthly Requests: $MONTHLY_REQUESTS
+# =============================================================================
+
+You are Zeus, the central orchestrator for the Pantheon multi-agent system.
+
+## Active Configuration
+- Plan: $PLAN
+- Service: $SERVICE
+- Tier: $TIER
+- Price: $PRICE
+- Monthly Request Limit: $MONTHLY_REQUESTS
+
+## Model Tiers
+EOF
+
+if [[ -n "$TIER_MAP" ]]; then
+    echo "$TIER_MAP" >> "$ORCH_FILE"
+fi
+
+cat >> "$ORCH_FILE" << EOF
+
+## Available Agents
+EOF
+
+for agent_file in "$AGENTS_DIR"/*.md; do
+    [[ -f "$agent_file" ]] || continue
+    agent_name=$(basename "$agent_file" .md)
+    description=$(extract_description "$agent_file")
+    printf -- "- @%s: %s\n" "$agent_name" "$description" >> "$ORCH_FILE"
+done
+
+cat >> "$ORCH_FILE" << EOF
+
+## Orchestration Rules
+1. **Planning**: Delegate to @athena for architecture decisions
+2. **Discovery**: Delegate to @apollo for codebase investigation
+3. **Implementation**: Dispatch @hermes (backend), @aphrodite (frontend), @demeter (database) in parallel when scopes are independent
+4. **Review**: Always route completed work to @themis before merge
+5. **Deploy**: Route infrastructure changes to @prometheus
+6. **Document**: Route memory tasks to @mnemosyne
+7. **Hotfix**: Route small fixes to @talos (bypass orchestration)
+
+## Cost-Conscious Routing
+- Use \`fast\` tier agents for discovery, documentation, and simple queries
+- Use \`default\` tier agents for standard implementation work
+- Use \`premium\` tier agents for planning, review, and complex orchestration
+- Respect monthly request limits: $MONTHLY_REQUESTS
+EOF
+
+# ── Generate Agent Handoff Prompt ────────────────────────────────────────────
+HANDOFF_FILE="$DYNAMIC_DIR/handoff-generated.txt"
+cat > "$HANDOFF_FILE" << EOF
+# =============================================================================
+# Dynamic Agent Handoff Prompt
+# Generated: $(date -u +"%Y-%m-%dT%H:%M:%SZ")
+# Plan: $PLAN
+# Service: $SERVICE
+# Tier: $TIER
+# =============================================================================
+
+## Handoff Tier Assignments
+EOF
+
+if [[ -n "$TIER_MAP" ]]; then
+    echo "$TIER_MAP" >> "$HANDOFF_FILE"
+    echo "" >> "$HANDOFF_FILE"
+fi
+
+cat >> "$HANDOFF_FILE" << EOF
+## Agent Directory
+EOF
+
+for agent_file in "$AGENTS_DIR"/*.md; do
+    [[ -f "$agent_file" ]] || continue
+    agent_name=$(basename "$agent_file" .md)
+    description=$(extract_description "$agent_file")
+    printf -- "- @%s: %s\n" "$agent_name" "$description" >> "$HANDOFF_FILE"
+done
+
+cat >> "$HANDOFF_FILE" << EOF
+
+## Handoff Rules
+| Direction | Tier | Reason |
+|---|---|---|
+| Any → Themis | premium | Critical quality + security gate |
+| Any → Zeus | premium | Complex orchestration decisions |
+| Athena → Zeus | premium | Plan handoff needs careful execution |
+| Any → Mnemosyne | fast | Simple documentation writes |
+| Hephaestus → Prometheus | default | Infrastructure config generation |
+| Hephaestus | fast | Conversational AI dispatch |
+
+## Cost Cap Rule
+The requested model tier cannot exceed the cost tier of the main conversation model.
+EOF
+
+# ── Summary ────────────────────────────────────────────────────────────────────
+echo "✅ Generated dynamic prompts for plan '$PLAN'"
+echo "   Service: $SERVICE"
+echo "   Tier: $TIER"
+echo "   Agents: $AGENTS_LIST"
+echo ""
+echo "   Output files:"
+echo "     - $AGORA_FILE"
+echo "     - $ORCH_FILE"
+echo "     - $HANDOFF_FILE"

package/scripts/generate-routing-docs.mjs

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+/**
+ * generate-routing-docs.mjs — Generate routing docs from routing.yml
+ *
+ * Reads the canonical routing.yml and outputs markdown documentation
+ * to stdout. Pipe to a file to save: node generate-routing-docs.mjs > ROUTING.md
+ */
+
+import { existsSync, readFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import yaml from 'js-yaml'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const ROOT = join(__dirname, '..')
+
+const routingPath = join(ROOT, 'routing.yml')
+if (!existsSync(routingPath)) {
+  console.error('❌ routing.yml not found')
+  process.exit(1)
+}
+const routing = yaml.load(readFileSync(routingPath, 'utf8'))
+
+const agents = routing.agents || {}
+const matrix = routing.routing_matrix || []
+const handoffs = routing.handoffs || {}
+
+let doc = ''
+
+// Title
+doc += `# Pantheon Routing Reference\n\n`
+doc += `Auto-generated from \`routing.yml\` (v${routing.version || '?'})\n\n`
+doc += `${Object.keys(agents).length} agents · ${matrix.length} routing rules · ${Object.keys(handoffs).length} agent handoff groups\n\n`
+
+// Agent Registry
+doc += `---\n\n## Agent Registry\n\n`
+doc += `All ${Object.keys(agents).length} Pantheon agents with roles, model tiers, and capabilities.\n\n`
+doc += `| Agent | Role | Model Tier | User-Invocable | Delegates To | Skills |\n`
+doc += `|-------|------|-----------|----------------|-------------|--------|\n`
+
+for (const [name, info] of Object.entries(agents)) {
+  const role = info.role || '—'
+  const tier = info.model_tier || '—'
+  const invocable = info.user_invocable ? '✅ Yes' : '❌ No'
+  const delegates = (info.subagent_can_delegate_to || []).join(', ') || '—'
+  const agentSkills = (info.skills || []).map((s) => `\`${s}\``).join(', ') || '—'
+  doc += `| **@${name}** | ${role} | ${tier} | ${invocable} | ${delegates} | ${agentSkills} |\n`
+}
+
+// Routing Matrix
+doc += `\n---\n\n## Routing Matrix\n\n`
+doc += `Task category → primary agent mapping. Use this to decide which agent to invoke.\n\n`
+doc += `| Category | Primary Agent | Model Tier | Can Run Parallel With |\n`
+doc += `|----------|--------------|-----------|----------------------|\n`
+
+for (const entry of matrix) {
+  const primary = `@${entry.primary_agent}`
+  const tier = entry.model_tier || '—'
+  const parallel = entry.parallel_with ? entry.parallel_with.map((a) => `@${a}`).join(', ') : '—'
+  doc += `| ${entry.category} | ${primary} | ${tier} | ${parallel} |\n`
+}
+
+// Handoff Reference
+doc += `\n---\n\n## Handoff Reference\n\n`
+doc += `Structured delegation contracts between agents.\n\n`
+
+for (const [agentName, agentHandoffs] of Object.entries(handoffs)) {
+  doc += `### @${agentName}\n\n`
+  doc += `| Handoff | Target Agent | Model Tier | Description |\n`
+  doc += `|---------|-------------|-----------|-------------|\n`
+
+  for (const [key, handoff] of Object.entries(agentHandoffs)) {
+    if (typeof handoff !== 'object') continue
+    const target = `@${handoff.agent}`
+    const tier = handoff.model_tier || '—'
+    const desc = handoff.description || handoff.prompt?.substring(0, 80) || '—'
+    doc += `| **${key}** | ${target} | ${tier} | ${desc} |\n`
+  }
+  doc += `\n`
+}
+
+// Deployment platforms
+doc += `---\n\n## Deployment Platforms\n\n`
+doc += `Supported platforms and their configuration details.\n\n`
+doc += `| Platform | Directory | Format | Handoff Strategy |\n`
+doc += `|----------|-----------|--------|-----------------|\n`
+
+const PLATFORM_INFO = {
+  opencode: { dir: '.opencode/agents/', format: '.md with YAML', handoff: 'native (YAML)' },
+  claude: { dir: '.claude/agents/', format: '.md with YAML', handoff: 'embed (body)' },
+  cursor: { dir: '.cursor/rules/', format: '.mdc rule files', handoff: 'embed (body)' },
+  windsurf: { dir: '.windsurf/rules/', format: '.md rule files', handoff: 'embed (body)' },
+  cline: { dir: '.clinerules/', format: 'plain text', handoff: 'embed (body)' },
+  copilot: { dir: '.github/agents/', format: '.agent.md with YAML', handoff: 'native (YAML)' },
+  continue: { dir: '.continue/rules/', format: '.md rules', handoff: 'embed (body)' },
+}
+
+for (const [platform, info] of Object.entries(PLATFORM_INFO)) {
+  doc += `| **${platform}** | ${info.dir} | ${info.format} | ${info.handoff} |\n`
+}
+
+doc += `\n---\n\n*Generated on ${new Date().toISOString().split('T')[0]} from \`routing.yml\`*\n`
+
+console.log(doc)

package/scripts/hash_verify.py

@@ -0,0 +1,192 @@
+#!/usr/bin/env python3
+"""Hash-Anchored Edit Verification — standalone script.
+
+Verifies that file edits actually changed content by comparing SHA-256
+hashes before and after an edit. Detects failed/no-op edits.
+
+Usage:
+  python3 scripts/hash_verify.py <file> [--before-hash=<sha256>] [--diff-min-lines=10]
+  python3 scripts/hash_verify.py --staged           # Check all staged files
+  python3 scripts/hash_verify.py --batch <file>...  # Check multiple files
+"""
+
+import argparse
+import hashlib
+import subprocess
+import sys
+from pathlib import Path
+
+EXIT_SUCCESS = 0
+EXIT_FAILURE = 1
+EXIT_WARNING = 2
+
+
+def sha256_of(file: Path) -> str:
+    """Return hex SHA-256 of file content."""
+    return hashlib.sha256(file.read_bytes()).hexdigest()
+
+
+def compute_diff_size(file: Path) -> int:
+    """Return number of changed lines in working-tree diff."""
+    try:
+        result = subprocess.run(
+            ["git", "diff", "--", str(file)],
+            capture_output=True,
+            text=True,
+            timeout=5,
+            check=False,
+        )
+    except (subprocess.TimeoutExpired, FileNotFoundError):
+        return 0
+
+    diff = result.stdout
+    added = len(
+        [
+            line
+            for line in diff.split("\n")
+            if line.startswith("+") and not line.startswith("+++")
+        ]
+    )
+    removed = len(
+        [
+            line
+            for line in diff.split("\n")
+            if line.startswith("-") and not line.startswith("---")
+        ]
+    )
+    return added + removed
+
+
+def verify_file(file: Path, before_hash: str | None, diff_min_lines: int) -> dict:
+    """Verify a single file edit."""
+    if not file.exists():
+        return {"file": str(file), "status": "error", "message": "File does not exist"}
+
+    after_hash = sha256_of(file)
+
+    if before_hash:
+        # Compare explicit before/after hashes
+        if after_hash == before_hash:
+            return {
+                "file": str(file),
+                "status": "failed",
+                "hash_before": before_hash,
+                "hash_after": after_hash,
+                "message": "Hash unchanged — edit did not modify file content",
+            }
+    else:
+        # Auto-detect: check git diff
+        diff_changes = compute_diff_size(file)
+        if diff_changes == 0:
+            return {
+                "file": str(file),
+                "status": "failed",
+                "hash_after": after_hash,
+                "message": "No git diff detected — edit did not modify file",
+            }
+
+        if diff_changes < diff_min_lines:
+            return {
+                "file": str(file),
+                "status": "warning",
+                "hash_after": after_hash,
+                "diff_lines": diff_changes,
+                "message": f"Edit detected but diff is small ({diff_changes} lines vs min {diff_min_lines})",
+            }
+
+    return {
+        "file": str(file),
+        "status": "verified",
+        "hash_after": after_hash,
+        "message": "Edit verified — file content changed",
+    }
+
+
+def check_staged_files(diff_min_lines: int) -> list[dict]:
+    """Verify all staged (git-add'ed) files."""
+    try:
+        result = subprocess.run(
+            ["git", "diff", "--cached", "--name-only"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+            check=False,
+        )
+    except (subprocess.TimeoutExpired, FileNotFoundError):
+        return [{"status": "error", "message": "Git not available"}]
+
+    staged = [f.strip() for f in result.stdout.split("\n") if f.strip()]
+    results = []
+    for fname in staged[:20]:  # limit to 20 files
+        fpath = Path(fname)
+        if fpath.exists():
+            results.append(verify_file(fpath, None, diff_min_lines))
+    return results
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Hash-anchored edit verification — ensures file edits actually changed content."
+    )
+    parser.add_argument("files", nargs="*", help="File(s) to verify")
+    parser.add_argument(
+        "--before-hash", help="Expected SHA-256 hash before edit (for single-file mode)"
+    )
+    parser.add_argument(
+        "--diff-min-lines",
+        type=int,
+        default=3,
+        help="Minimum diff lines to consider edit meaningful (default: 3)",
+    )
+    parser.add_argument(
+        "--staged", action="store_true", help="Verify all staged files instead"
+    )
+    parser.add_argument(
+        "--batch", action="store_true", help="Treat positional args as batch file list"
+    )
+    args = parser.parse_args()
+
+    if args.staged:
+        results = check_staged_files(args.diff_min_lines)
+    elif args.batch or len(args.files) > 1:
+        results = [verify_file(Path(f), None, args.diff_min_lines) for f in args.files]
+    elif args.files:
+        results = [
+            verify_file(Path(args.files[0]), args.before_hash, args.diff_min_lines)
+        ]
+    else:
+        print("Usage: python3 scripts/hash_verify.py <file> [--before-hash=<sha256>]")
+        print("       python3 scripts/hash_verify.py --staged")
+        print("       python3 scripts/hash_verify.py --batch <file>...")
+        sys.exit(EXIT_FAILURE)
+
+    # Print results
+    any_failed = False
+    any_warning = False
+
+    for r in results:
+        status_tag = {
+            "verified": "✅",
+            "warning": "⚠️",
+            "failed": "❌",
+            "error": "❌",
+        }.get(r["status"], "❓")
+        print(f"{status_tag} {r['file']}: {r['message']}")
+        if r["status"] == "failed" or r["status"] == "error":
+            any_failed = True
+        elif r["status"] == "warning":
+            any_warning = True
+
+    if any_failed:
+        print("\n❌ HASH VERIFY FAILED — some edits did not modify files")
+        sys.exit(EXIT_FAILURE)
+    elif any_warning:
+        print("\n⚠️  HASH VERIFY PASSED WITH WARNINGS — small diffs detected")
+        sys.exit(EXIT_WARNING)
+    else:
+        print("\n✅ HASH VERIFY: all edits verified")
+        sys.exit(EXIT_SUCCESS)
+
+
+if __name__ == "__main__":
+    main()

package/scripts/init-pantheon-mcp.sh

@@ -0,0 +1,118 @@
+#!/bin/bash
+# Pantheon MCP Init — configura os 3 MCP servers em qualquer plataforma
+# Uso: ./scripts/init-pantheon-mcp.sh /caminho/do/projeto [plataforma]
+#   plataforma: opencode (padrão), claude, cursor, windsurf, cline, continue, copilot
+
+set -e
+
+SOURCE_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+TARGET_DIR="${1:-.}"
+PLATFORM="${2:-opencode}"
+
+echo "🚀 Pantheon MCP Init — $PLATFORM"
+echo "   Origem:  $SOURCE_DIR"
+echo "   Destino: $TARGET_DIR"
+echo ""
+
+# 1. Copiar scripts
+echo "📁 Copiando scripts MCP..."
+mkdir -p "$TARGET_DIR/scripts" "$TARGET_DIR/.pantheon/code-mode"
+cp "$SOURCE_DIR/scripts/mcp_resources_server.py" "$TARGET_DIR/scripts/"
+cp "$SOURCE_DIR/scripts/code_mode_server.py" "$TARGET_DIR/scripts/"
+cp "$SOURCE_DIR/scripts/memory_mcp_server.py" "$TARGET_DIR/scripts/"
+cp "$SOURCE_DIR/.pantheon/code-mode/example-sync.sh" "$TARGET_DIR/.pantheon/code-mode/"
+chmod +x "$TARGET_DIR/.pantheon/code-mode/example-sync.sh"
+echo "   ✅ Scripts copiados"
+
+# 2. Virtualenv + dependências
+echo "🐍 Configurando virtualenv..."
+cd "$TARGET_DIR"
+if [ ! -d ".venv" ]; then
+    python3 -m venv .venv
+fi
+source .venv/bin/activate
+pip install -q chromadb>=0.6.0 sentence-transformers fastmcp>=3.4.0 pyyaml 2>/dev/null || \
+  pip install chromadb sentence-transformers fastmcp pyyaml 2>/dev/null
+echo "   ✅ Dependências instaladas"
+
+# 3. Config da plataforma
+echo "📝 Configurando $PLATFORM..."
+
+case "$PLATFORM" in
+  opencode)
+    mkdir -p "$(dirname "$TARGET_DIR/opencode.json")"
+    if [ ! -f "$TARGET_DIR/opencode.json" ]; then
+      cp "$SOURCE_DIR/platform/opencode/opencode.json" "$TARGET_DIR/"
+      echo "   ✅ opencode.json criado"
+    else
+      echo "   ⚠️  opencode.json já existe — adicione os MCPs manualmente"
+    fi
+    ;;
+  claude)
+    if [ ! -f "$TARGET_DIR/.mcp.json" ]; then
+      cp "$SOURCE_DIR/platform/claude/mcp-template.json" "$TARGET_DIR/.mcp.json"
+      echo "   ✅ .mcp.json criado"
+    else
+      echo "   ⚠️  .mcp.json já existe — faça merge manual dos mcpServers"
+    fi
+    ;;
+  cursor)
+    mkdir -p "$TARGET_DIR/.cursor"
+    if [ ! -f "$TARGET_DIR/.cursor/mcp.json" ]; then
+      cp "$SOURCE_DIR/platform/cursor/mcp-template.json" "$TARGET_DIR/.cursor/mcp.json"
+      echo "   ✅ .cursor/mcp.json criado"
+    else
+      echo "   ⚠️  .cursor/mcp.json já existe — faça merge manual"
+    fi
+    ;;
+  windsurf)
+    mkdir -p "$HOME/.codeium/windsurf"
+    if [ ! -f "$HOME/.codeium/windsurf/mcp_config.json" ]; then
+      cp "$SOURCE_DIR/platform/windsurf/mcp-template.json" "$HOME/.codeium/windsurf/mcp_config.json"
+      echo "   ✅ mcp_config.json criado (global)"
+    else
+      echo "   ⚠️  mcp_config.json já existe — faça merge manual"
+    fi
+    ;;
+  cline)
+    echo "   ⚠️  Cline usa settings do VS Code. Copie manualmente:"
+    echo "      $SOURCE_DIR/platform/cline/mcp-template.json"
+    echo "      Para: ~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json"
+    ;;
+  continue)
+    echo "   ⚠️  Continue.dev usa ~/.continue/config.json. Copie manualmente:"
+    echo "      $SOURCE_DIR/platform/continue/mcp-template.json"
+    echo "      (mcpServers é ARRAY — faça merge no seu config.json)"
+    ;;
+  copilot)
+    mkdir -p "$TARGET_DIR/.vscode"
+    if [ ! -f "$TARGET_DIR/.vscode/mcp.json" ]; then
+      cp "$SOURCE_DIR/platform/copilot/mcp-template.json" "$TARGET_DIR/.vscode/mcp.json"
+      echo "   ✅ .vscode/mcp.json criado"
+    else
+      echo "   ⚠️  .vscode/mcp.json já existe — faça merge manual"
+    fi
+    ;;
+  *)
+    echo "   ❌ Plataforma desconhecida: $PLATFORM"
+    echo "   Use: opencode, claude, cursor, windsurf, cline, continue, copilot"
+    exit 1
+    ;;
+esac
+
+# 4. Verificação
+echo ""
+echo "🔍 Verificando instalação..."
+python3 -c "from scripts.mcp_resources_server import mcp; print('   ✅ resources OK')" 2>/dev/null || echo "   ⚠️  Verifique o Python path"
+python3 -c "from scripts.code_mode_server import mcp; print('   ✅ code-mode OK')" 2>/dev/null || echo "   ⚠️  Verifique o Python path"
+.venv/bin/python3 -c "from scripts.memory_mcp_server import mcp; print('   ✅ memory OK')" 2>/dev/null || echo "   ⚠️  Verifique o .venv"
+
+echo ""
+echo "🎉 Pantheon MCP Init concluído para $PLATFORM!"
+echo ""
+echo "Comandos uteis:"
+echo "  Testar:  cd $TARGET_DIR && .venv/bin/python3 -m pytest tests/ -v"
+echo "  Usar:    abra o projeto no $PLATFORM e os MCPs estarão disponíveis"
+echo ""
+echo "Nota: o modelo all-MiniLM-L6-v2 (~80MB) baixa automaticamente"
+echo "no primeiro uso do pantheon-memory."