@simonfestl/husky-cli 1.6.5 → 1.8.2

package/dist/commands/e2e.js

@@ -60,6 +60,21 @@ function uploadToGCS(localPath, gcsPath) {
     console.error("GCS upload failed:", result.stderr);
     return { success: false, url: "" };
 }
+// Helper: Fetch secret from GCP Secret Manager
+async function fetchSecret(secretName) {
+    const result = runCommand("gcloud", [
+        "secrets", "versions", "access", "latest",
+        "--secret", secretName,
+    ]);
+    if (!result.success) {
+        throw new Error(`Failed to fetch secret ${secretName}: ${result.stderr}`);
+    }
+    return result.stdout.trim();
+}
+// Helper: Sleep function
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
 // husky e2e run <task-id>
 e2eCommand
     .command("run <taskId>")
@@ -69,16 +84,48 @@ e2eCommand
     .option("--browser <browser>", "Browser to use (chromium, firefox, webkit)", "chromium")
     .option("--timeout <ms>", "Test timeout in milliseconds", "60000")
     .option("--output <dir>", "Output directory for results")
+    .option("--retries <count>", "Number of retries for failed tests", "0")
+    .option("--secret <names...>", "Secrets to fetch from GCP Secret Manager")
+    .option("--env <values...>", "Environment variables (KEY=value)")
     .option("--json", "Output as JSON")
     .action(async (taskId, options) => {
-    requireAnyPermission(["task:e2e", "deploy:sandbox", "e2e:*"]);
+    requireAnyPermission(["task:e2e_pass", "deploy:sandbox", "deploy:*"]);
     const config = ensureConfig();
     const timestamp = generateTimestamp();
     const outputDir = options.output || `/tmp/e2e-${taskId}-${timestamp}`;
+    const maxRetries = parseInt(options.retries, 10);
+    // Inject secrets from GCP Secret Manager
+    if (options.secret && options.secret.length > 0) {
+        console.log(`\n  Loading secrets from GCP...`);
+        for (const secretName of options.secret) {
+            try {
+                const value = await fetchSecret(secretName);
+                process.env[secretName] = value;
+                console.log(`  ✓ ${secretName} loaded`);
+            }
+            catch (error) {
+                console.error(`  ✗ Failed to load ${secretName}:`, error.message);
+                process.exit(1);
+            }
+        }
+    }
+    // Inject environment variables
+    if (options.env && options.env.length > 0) {
+        console.log(`\n  Setting environment variables...`);
+        for (const envPair of options.env) {
+            const [key, ...valueParts] = envPair.split("=");
+            const value = valueParts.join("=");
+            process.env[key] = value;
+            console.log(`  ✓ ${key} set`);
+        }
+    }
     console.log(`\n  E2E Tests for Task: ${taskId}\n`);
     console.log(`  Output directory: ${outputDir}`);
     console.log(`  Browser: ${options.browser}`);
     console.log(`  Headless: ${!options.headed}`);
+    if (maxRetries > 0) {
+        console.log(`  Retries: ${maxRetries}`);
+    }
     console.log("");
     // Create output directory
     if (!fs.existsSync(outputDir)) {
@@ -129,9 +176,28 @@ e2eCommand
     if (options.browser) {
         playwrightArgs.push(`--project=${options.browser}`);
     }
-    const result = runCommand("npx", ["playwright", ...playwrightArgs], {
-        timeout: parseInt(options.timeout, 10) * 2, // Allow 2x timeout for test suite
-    });
+    // Run tests with retry logic
+    let result = { stdout: "", stderr: "", success: false };
+    let attempts = 0;
+    while (attempts <= maxRetries) {
+        attempts++;
+        if (attempts > 1) {
+            console.log(`\n  Retry ${attempts - 1}/${maxRetries}...\n`);
+            await sleep(5000); // Wait 5 seconds before retry
+        }
+        result = runCommand("npx", ["playwright", ...playwrightArgs], {
+            timeout: parseInt(options.timeout, 10) * 2, // Allow 2x timeout for test suite
+        });
+        if (result.success) {
+            break;
+        }
+        // Capture failure screenshot on last attempt
+        if (attempts > maxRetries) {
+            console.log("  Capturing failure screenshot...");
+            const failScreenshot = path.join(outputDir, `failure-${timestamp}.png`);
+            // Note: Playwright already captures screenshots on failure with --screenshot=on
+        }
+    }
     const testResult = {
         taskId,
         taskName,
@@ -183,7 +249,7 @@ e2eCommand
     .option("--video", "Record video of the session")
     .option("--json", "Output as JSON")
     .action(async (url, options) => {
-    requireAnyPermission(["task:e2e", "deploy:sandbox", "e2e:*"]);
+    requireAnyPermission(["task:e2e_pass", "deploy:sandbox", "deploy:*"]);
     const timestamp = generateTimestamp();
     const outputFile = options.output || `/tmp/e2e-recording-${timestamp}.ts`;
     const videoDir = `/tmp/e2e-video-${timestamp}`;
@@ -260,7 +326,7 @@ e2eCommand
     .option("--type <type>", "File type (screenshot, video, recording, report)", "file")
     .option("--json", "Output as JSON")
     .action(async (file, options) => {
-    requireAnyPermission(["task:e2e", "deploy:sandbox", "e2e:*"]);
+    requireAnyPermission(["task:e2e_pass", "deploy:sandbox", "deploy:*"]);
     if (!fs.existsSync(file)) {
         console.error(`Error: File not found: ${file}`);
         process.exit(1);
@@ -312,7 +378,7 @@ e2eCommand
     .option("--upload", "Upload screenshot to GCS")
     .option("--json", "Output as JSON")
     .action(async (url, options) => {
-    requireAnyPermission(["task:e2e", "deploy:sandbox", "e2e:*"]);
+    requireAnyPermission(["task:e2e_pass", "deploy:sandbox", "deploy:*"]);
     const timestamp = generateTimestamp();
     const defaultFilename = `screenshot-${timestamp}.png`;
     const outputFile = options.output || `/tmp/${defaultFilename}`;
@@ -415,7 +481,7 @@ e2eCommand
     .option("--limit <n>", "Limit number of results", "20")
     .option("--json", "Output as JSON")
     .action(async (options) => {
-    requireAnyPermission(["task:e2e", "deploy:sandbox", "e2e:*"]);
+    requireAnyPermission(["task:e2e_pass", "deploy:sandbox", "deploy:*"]);
     let gcsPath = `gs://${GCS_BUCKET}/e2e/`;
     if (options.task) {
         gcsPath += `${options.task}/`;
@@ -483,7 +549,7 @@ e2eCommand
     .option("--older-than <days>", "Remove artifacts older than N days", "7")
     .option("--dry-run", "Show what would be deleted without deleting")
     .action(async (options) => {
-    requireAnyPermission(["task:e2e", "deploy:sandbox", "e2e:*"]);
+    requireAnyPermission(["task:e2e_pass", "deploy:sandbox", "deploy:*"]);
     console.log(`\n  Cleaning E2E Artifacts\n`);
     const tmpDir = "/tmp";
     const e2ePatterns = ["e2e-", "screenshot-", "recording-"];
@@ -526,3 +592,289 @@ e2eCommand
     console.log(`  ${options.dryRun ? "Would clean" : "Cleaned"}: ${cleaned} items (${(totalSize / 1024 / 1024).toFixed(2)} MB)`);
     console.log("");
 });
+// husky e2e inbox - List E2E inbox messages
+e2eCommand
+    .command("inbox")
+    .description("List E2E inbox messages from API")
+    .option("--status <status>", "Filter by status (pending, running, completed, failed)")
+    .option("--task <taskId>", "Filter by task ID")
+    .option("--limit <n>", "Limit number of results", "50")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    requireAnyPermission(["task:e2e_pass", "deploy:sandbox", "deploy:*"]);
+    const config = ensureConfig();
+    const params = new URLSearchParams();
+    if (options.status)
+        params.set("status", options.status);
+    if (options.task)
+        params.set("taskId", options.task);
+    if (options.limit)
+        params.set("limit", options.limit);
+    const url = `${config.apiUrl}/api/e2e/inbox?${params.toString()}`;
+    try {
+        const res = await fetch(url, {
+            headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+        });
+        if (!res.ok) {
+            console.error(`Error: ${res.status} ${res.statusText}`);
+            process.exit(1);
+        }
+        const inbox = await res.json();
+        if (options.json) {
+            console.log(JSON.stringify(inbox, null, 2));
+            return;
+        }
+        console.log(`\n  E2E Inbox (${inbox.length} items)\n`);
+        if (inbox.length === 0) {
+            console.log("  No E2E inbox messages found.");
+            console.log("");
+            return;
+        }
+        console.log("  " + "-".repeat(80));
+        console.log(`  ${"STATUS".padEnd(12)} ${"TASK ID".padEnd(24)} TITLE`);
+        console.log("  " + "-".repeat(80));
+        for (const item of inbox) {
+            const statusIcons = {
+                pending: "⏳",
+                running: "🔄",
+                completed: "✅",
+                failed: "❌",
+            };
+            const statusIcon = statusIcons[item.status] || "❓";
+            console.log(`  ${statusIcon} ${item.status.padEnd(10)} ${item.taskId.padEnd(24)} ${item.taskTitle?.slice(0, 40) || "N/A"}`);
+        }
+        console.log("");
+    }
+    catch (error) {
+        console.error("Error fetching E2E inbox:", error.message);
+        process.exit(1);
+    }
+});
+// husky e2e watch - Watch E2E inbox for new test requests
+e2eCommand
+    .command("watch")
+    .description("Watch E2E inbox for new test requests")
+    .option("--interval <seconds>", "Poll interval in seconds", "30")
+    .option("--once", "Process inbox once and exit")
+    .action(async (options) => {
+    requireAnyPermission(["task:e2e_pass", "deploy:sandbox", "deploy:*"]);
+    const config = ensureConfig();
+    const interval = parseInt(options.interval, 10) * 1000;
+    console.log(`\n  E2E Inbox Watcher\n`);
+    console.log(`  API: ${config.apiUrl}`);
+    console.log(`  Poll interval: ${options.interval}s`);
+    console.log("");
+    const processInbox = async () => {
+        try {
+            // Fetch E2E inbox from API
+            const res = await fetch(`${config.apiUrl}/api/e2e/inbox`, {
+                headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+            });
+            if (!res.ok) {
+                console.error(`  Error fetching inbox: ${res.status}`);
+                return;
+            }
+            const inbox = await res.json();
+            const pending = inbox.filter((item) => item.status === "pending");
+            if (pending.length === 0) {
+                console.log(`  [${new Date().toISOString()}] No pending E2E requests`);
+                return;
+            }
+            console.log(`  [${new Date().toISOString()}] Found ${pending.length} pending E2E request(s)`);
+            for (const item of pending) {
+                console.log(`\n  Processing: ${item.taskId} - ${item.taskTitle}`);
+                // Update status to running
+                await fetch(`${config.apiUrl}/api/e2e/inbox/${item.id}`, {
+                    method: "PATCH",
+                    headers: {
+                        "Content-Type": "application/json",
+                        ...(config.apiKey ? { "x-api-key": config.apiKey } : {}),
+                    },
+                    body: JSON.stringify({ status: "running" }),
+                });
+                // Run E2E tests for this task
+                const timestamp = generateTimestamp();
+                const outputDir = `/tmp/e2e-${item.taskId}-${timestamp}`;
+                console.log(`  Running tests in ${outputDir}...`);
+                const playwrightArgs = [
+                    "test",
+                    "--reporter=list",
+                    `--output=${outputDir}`,
+                    "--timeout=60000",
+                ];
+                const result = runCommand("npx", ["playwright", ...playwrightArgs], {
+                    timeout: 300000, // 5 min
+                });
+                // Upload results
+                const resultsPath = path.join(outputDir, "results.json");
+                const testResult = {
+                    taskId: item.taskId,
+                    success: result.success,
+                    timestamp,
+                    stdout: result.stdout,
+                    stderr: result.stderr,
+                };
+                if (!fs.existsSync(outputDir)) {
+                    fs.mkdirSync(outputDir, { recursive: true });
+                }
+                fs.writeFileSync(resultsPath, JSON.stringify(testResult, null, 2));
+                const gcsPath = `e2e/${item.taskId}/${timestamp}/results.json`;
+                const uploadResult = uploadToGCS(resultsPath, gcsPath);
+                // Update inbox status
+                await fetch(`${config.apiUrl}/api/e2e/inbox/${item.id}`, {
+                    method: "PATCH",
+                    headers: {
+                        "Content-Type": "application/json",
+                        ...(config.apiKey ? { "x-api-key": config.apiKey } : {}),
+                    },
+                    body: JSON.stringify({
+                        status: result.success ? "completed" : "failed",
+                        completedAt: new Date().toISOString(),
+                        result: {
+                            passed: result.success,
+                            gcsUrl: uploadResult.url,
+                        },
+                    }),
+                });
+                // Update task status via API
+                const taskEndpoint = result.success
+                    ? `${config.apiUrl}/api/tasks/${item.taskId}/e2e/pass`
+                    : `${config.apiUrl}/api/tasks/${item.taskId}/e2e/fail`;
+                await fetch(taskEndpoint, {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json",
+                        ...(config.apiKey ? { "x-api-key": config.apiKey } : {}),
+                    },
+                    body: JSON.stringify({
+                        notes: result.success ? "E2E tests passed" : "E2E tests failed",
+                        testResults: testResult,
+                        screenshots: uploadResult.url ? [uploadResult.url] : [],
+                    }),
+                });
+                console.log(`  ${result.success ? "✓" : "✗"} Task ${item.taskId}: ${result.success ? "PASSED" : "FAILED"}`);
+            }
+        }
+        catch (error) {
+            console.error(`  Error processing inbox:`, error.message);
+        }
+    };
+    // Process once or continuously
+    if (options.once) {
+        await processInbox();
+    }
+    else {
+        console.log("  Watching for E2E requests... (Ctrl+C to stop)\n");
+        while (true) {
+            await processInbox();
+            await sleep(interval);
+        }
+    }
+});
+// husky e2e done <inboxId> - Complete an E2E test request
+e2eCommand
+    .command("done <inboxId>")
+    .description("Complete an E2E test request from inbox")
+    .option("--passed", "Mark test as passed")
+    .option("--failed", "Mark test as failed")
+    .option("--notes <notes>", "Add notes about the test result")
+    .option("--screenshots <urls...>", "Screenshot URLs to attach")
+    .option("--video <url>", "Video URL to attach")
+    .option("--json", "Output as JSON")
+    .action(async (inboxId, options) => {
+    requireAnyPermission(["task:e2e_pass", "deploy:sandbox", "deploy:*"]);
+    const config = ensureConfig();
+    // Determine status
+    let passed;
+    if (options.passed) {
+        passed = true;
+    }
+    else if (options.failed) {
+        passed = false;
+    }
+    if (passed === undefined) {
+        console.error("Error: Must specify --passed or --failed");
+        process.exit(1);
+    }
+    const status = passed ? "completed" : "failed";
+    console.log(`\n  Completing E2E Test Request\n`);
+    console.log(`  Inbox ID: ${inboxId}`);
+    console.log(`  Result: ${passed ? "PASSED" : "FAILED"}`);
+    if (options.notes) {
+        console.log(`  Notes: ${options.notes}`);
+    }
+    console.log("");
+    try {
+        // First, get the inbox item to find the taskId
+        const getRes = await fetch(`${config.apiUrl}/api/e2e/inbox/${inboxId}`, {
+            headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+        });
+        if (!getRes.ok) {
+            console.error(`Error: Inbox item not found (${getRes.status})`);
+            process.exit(1);
+        }
+        const inboxItem = await getRes.json();
+        const taskId = inboxItem.taskId;
+        // Build result object
+        const result = {
+            passed,
+            notes: options.notes,
+            screenshots: options.screenshots || [],
+            video: options.video,
+            completedAt: new Date().toISOString(),
+        };
+        // Update inbox status
+        const updateRes = await fetch(`${config.apiUrl}/api/e2e/inbox/${inboxId}`, {
+            method: "PATCH",
+            headers: {
+                "Content-Type": "application/json",
+                ...(config.apiKey ? { "x-api-key": config.apiKey } : {}),
+            },
+            body: JSON.stringify({
+                status,
+                result,
+            }),
+        });
+        if (!updateRes.ok) {
+            console.error(`Error updating inbox: ${updateRes.status}`);
+            process.exit(1);
+        }
+        // Update task status
+        const taskEndpoint = passed
+            ? `${config.apiUrl}/api/tasks/${taskId}/e2e/pass`
+            : `${config.apiUrl}/api/tasks/${taskId}/e2e/fail`;
+        const taskRes = await fetch(taskEndpoint, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...(config.apiKey ? { "x-api-key": config.apiKey } : {}),
+            },
+            body: JSON.stringify({
+                notes: options.notes || (passed ? "E2E tests passed" : "E2E tests failed"),
+                screenshots: options.screenshots || [],
+                video: options.video,
+            }),
+        });
+        if (!taskRes.ok) {
+            console.warn(`Warning: Could not update task status: ${taskRes.status}`);
+        }
+        if (options.json) {
+            console.log(JSON.stringify({
+                success: true,
+                inboxId,
+                taskId,
+                status,
+                result,
+            }, null, 2));
+        }
+        else {
+            console.log(`  ${passed ? "✓" : "✗"} E2E test request completed`);
+            console.log(`  Task ${taskId} status updated to: ${passed ? "pr_ready" : "e2e_testing"}`);
+            console.log("");
+        }
+    }
+    catch (error) {
+        console.error("Error completing E2E request:", error.message);
+        process.exit(1);
+    }
+});

package/dist/commands/image.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const imageCommand: Command;

package/dist/commands/image.js

@@ -0,0 +1,141 @@
+import { Command } from "commander";
+import { writeFileSync } from "fs";
+import { exec } from "child_process";
+import { promisify } from "util";
+import { getConfig } from "./config.js";
+import { z } from "zod";
+const execAsync = promisify(exec);
+// Input validation schema
+const ImageOptionsSchema = z.object({
+    ar: z.enum(['1:1', '16:9', '9:16', '4:3', '3:4']).default('16:9'),
+    output: z.string().optional(),
+    json: z.boolean().optional()
+});
+export const imageCommand = new Command("image")
+    .description("Image generation with Google Imagen 3 🎨")
+    .argument("<prompt>", "Text description of the image to generate")
+    .option("-o, --output <path>", "Output file path (default: imagen-{timestamp}.png)")
+    .option("--ar <ratio>", "Aspect ratio: 1:1, 16:9, 9:16, 4:3, 3:4 (default: 16:9)", "16:9")
+    .option("--json", "Output metadata as JSON")
+    .action(async (prompt, options) => {
+    try {
+        // Validate prompt
+        if (!prompt || prompt.trim().length === 0) {
+            console.error("Error: Prompt cannot be empty");
+            process.exit(1);
+        }
+        if (prompt.length > 1000) {
+            console.error("Error: Prompt too long (max 1000 characters)");
+            process.exit(1);
+        }
+        // Validate options with Zod
+        const validatedOptions = ImageOptionsSchema.parse(options);
+        await generateImage(prompt.trim(), validatedOptions);
+    }
+    catch (error) {
+        if (error instanceof z.ZodError) {
+            console.error("Error: Invalid options");
+            error.issues.forEach((issue) => {
+                console.error(`  - ${issue.path.join('.')}: ${issue.message}`);
+            });
+            process.exit(1);
+        }
+        const err = error;
+        console.error(`Error: ${err.message}`);
+        if (process.env.DEBUG) {
+            console.error(`Debug: ${err.stack}`);
+        }
+        process.exit(1);
+    }
+});
+/**
+ * Generate image from text prompt using Imagen 3 REST API
+ */
+async function generateImage(prompt, options) {
+    console.log(`🎨 Generating image with Google Imagen 3...`);
+    console.log(`📝 Prompt: "${prompt}"\n`);
+    // Get project ID from config or environment
+    const config = getConfig();
+    const projectId = process.env.GCP_PROJECT_ID || config.gcpProjectId || 'tigerv0';
+    const location = process.env.GCP_LOCATION || config.gcpLocation || 'us-central1';
+    const aspectRatio = options.ar || '16:9';
+    const timestamp = Date.now();
+    const outputPath = options.output || `imagen-${timestamp}.png`;
+    console.log(`⚙️  Aspect Ratio: ${aspectRatio}`);
+    console.log(`⚙️  Project: ${projectId}\n`);
+    console.log(`🔄 Calling Vertex AI Imagen 3...\n`);
+    try {
+        // Get access token using gcloud
+        const { stdout: token } = await execAsync('gcloud auth print-access-token');
+        const accessToken = token.trim();
+        if (!accessToken) {
+            throw new Error('Failed to get access token. Make sure you are authenticated with gcloud.');
+        }
+        // Build Imagen 3 REST API URL
+        const apiUrl = `https://${location}-aiplatform.googleapis.com/v1/projects/${projectId}/locations/${location}/publishers/google/models/imagen-3.0-generate-001:predict`;
+        // Prepare request body (NO string interpolation for security)
+        const requestBody = {
+            instances: [{ prompt }],
+            parameters: {
+                sampleCount: 1,
+                aspectRatio,
+                safetyFilterLevel: "block_some",
+                personGeneration: "allow_adult"
+            }
+        };
+        // Make secure HTTP request using fetch (NO curl command injection)
+        const response = await fetch(apiUrl, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${accessToken}`,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify(requestBody)
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            if (response.status === 401) {
+                throw new Error('Authentication failed. Run: gcloud auth login');
+            }
+            else if (response.status === 403) {
+                throw new Error('Permission denied. Check your GCP project permissions.');
+            }
+            else if (response.status === 429) {
+                throw new Error('API quota exceeded. Please try again later.');
+            }
+            else {
+                throw new Error(`API returned ${response.status}: ${errorText}`);
+            }
+        }
+        const data = await response.json();
+        if (!data.predictions || data.predictions.length === 0) {
+            throw new Error('No image was generated. Try a different prompt.');
+        }
+        // Extract base64 image data and save to file
+        const base64Data = data.predictions[0].bytesBase64Encoded;
+        const buffer = Buffer.from(base64Data, 'base64');
+        writeFileSync(outputPath, buffer);
+        if (options.json) {
+            console.log(JSON.stringify({
+                prompt,
+                file: outputPath,
+                aspectRatio,
+                model: 'imagen-3.0-generate-001',
+                project: projectId,
+                location
+            }, null, 2));
+        }
+        else {
+            console.log(`💾 Saved: ${outputPath}`);
+            console.log(`\n✅ Done! Generated image with Imagen 3 🎨`);
+        }
+    }
+    catch (error) {
+        const err = error;
+        // Don't expose sensitive error details in production
+        if (err.message.includes('gcloud')) {
+            throw err; // User-friendly message already set
+        }
+        throw new Error(`Failed to generate image. ${process.env.DEBUG ? err.message : 'Run with DEBUG=1 for details.'}`);
+    }
+}

package/dist/commands/llm-context.js

@@ -248,16 +248,83 @@ husky biz qdrant search <coll> "<q>"    # Semantic search
 
 ---
 
+## Agent Brain (Lernender Agent)
+
+> [!IMPORTANT]
+> **MANDATORY WORKFLOW für Daily Ops (Support, Worker, etc.)**
+>
+> 1. **VOR der Arbeit**: \`husky brain recall\` - Prüfe ob ähnliches Problem bereits gelöst wurde
+> 2. **NACH der Arbeit**: \`husky brain remember\` - Speichere neue Erkenntnisse
+
+### Role-Based Access
+
+Jeder Agent-Typ hat sein **eigenes Brain** und kann NUR auf eigene Memories zugreifen:
+
+| Agent Type | Brain Collection | Zugriff |
+|------------|------------------|---------|
+| \`support\` | brain_support | Nur Support-Wissen |
+| \`worker\` | brain_worker | Nur Worker-Wissen |
+| \`supervisor\` | brain_supervisor | Nur Supervisor-Wissen |
+| \`claude\` | brain_claude | Nur Claude-Wissen |
+
+Der Agent-Typ wird automatisch aus \`HUSKY_AGENT_TYPE\` oder Config gelesen.
+
+### Commands
+
+\`\`\`bash
+# ZUERST: Bestehendes Wissen abrufen
+husky brain recall "kunde kann nicht einloggen"    # Semantic Search
+husky brain recall "billing problem" --limit 10    # Mehr Ergebnisse
+
+# DANACH: Neues Wissen speichern
+husky brain remember "Login-Problem bei Safari gelöst durch Cache löschen" --tags "login,safari,cache"
+
+# Weitere Commands
+husky brain list                        # Alle eigenen Memories
+husky brain tags "billing,refund"       # Nach Tags suchen
+husky brain stats                       # Statistiken
+husky brain info                        # Aktuelle Konfiguration
+husky brain forget <id>                 # Memory löschen
+\`\`\`
+
+### Workflow Beispiel: Support Agent
+
+\`\`\`bash
+# 1. Neues Ticket kommt rein: "Kunde kann Rechnung nicht herunterladen"
+husky brain recall "rechnung download problem"
+
+# 2. Brain findet ähnliche gelöste Fälle:
+#    [92.3%] PDF-Download funktioniert nicht bei AdBlocker - Lösung: AdBlocker deaktivieren
+#    [87.1%] Rechnung lädt nicht - Browser-Cache war voll
+
+# 3. Agent nutzt Wissen, löst Ticket
+
+# 4. Nach Lösung: Neues Wissen speichern
+husky brain remember "Rechnungs-Download fehlgeschlagen wegen Corporate Firewall - IT musste *.billbee.io freigeben" --tags "billing,download,firewall,corporate"
+\`\`\`
+
+### Best Practices
+
+- **Tags verwenden**: Immer relevante Tags hinzufügen für bessere Auffindbarkeit
+- **Konkret sein**: "Safari Cache löschen löst Login" statt "Login Problem gelöst"
+- **Kontext speichern**: Ursache UND Lösung dokumentieren
+- **Regelmäßig recall**: Vor JEDER neuen Aufgabe prüfen ob Wissen existiert
+
+---
+
 ## Environment Variables
 
 | Variable | Description |
 |----------|-------------|
 | \`HUSKY_ENV\` | Environment prefix (PROD/SANDBOX) |
+| \`HUSKY_AGENT_TYPE\` | Agent type for brain access (support/worker/supervisor/claude) |
+| \`HUSKY_AGENT_ID\` | Unique agent identifier |
 | \`PROD_BILLBEE_API_KEY\` | Billbee API key |
 | \`PROD_ZENDESK_API_TOKEN\` | Zendesk token |
 | \`PROD_SEATABLE_API_TOKEN\` | SeaTable token |
-| \`PROD_QDRANT_URL\` | Qdrant URL |
-| \`PROD_QDRANT_API_KEY\` | Qdrant API key |
+| \`HUSKY_QDRANT_URL\` | Qdrant URL (internal: http://10.132.0.46:6333) |
+
+> **Note:** Qdrant runs on internal VM (VPC). No API key needed - access is secured by VPC isolation.
 
 ---