@simonfestl/husky-cli 1.5.0 → 1.6.1

package/dist/commands/brain.js

@@ -1,6 +1,10 @@
 import { Command } from "commander";
-import { AgentBrain } from "../lib/biz/agent-brain.js";
+import { AgentBrain, AGENT_TYPES, isValidAgentType } from "../lib/biz/agent-brain.js";
 const DEFAULT_AGENT = process.env.HUSKY_AGENT_ID || 'default';
+function createBrain(agentId, agentType) {
+    const validAgentType = isValidAgentType(agentType) ? agentType : undefined;
+    return new AgentBrain({ agentId, agentType: validAgentType });
+}
 export const brainCommand = new Command("brain")
     .description("Agent memory and knowledge management");
 brainCommand
@@ -8,15 +12,17 @@ brainCommand
     .description("Store a memory")
     .option("-a, --agent <id>", "Agent ID", DEFAULT_AGENT)
     .option("-t, --tags <tags>", "Comma-separated tags")
+    .option("--agent-type <type>", `Agent type for database selection (${AGENT_TYPES.join(", ")})`)
     .option("--json", "Output as JSON")
     .action(async (content, options) => {
     try {
-        const brain = new AgentBrain(options.agent);
+        const brain = createBrain(options.agent, options.agentType);
         const tags = options.tags ? options.tags.split(",").map((t) => t.trim()) : [];
-        console.log(`  Storing memory for agent: ${options.agent}...`);
+        const dbInfo = brain.getDatabaseInfo();
+        console.log(`  Storing memory for agent: ${options.agent} (db: ${dbInfo.databaseName})...`);
         const id = await brain.remember(content, tags);
         if (options.json) {
-            console.log(JSON.stringify({ success: true, id, agent: options.agent }));
+            console.log(JSON.stringify({ success: true, id, agent: options.agent, database: dbInfo.databaseName }));
         }
         else {
             console.log(`  ✓ Memory stored: ${id}`);
@@ -33,14 +39,16 @@ brainCommand
     .option("-a, --agent <id>", "Agent ID", DEFAULT_AGENT)
     .option("-l, --limit <num>", "Max results", "5")
     .option("-m, --min-score <score>", "Minimum similarity score (0-1)", "0.5")
+    .option("--agent-type <type>", `Agent type for database selection (${AGENT_TYPES.join(", ")})`)
     .option("--json", "Output as JSON")
     .action(async (query, options) => {
     try {
-        const brain = new AgentBrain(options.agent);
-        console.log(`  Searching memories for: "${query}"...`);
+        const brain = createBrain(options.agent, options.agentType);
+        const dbInfo = brain.getDatabaseInfo();
+        console.log(`  Searching memories for: "${query}" (db: ${dbInfo.databaseName})...`);
         const results = await brain.recall(query, parseInt(options.limit, 10), parseFloat(options.minScore));
         if (options.json) {
-            console.log(JSON.stringify({ success: true, query, results }));
+            console.log(JSON.stringify({ success: true, query, database: dbInfo.databaseName, results }));
             return;
         }
         console.log(`\n  🧠 Memories for "${query}" (${results.length} found)\n`);
@@ -64,16 +72,18 @@ brainCommand
     .description("List recent memories")
     .option("-a, --agent <id>", "Agent ID", DEFAULT_AGENT)
     .option("-l, --limit <num>", "Max results", "20")
+    .option("--agent-type <type>", `Agent type for database selection (${AGENT_TYPES.join(", ")})`)
     .option("--json", "Output as JSON")
     .action(async (options) => {
     try {
-        const brain = new AgentBrain(options.agent);
+        const brain = createBrain(options.agent, options.agentType);
+        const dbInfo = brain.getDatabaseInfo();
         const memories = await brain.listMemories(parseInt(options.limit, 10));
         if (options.json) {
-            console.log(JSON.stringify({ success: true, memories }));
+            console.log(JSON.stringify({ success: true, database: dbInfo.databaseName, memories }));
             return;
         }
-        console.log(`\n  🧠 Memories for agent: ${options.agent} (${memories.length})\n`);
+        console.log(`\n  🧠 Memories for agent: ${options.agent} (db: ${dbInfo.databaseName}) (${memories.length})\n`);
         if (memories.length === 0) {
             console.log("  No memories stored yet.");
             return;
@@ -94,9 +104,10 @@ brainCommand
     .command("forget <id>")
     .description("Delete a memory")
     .option("-a, --agent <id>", "Agent ID", DEFAULT_AGENT)
+    .option("--agent-type <type>", `Agent type for database selection (${AGENT_TYPES.join(", ")})`)
     .action(async (memoryId, options) => {
     try {
-        const brain = new AgentBrain(options.agent);
+        const brain = createBrain(options.agent, options.agentType);
         await brain.forget(memoryId);
         console.log(`  ✓ Memory deleted: ${memoryId}`);
     }
@@ -109,16 +120,18 @@ brainCommand
     .command("stats")
     .description("Show memory statistics")
     .option("-a, --agent <id>", "Agent ID", DEFAULT_AGENT)
+    .option("--agent-type <type>", `Agent type for database selection (${AGENT_TYPES.join(", ")})`)
     .option("--json", "Output as JSON")
     .action(async (options) => {
     try {
-        const brain = new AgentBrain(options.agent);
+        const brain = createBrain(options.agent, options.agentType);
+        const dbInfo = brain.getDatabaseInfo();
         const stats = await brain.stats();
         if (options.json) {
-            console.log(JSON.stringify({ success: true, agent: options.agent, ...stats }));
+            console.log(JSON.stringify({ success: true, agent: options.agent, database: dbInfo.databaseName, ...stats }));
             return;
         }
-        console.log(`\n  🧠 Brain Stats for: ${options.agent}`);
+        console.log(`\n  🧠 Brain Stats for: ${options.agent} (db: ${dbInfo.databaseName})`);
         console.log(`  ────────────────────────────────`);
         console.log(`  Total memories: ${stats.count}`);
         if (Object.keys(stats.tags).length > 0) {
@@ -140,17 +153,19 @@ brainCommand
     .description("Find memories by tags")
     .option("-a, --agent <id>", "Agent ID", DEFAULT_AGENT)
     .option("-l, --limit <num>", "Max results", "10")
+    .option("--agent-type <type>", `Agent type for database selection (${AGENT_TYPES.join(", ")})`)
     .option("--json", "Output as JSON")
     .action(async (tags, options) => {
     try {
-        const brain = new AgentBrain(options.agent);
+        const brain = createBrain(options.agent, options.agentType);
+        const dbInfo = brain.getDatabaseInfo();
         const tagList = tags.split(",").map((t) => t.trim());
         const memories = await brain.recallByTags(tagList, parseInt(options.limit, 10));
         if (options.json) {
-            console.log(JSON.stringify({ success: true, tags: tagList, memories }));
+            console.log(JSON.stringify({ success: true, tags: tagList, database: dbInfo.databaseName, memories }));
             return;
         }
-        console.log(`\n  🏷️  Memories with tags: ${tagList.join(", ")} (${memories.length})\n`);
+        console.log(`\n  🏷️  Memories with tags: ${tagList.join(", ")} (db: ${dbInfo.databaseName}) (${memories.length})\n`);
         if (memories.length === 0) {
             console.log("  No memories found with these tags.");
             return;
@@ -165,4 +180,36 @@ brainCommand
         process.exit(1);
     }
 });
+brainCommand
+    .command("info")
+    .description("Show current brain configuration")
+    .option("-a, --agent <id>", "Agent ID", DEFAULT_AGENT)
+    .option("--agent-type <type>", `Agent type for database selection (${AGENT_TYPES.join(", ")})`)
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    try {
+        const brain = createBrain(options.agent, options.agentType);
+        const dbInfo = brain.getDatabaseInfo();
+        if (options.json) {
+            console.log(JSON.stringify({
+                agent: options.agent,
+                agentType: dbInfo.agentType || null,
+                database: dbInfo.databaseName,
+                availableTypes: AGENT_TYPES
+            }));
+            return;
+        }
+        console.log(`\n  🧠 Brain Configuration`);
+        console.log(`  ────────────────────────────────`);
+        console.log(`  Agent ID: ${options.agent}`);
+        console.log(`  Agent Type: ${dbInfo.agentType || '(not set - using default)'}`);
+        console.log(`  Database: ${dbInfo.databaseName}`);
+        console.log(`\n  Available agent types: ${AGENT_TYPES.join(", ")}`);
+        console.log("");
+    }
+    catch (error) {
+        console.error("Error:", error.message);
+        process.exit(1);
+    }
+});
 export default brainCommand;

package/dist/commands/chat.js

@@ -620,6 +620,228 @@ chatCommand
     await new Promise(() => { });
 });
 // ============================================
+// AGENT QUESTION COMMANDS (prevents supervisor loop)
+// ============================================
+// Agent persona/role icons for Google Chat messages
+const AGENT_PERSONA_ICONS = {
+    support: "🎧",
+    worker: "👷",
+    supervisor: "🎯",
+    reviewer: "🔍",
+    research: "🔬",
+    accounting: "📊",
+    marketing: "📢",
+    developer: "💻",
+    devops: "🔧",
+    default: "🤖",
+};
+chatCommand
+    .command("ask <question>")
+    .description("Ask a question to human via Google Chat (registers conversation for reply routing)")
+    .requiredOption("--space <id>", "Google Chat space ID (e.g., spaces/ABC123)")
+    .option("--agent-id <id>", "Agent ID (default: from env or hostname)")
+    .option("--vm-name <name>", "VM name (default: from env or hostname)")
+    .option("--session <name>", "Tmux session for reply routing", "main")
+    .option("--role <role>", "Agent role/persona (support, worker, supervisor, etc.)")
+    .option("--context <text>", "Additional context for the question")
+    .option("--task-id <id>", "Related task ID")
+    .option("--json", "Output as JSON")
+    .action(async (question, options) => {
+    const config = getConfig();
+    const huskyApiUrl = getHuskyApiUrl();
+    if (!huskyApiUrl) {
+        console.error("Error: API URL not configured. Set husky-api-url or api-url.");
+        process.exit(1);
+    }
+    // Get agent/VM identity
+    const agentId = options.agentId || process.env.HUSKY_AGENT_ID || process.env.HUSKY_WORKER_ID || `agent-${process.pid}`;
+    const vmName = options.vmName || process.env.HUSKY_VM_NAME || process.env.HOSTNAME || "unknown-vm";
+    const tmuxSession = options.session;
+    const agentRole = options.role || process.env.HUSKY_AGENT_TYPE || process.env.HUSKY_AGENT_ROLE || "worker";
+    const taskId = options.taskId || process.env.HUSKY_TASK_ID;
+    // Build formatted message with metadata
+    const icon = AGENT_PERSONA_ICONS[agentRole] || AGENT_PERSONA_ICONS.default;
+    let formattedMessage = `${icon} *Agent Question*\n\n`;
+    formattedMessage += `*From:* ${agentId} (${agentRole})\n`;
+    formattedMessage += `*VM:* ${vmName} / session: ${tmuxSession}\n`;
+    if (taskId) {
+        formattedMessage += `*Task:* ${taskId}\n`;
+    }
+    formattedMessage += `\n---\n\n${question}`;
+    if (options.context) {
+        formattedMessage += `\n\n*Context:* ${options.context}`;
+    }
+    try {
+        // 1. Send message to Google Chat
+        const sendRes = await fetch(`${huskyApiUrl}/api/google-chat/send`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...(config.apiKey ? { "x-api-key": config.apiKey } : {}),
+            },
+            body: JSON.stringify({
+                text: formattedMessage,
+                spaceName: options.space,
+                // Don't specify threadName - let Google Chat create a new thread
+            }),
+        });
+        if (!sendRes.ok) {
+            const error = await sendRes.text();
+            throw new Error(`Failed to send message: ${sendRes.status} - ${error}`);
+        }
+        const sendData = await sendRes.json();
+        const threadName = sendData.threadName || sendData.name;
+        if (!threadName) {
+            console.error("Warning: Could not get thread name from response. Reply routing may not work.");
+        }
+        // 2. Register conversation for reply routing (with full metadata)
+        const convRes = await fetch(`${huskyApiUrl}/api/agent-conversations`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...(config.apiKey ? { "x-api-key": config.apiKey } : {}),
+            },
+            body: JSON.stringify({
+                agentId,
+                vmName,
+                tmuxSession,
+                spaceId: options.space,
+                threadName,
+                question,
+                status: "active",
+                // Additional metadata for routing and context
+                agentRole,
+                taskId: taskId || null,
+                context: options.context || null,
+            }),
+        });
+        let conversationId;
+        if (convRes.ok) {
+            const convData = await convRes.json();
+            conversationId = convData.id;
+        }
+        else {
+            console.error("Warning: Failed to register conversation. Reply may go to supervisor instead.");
+        }
+        if (options.json) {
+            console.log(JSON.stringify({
+                success: true,
+                agentId,
+                agentRole,
+                vmName,
+                tmuxSession,
+                threadName,
+                conversationId,
+                space: options.space,
+                question,
+                taskId: taskId || null,
+            }, null, 2));
+        }
+        else {
+            console.log("✅ Question sent to Google Chat");
+            console.log(`   Agent: ${agentId} (${agentRole})`);
+            console.log(`   VM: ${vmName} / session: ${tmuxSession}`);
+            if (taskId) {
+                console.log(`   Task: ${taskId}`);
+            }
+            console.log(`   Thread: ${threadName || "(unknown)"}`);
+            if (conversationId) {
+                console.log(`   Conversation ID: ${conversationId}`);
+            }
+            console.log("\n   When human replies, it will be routed to your tmux session.");
+            console.log(`   To resolve conversation: husky chat resolve ${conversationId || threadName}`);
+        }
+    }
+    catch (error) {
+        console.error("Error asking question:", error);
+        process.exit(1);
+    }
+});
+chatCommand
+    .command("resolve <conversationId>")
+    .description("Mark a conversation as resolved (stops routing replies to agent)")
+    .action(async (conversationId) => {
+    const config = getConfig();
+    const huskyApiUrl = getHuskyApiUrl();
+    if (!huskyApiUrl) {
+        console.error("Error: API URL not configured. Set husky-api-url or api-url.");
+        process.exit(1);
+    }
+    try {
+        const res = await fetch(`${huskyApiUrl}/api/agent-conversations/${conversationId}`, {
+            method: "PATCH",
+            headers: {
+                "Content-Type": "application/json",
+                ...(config.apiKey ? { "x-api-key": config.apiKey } : {}),
+            },
+            body: JSON.stringify({ status: "resolved" }),
+        });
+        if (!res.ok) {
+            if (res.status === 404) {
+                console.error("Conversation not found.");
+                process.exit(1);
+            }
+            throw new Error(`API error: ${res.status}`);
+        }
+        console.log("✅ Conversation marked as resolved.");
+        console.log("   Future replies in this thread will go to supervisor.");
+    }
+    catch (error) {
+        console.error("Error resolving conversation:", error);
+        process.exit(1);
+    }
+});
+chatCommand
+    .command("conversations")
+    .description("List active agent conversations")
+    .option("--all", "Show all conversations (including resolved)")
+    .option("--agent <id>", "Filter by agent ID")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    const config = getConfig();
+    const huskyApiUrl = getHuskyApiUrl();
+    if (!huskyApiUrl) {
+        console.error("Error: API URL not configured. Set husky-api-url or api-url.");
+        process.exit(1);
+    }
+    try {
+        const params = new URLSearchParams();
+        if (!options.all)
+            params.set("status", "active");
+        if (options.agent)
+            params.set("agentId", options.agent);
+        const res = await fetch(`${huskyApiUrl}/api/agent-conversations?${params}`, {
+            headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+        });
+        if (!res.ok) {
+            throw new Error(`API error: ${res.status}`);
+        }
+        const data = await res.json();
+        if (options.json) {
+            console.log(JSON.stringify(data, null, 2));
+            return;
+        }
+        if (!data.conversations || data.conversations.length === 0) {
+            console.log("No active conversations.");
+            return;
+        }
+        console.log("\n  Agent Conversations");
+        console.log("  " + "─".repeat(60));
+        for (const conv of data.conversations) {
+            const time = new Date(conv.createdAt).toLocaleString();
+            const statusIcon = conv.status === "active" ? "🟢" : "⚪";
+            console.log(`  ${statusIcon} [${conv.id.slice(0, 8)}] ${conv.agentId} @ ${conv.vmName}`);
+            console.log(`     Q: "${conv.question.slice(0, 50)}${conv.question.length > 50 ? "..." : ""}"`);
+            console.log(`     Created: ${time}`);
+            console.log("");
+        }
+    }
+    catch (error) {
+        console.error("Error fetching conversations:", error);
+        process.exit(1);
+    }
+});
+// ============================================
 // REVIEW COMMANDS (kept for backwards compatibility)
 // ============================================
 chatCommand

package/dist/commands/config.d.ts

@@ -23,6 +23,7 @@ interface Config {
     gcpLocation?: string;
     gotessToken?: string;
     gotessBookId?: string;
+    agentType?: string;
 }
 export declare function getConfig(): Config;
 /**

package/dist/commands/config.js

@@ -158,6 +158,7 @@ configCommand
         "gcp-location": "gcpLocation",
         "gotess-token": "gotessToken",
         "gotess-book-id": "gotessBookId",
+        "agent-type": "agentType",
     };
     const configKey = keyMappings[key];
     if (!configKey) {
@@ -170,6 +171,7 @@ configCommand
         console.log("  Qdrant:   qdrant-url, qdrant-api-key");
         console.log("  GCP:      gcp-project-id, gcp-location");
         console.log("  Gotess:   gotess-token, gotess-book-id");
+        console.log("  Brain:    agent-type");
         process.exit(1);
     }
     // Validation for specific keys
@@ -180,6 +182,13 @@ configCommand
             process.exit(1);
         }
     }
+    if (key === "agent-type") {
+        const validTypes = ["support", "claude", "gotess", "supervisor", "worker"];
+        if (!validTypes.includes(value)) {
+            console.error(`Error: Invalid agent type. Must be one of: ${validTypes.join(", ")}`);
+            process.exit(1);
+        }
+    }
     // Set the value
     config[configKey] = value;
     saveConfig(config);

package/dist/commands/vm.js

@@ -3,6 +3,7 @@ import { getConfig } from "./config.js";
 import * as readline from "readline";
 import * as fs from "fs";
 import * as path from "path";
+import { spawnSync } from "child_process";
 import { DEFAULT_AGENT_CONFIGS, generateStartupScript, listDefaultAgentTypes, getDefaultAgentConfig, } from "../lib/agent-templates.js";
 import { requirePermission } from "../lib/permissions.js";
 export const vmCommand = new Command("vm").description("Manage VM sessions");
@@ -747,6 +748,340 @@ vmCommand
     const script = generateStartupScript(options.type, options.huskyUrl, options.huskyKey, options.project);
     console.log(script);
 });
+// ============================================================================
+// VM Monitoring Commands
+// ============================================================================
+// Patterns that indicate an agent is stuck
+const STUCK_PATTERNS = [
+    { pattern: /Do you want to allow|Allow this action|allow this tool/i, reason: "Waiting for allow/deny prompt" },
+    { pattern: /\[y\/n\]|\[Y\/n\]|\(yes\/no\)/i, reason: "Waiting for yes/no confirmation" },
+    { pattern: /Press Enter to continue|press any key/i, reason: "Waiting for user input" },
+    { pattern: /Error:|error:|FAILED|failed/i, reason: "Error detected" },
+    { pattern: /permission denied|Permission denied/i, reason: "Permission denied error" },
+    { pattern: /timed out|timeout|Timeout/i, reason: "Timeout error" },
+];
+// Helper to run SSH command on a VM using spawnSync (no shell injection)
+function sshCommand(vmName, zone, command) {
+    try {
+        const result = spawnSync("gcloud", [
+            "compute", "ssh", vmName,
+            `--zone=${zone}`,
+            `--command=${command}`,
+        ], { encoding: "utf-8", timeout: 30000 });
+        if (result.status !== 0)
+            return null;
+        return result.stdout?.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+// Get tmux sessions on a VM
+function getTmuxSessions(vmName, zone) {
+    const result = sshCommand(vmName, zone, "tmux list-sessions -F '#{session_name}' 2>/dev/null || true");
+    if (!result)
+        return [];
+    return result.split("\n").filter(Boolean);
+}
+// Capture last lines from a tmux session
+function captureTmuxOutput(vmName, zone, sessionName, lines = 50) {
+    return sshCommand(vmName, zone, `tmux capture-pane -t ${sessionName} -p -S -${lines} 2>/dev/null || true`);
+}
+// Check if output matches stuck patterns
+function checkForStuckPatterns(output) {
+    for (const { pattern, reason } of STUCK_PATTERNS) {
+        if (pattern.test(output)) {
+            return { isStuck: true, reason };
+        }
+    }
+    return { isStuck: false };
+}
+// husky vm monitor
+vmCommand
+    .command("monitor")
+    .description("Monitor agent status across running VMs")
+    .option("--vm <name>", "Monitor specific VM only")
+    .option("--watch", "Continuous monitoring (refresh every 10s)")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    const config = ensureConfig();
+    // Get running VMs from API
+    const getRunningVMs = async () => {
+        const url = new URL("/api/vm-sessions", config.apiUrl);
+        url.searchParams.set("vmStatus", "running");
+        const res = await fetch(url.toString(), {
+            headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+        });
+        if (!res.ok) {
+            throw new Error(`API error: ${res.status}`);
+        }
+        const data = await res.json();
+        return data.sessions || [];
+    };
+    const monitorVMs = async () => {
+        let sessions;
+        try {
+            sessions = await getRunningVMs();
+        }
+        catch (error) {
+            console.error("Error fetching VMs:", error);
+            return [];
+        }
+        // Filter by VM name if specified
+        if (options.vm) {
+            sessions = sessions.filter((s) => s.vmName === options.vm || s.name === options.vm || s.id === options.vm);
+        }
+        if (sessions.length === 0) {
+            console.log("\n  No running VMs found.");
+            return [];
+        }
+        const results = [];
+        for (const session of sessions) {
+            const vmStatus = {
+                vmName: session.vmName,
+                zone: session.vmZone,
+                ip: session.vmIpAddress,
+                sessions: [],
+                isStuck: false,
+            };
+            // Get tmux sessions on this VM
+            const tmuxSessions = getTmuxSessions(session.vmName, session.vmZone);
+            if (tmuxSessions.length === 0) {
+                vmStatus.sessions.push({
+                    sessionName: "(none)",
+                    lastOutput: "No tmux sessions running",
+                    isStuck: false,
+                });
+            }
+            else {
+                for (const tmuxSession of tmuxSessions) {
+                    const output = captureTmuxOutput(session.vmName, session.vmZone, tmuxSession) || "";
+                    const stuckCheck = checkForStuckPatterns(output);
+                    const sessionStatus = {
+                        sessionName: tmuxSession,
+                        lastOutput: output.split("\n").slice(-10).join("\n"),
+                        isStuck: stuckCheck.isStuck,
+                        stuckReason: stuckCheck.reason,
+                    };
+                    vmStatus.sessions.push(sessionStatus);
+                    if (stuckCheck.isStuck) {
+                        vmStatus.isStuck = true;
+                        vmStatus.stuckReason = `${tmuxSession}: ${stuckCheck.reason}`;
+                    }
+                }
+            }
+            results.push(vmStatus);
+        }
+        return results;
+    };
+    // Initial check
+    const results = await monitorVMs();
+    if (options.json) {
+        console.log(JSON.stringify(results, null, 2));
+        if (!options.watch)
+            return;
+    }
+    else {
+        printMonitorResults(results);
+    }
+    // Watch mode
+    if (options.watch) {
+        console.log("\n--- Monitoring (Ctrl+C to stop, refreshing every 10s) ---\n");
+        const interval = setInterval(async () => {
+            const newResults = await monitorVMs();
+            if (options.json) {
+                console.log(JSON.stringify(newResults, null, 2));
+            }
+            else {
+                console.log("\x1b[2J\x1b[H"); // Clear screen
+                console.log(`VM Monitor - ${new Date().toLocaleTimeString()}`);
+                printMonitorResults(newResults);
+            }
+        }, 10000);
+        process.on("SIGINT", () => {
+            clearInterval(interval);
+            console.log("\nMonitoring stopped.");
+            process.exit(0);
+        });
+        await new Promise(() => { });
+    }
+});
+// husky vm unstuck <vmName>
+vmCommand
+    .command("unstuck <vmName>")
+    .description("Try to unstick an agent by sending input")
+    .option("--session <name>", "Target specific tmux session", "main")
+    .option("--action <action>", "Action to send (see --list-actions)", "enter")
+    .option("--zone <zone>", "GCP zone", "europe-west1-b")
+    .option("--text <text>", "Send custom text (use with --action custom)")
+    .option("--list-actions", "Show all available actions")
+    .option("--json", "Output as JSON")
+    .action(async (vmName, options) => {
+    // All available actions for different AI agents
+    const actionKeys = {
+        // Basic actions
+        enter: "Enter",
+        yes: "y Enter",
+        no: "n Enter",
+        // Claude Code / OpenCode prompts
+        allow: "y Enter", // Allow single action
+        deny: "n Enter", // Deny action
+        "allow-all": "a Enter", // Allow all (OpenCode)
+        a: "a Enter", // Shorthand for allow-all
+        // Numbered menu selections (common in OpenCode)
+        "1": "1 Enter",
+        "2": "2 Enter",
+        "3": "3 Enter",
+        "4": "4 Enter",
+        "5": "5 Enter",
+        // Common responses
+        skip: "s Enter", // Skip
+        cancel: "Escape", // Cancel/escape
+        quit: "q Enter", // Quit
+        continue: "c Enter", // Continue
+        retry: "r Enter", // Retry
+        // Custom text (use with --text)
+        custom: "",
+    };
+    // Show available actions
+    if (options.listActions) {
+        console.log("\n  Available unstuck actions:\n");
+        console.log("  Basic:");
+        console.log("    enter        - Press Enter");
+        console.log("    yes / y      - Send 'y' + Enter");
+        console.log("    no / n       - Send 'n' + Enter");
+        console.log("\n  AI Agent Prompts:");
+        console.log("    allow        - Allow action (y + Enter)");
+        console.log("    deny         - Deny action (n + Enter)");
+        console.log("    allow-all/a  - Allow all (a + Enter) - OpenCode");
+        console.log("\n  Menu Selections:");
+        console.log("    1, 2, 3, 4, 5 - Send number + Enter");
+        console.log("\n  Other:");
+        console.log("    skip         - Skip (s + Enter)");
+        console.log("    cancel       - Escape key");
+        console.log("    quit         - Quit (q + Enter)");
+        console.log("    continue     - Continue (c + Enter)");
+        console.log("    retry        - Retry (r + Enter)");
+        console.log("    custom       - Use with --text to send custom input");
+        console.log("\n  Examples:");
+        console.log("    husky vm unstuck supervisor --action allow-all");
+        console.log("    husky vm unstuck worker-1 --action 2");
+        console.log('    husky vm unstuck support --action custom --text "my response"');
+        console.log("");
+        return;
+    }
+    // Handle custom text action
+    let keys;
+    if (options.action === "custom") {
+        if (!options.text) {
+            console.error("Error: --text is required when using --action custom");
+            process.exit(1);
+        }
+        // Escape special characters for tmux send-keys
+        const escapedText = options.text.replace(/"/g, '\\"').replace(/'/g, "\\'");
+        keys = `"${escapedText}" Enter`;
+    }
+    else {
+        keys = actionKeys[options.action] || "Enter";
+        if (!actionKeys[options.action]) {
+            console.warn(`Warning: Unknown action "${options.action}", sending Enter`);
+        }
+    }
+    console.log(`Sending "${options.action}" to ${vmName}:${options.session}...`);
+    try {
+        // First check if session exists
+        const sessions = getTmuxSessions(vmName, options.zone);
+        if (!sessions.includes(options.session)) {
+            console.error(`Error: Session "${options.session}" not found on ${vmName}`);
+            console.log(`Available sessions: ${sessions.join(", ") || "(none)"}`);
+            process.exit(1);
+        }
+        // Send keys to tmux session
+        const result = spawnSync("gcloud", [
+            "compute", "ssh", vmName,
+            `--zone=${options.zone}`,
+            `--command=tmux send-keys -t ${options.session} ${keys}`,
+        ], { encoding: "utf-8", timeout: 30000 });
+        if (result.status !== 0) {
+            throw new Error(result.stderr || "Failed to send keys");
+        }
+        // Wait a moment and capture output
+        await new Promise((resolve) => setTimeout(resolve, 2000));
+        const output = captureTmuxOutput(vmName, options.zone, options.session, 20);
+        if (options.json) {
+            console.log(JSON.stringify({
+                success: true,
+                action: options.action,
+                vmName,
+                session: options.session,
+                lastOutput: output?.split("\n").slice(-10).join("\n"),
+            }, null, 2));
+        }
+        else {
+            console.log(`\nAction sent successfully!`);
+            console.log(`\nLast output from ${options.session}:`);
+            console.log("---");
+            console.log(output?.split("\n").slice(-10).join("\n") || "(no output)");
+            console.log("---");
+        }
+    }
+    catch (error) {
+        console.error("Error:", error);
+        process.exit(1);
+    }
+});
+// husky vm ssh <vmName>
+vmCommand
+    .command("ssh <vmName>")
+    .description("SSH into a VM (opens interactive shell)")
+    .option("--zone <zone>", "GCP zone", "europe-west1-b")
+    .option("--command <cmd>", "Run command instead of interactive shell")
+    .action(async (vmName, options) => {
+    if (options.command) {
+        const result = sshCommand(vmName, options.zone, options.command);
+        if (result !== null) {
+            console.log(result);
+        }
+        else {
+            console.error("Failed to execute command");
+            process.exit(1);
+        }
+    }
+    else {
+        // Interactive SSH
+        spawnSync("gcloud", ["compute", "ssh", vmName, `--zone=${options.zone}`], {
+            stdio: "inherit",
+        });
+    }
+});
+function printMonitorResults(results) {
+    console.log("\n  VM MONITOR STATUS");
+    console.log("  " + "=".repeat(80));
+    for (const vm of results) {
+        const stuckIndicator = vm.isStuck ? " [STUCK]" : "";
+        console.log(`\n  ${vm.vmName}${stuckIndicator}`);
+        console.log(`  Zone: ${vm.zone} | IP: ${vm.ip || "N/A"}`);
+        console.log("  " + "-".repeat(60));
+        for (const session of vm.sessions) {
+            const sessionStuck = session.isStuck ? ` <- STUCK: ${session.stuckReason}` : "";
+            console.log(`\n  [${session.sessionName}]${sessionStuck}`);
+            const lines = session.lastOutput.split("\n").slice(-5);
+            for (const line of lines) {
+                console.log(`    ${line.substring(0, 76)}`);
+            }
+        }
+    }
+    const stuckVMs = results.filter((r) => r.isStuck);
+    if (stuckVMs.length > 0) {
+        console.log("\n  " + "=".repeat(80));
+        console.log(`  WARNING: ${stuckVMs.length} VM(s) appear stuck:`);
+        for (const vm of stuckVMs) {
+            console.log(`    - ${vm.vmName}: ${vm.stuckReason}`);
+        }
+        console.log(`\n  To unstick, run: husky vm unstuck <vmName> --action allow`);
+    }
+    console.log("");
+}
 // Print helpers
 function printVMSessions(sessions, stats) {
     if (sessions.length === 0) {

package/dist/commands/worker.js

@@ -9,9 +9,28 @@ workerCommand
     .description("Show current worker identity")
     .option("--json", "Output as JSON")
     .action(async (options) => {
+    const config = getConfig();
     const identity = getWorkerIdentity();
+    // Fetch role from API
+    let role = "unknown";
+    let permissions = [];
+    if (config.apiUrl && config.apiKey) {
+        try {
+            const res = await fetch(`${config.apiUrl}/api/auth/whoami`, {
+                headers: { "x-api-key": config.apiKey },
+            });
+            if (res.ok) {
+                const data = await res.json();
+                role = data.role || "unknown";
+                permissions = data.permissions || [];
+            }
+        }
+        catch {
+            // Silently fail - role will show as "unknown"
+        }
+    }
     if (options.json) {
-        console.log(JSON.stringify(identity, null, 2));
+        console.log(JSON.stringify({ ...identity, role, permissions }, null, 2));
     }
     else {
         console.log("\n  Worker Identity");
@@ -22,6 +41,11 @@ workerCommand
         console.log(`  User:     ${identity.username}`);
         console.log(`  Platform: ${identity.platform}`);
         console.log(`  Version:  ${identity.agentVersion}`);
+        console.log("  " + "─".repeat(40));
+        console.log(`  Role:     ${role}`);
+        if (permissions.length > 0) {
+            console.log(`  Perms:    ${permissions.join(", ")}`);
+        }
         console.log("");
     }
 });

package/dist/lib/biz/agent-brain.d.ts

@@ -1,3 +1,5 @@
+export declare const AGENT_TYPES: readonly ["support", "claude", "gotess", "supervisor", "worker"];
+export type AgentType = typeof AGENT_TYPES[number];
 export interface Memory {
     id: string;
     agent: string;
@@ -12,12 +14,26 @@ export interface RecallResult {
     memory: Memory;
     score: number;
 }
+export interface AgentBrainOptions {
+    agentId: string;
+    agentType?: AgentType;
+    projectId?: string;
+}
+export declare function isValidAgentType(value: string | undefined): value is AgentType;
+export declare function getAgentType(): AgentType | undefined;
+export declare function getDatabaseName(agentType?: AgentType): string;
 export declare class AgentBrain {
     private db;
     private embeddings;
     private agentId;
+    private agentType?;
     private collectionPath;
-    constructor(agentId: string, projectId?: string);
+    private databaseName;
+    constructor(agentIdOrOptions: string | AgentBrainOptions, projectId?: string);
+    getDatabaseInfo(): {
+        agentType?: AgentType;
+        databaseName: string;
+    };
     remember(content: string, tags?: string[], metadata?: Record<string, unknown>): Promise<string>;
     recall(query: string, limit?: number, minScore?: number): Promise<RecallResult[]>;
     recallByTags(tags: string[], limit?: number): Promise<Memory[]>;

package/dist/lib/biz/agent-brain.js

@@ -3,24 +3,85 @@ import { getFirestore, Timestamp } from 'firebase-admin/firestore';
 import { EmbeddingService } from './embeddings.js';
 import { getConfig } from '../../commands/config.js';
 const BRAIN_COLLECTION = 'agent_brains';
+const DEFAULT_DATABASE = '(default)';
+export const AGENT_TYPES = ['support', 'claude', 'gotess', 'supervisor', 'worker'];
+const AGENT_DB_MAP = {
+    support: 'support-brain-db',
+    claude: 'claude-brain-db',
+    gotess: 'gotess-brain-db',
+    supervisor: 'supervisor-brain-db',
+    worker: 'worker-brain-db',
+};
+const firestoreCache = new Map();
+let firebaseInitialized = false;
+export function isValidAgentType(value) {
+    return value !== undefined && AGENT_TYPES.includes(value);
+}
+export function getAgentType() {
+    const envType = process.env.HUSKY_AGENT_TYPE;
+    if (isValidAgentType(envType)) {
+        return envType;
+    }
+    const config = getConfig();
+    const configType = config.agentType;
+    if (isValidAgentType(configType)) {
+        return configType;
+    }
+    return undefined;
+}
+export function getDatabaseName(agentType) {
+    if (!agentType) {
+        return DEFAULT_DATABASE;
+    }
+    return AGENT_DB_MAP[agentType];
+}
 export class AgentBrain {
     db;
     embeddings;
     agentId;
+    agentType;
     collectionPath;
-    constructor(agentId, projectId) {
-        this.agentId = agentId;
+    databaseName;
+    constructor(agentIdOrOptions, projectId) {
+        let options;
+        if (typeof agentIdOrOptions === 'string') {
+            options = { agentId: agentIdOrOptions, projectId };
+        }
+        else {
+            options = agentIdOrOptions;
+        }
         const config = getConfig();
-        const gcpProject = projectId || config.gcpProjectId || process.env.GOOGLE_CLOUD_PROJECT || 'tigerv0';
-        if (getApps().length === 0) {
+        this.agentId = options.agentId;
+        this.agentType = options.agentType || getAgentType();
+        this.databaseName = getDatabaseName(this.agentType);
+        const gcpProject = options.projectId || config.gcpProjectId || process.env.GOOGLE_CLOUD_PROJECT || 'tigerv0';
+        if (!firebaseInitialized && getApps().length === 0) {
             initializeApp({ projectId: gcpProject });
+            firebaseInitialized = true;
         }
-        this.db = getFirestore();
+        const cacheKey = `${gcpProject}:${this.databaseName}`;
+        let db = firestoreCache.get(cacheKey);
+        if (!db) {
+            if (this.databaseName === DEFAULT_DATABASE) {
+                db = getFirestore();
+            }
+            else {
+                db = getFirestore(this.databaseName);
+            }
+            firestoreCache.set(cacheKey, db);
+        }
+        this.db = db;
         this.embeddings = new EmbeddingService({
             projectId: gcpProject,
             location: config.gcpLocation || 'europe-west1'
         });
-        this.collectionPath = `${BRAIN_COLLECTION}/${agentId}/memories`;
+        this.collectionPath = `${BRAIN_COLLECTION}/${this.agentId}/memories`;
+    }
+    getDatabaseInfo() {
+        return {
+            agentType: this.agentType,
+            databaseName: this.databaseName,
+        };
     }
     async remember(content, tags = [], metadata) {
         const embedding = await this.embeddings.embed(content);
@@ -65,6 +126,9 @@ export class AgentBrain {
             .slice(0, limit);
     }
     async recallByTags(tags, limit = 10) {
+        if (tags.length === 0) {
+            return [];
+        }
         const snapshot = await this.db
             .collection(this.collectionPath)
             .where('tags', 'array-contains-any', tags)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simonfestl/husky-cli",
-  "version": "1.5.0",
+  "version": "1.6.1",
   "description": "CLI for Huskyv0 Task Orchestration with Claude Agent SDK",
   "type": "module",
   "bin": {