@simonfestl/husky-cli 1.36.0 → 1.37.0

package/dist/commands/config.js

@@ -41,11 +41,19 @@ function validateApiUrl(url) {
 }
 export function getConfig() {
     try {
-        if (!existsSync(CONFIG_FILE)) {
-            return {};
+        let config = {};
+        if (existsSync(CONFIG_FILE)) {
+            const content = readFileSync(CONFIG_FILE, "utf-8");
+            config = JSON.parse(content);
         }
-        const content = readFileSync(CONFIG_FILE, "utf-8");
-        return JSON.parse(content);
+        // Environment variable overrides (useful for testing)
+        if (process.env.HUSKY_API_URL) {
+            config.apiUrl = process.env.HUSKY_API_URL;
+        }
+        if (process.env.HUSKY_API_KEY) {
+            config.apiKey = process.env.HUSKY_API_KEY;
+        }
+        return config;
     }
     catch {
         return {};

package/dist/commands/insights.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Insights Command - Aggregated Session Analytics
+ *
+ * Part of the self-improving system. Provides commands for:
+ * - Viewing recent errors across sessions
+ * - Listing learnings
+ * - Showing suggested improvements
+ * - Aggregated statistics
+ */
+import { Command } from "commander";
+export declare const insightsCommand: Command;
+export default insightsCommand;

package/dist/commands/insights.js

@@ -0,0 +1,397 @@
+/**
+ * Insights Command - Aggregated Session Analytics
+ *
+ * Part of the self-improving system. Provides commands for:
+ * - Viewing recent errors across sessions
+ * - Listing learnings
+ * - Showing suggested improvements
+ * - Aggregated statistics
+ */
+import { Command } from "commander";
+import { getConfig } from "./config.js";
+import { getApiClient } from "../lib/api-client.js";
+// ============================================================================
+// Helpers
+// ============================================================================
+function truncate(text, maxLen) {
+    if (text.length <= maxLen)
+        return text;
+    return text.slice(0, maxLen - 3) + "...";
+}
+function formatDate(date) {
+    const d = typeof date === "string" ? new Date(date) : date;
+    return d.toLocaleString("de-DE", {
+        day: "2-digit",
+        month: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+    });
+}
+function parseDuration(since) {
+    const match = since.match(/^(\d+)([dhwm])$/);
+    if (!match) {
+        throw new Error("Invalid duration format. Use: 7d, 24h, 2w, 1m");
+    }
+    const value = parseInt(match[1], 10);
+    const unit = match[2];
+    const now = new Date();
+    switch (unit) {
+        case "h":
+            return new Date(now.getTime() - value * 60 * 60 * 1000);
+        case "d":
+            return new Date(now.getTime() - value * 24 * 60 * 60 * 1000);
+        case "w":
+            return new Date(now.getTime() - value * 7 * 24 * 60 * 60 * 1000);
+        case "m":
+            return new Date(now.getTime() - value * 30 * 24 * 60 * 60 * 1000);
+        default:
+            throw new Error("Invalid duration unit. Use: h, d, w, m");
+    }
+}
+function ensureConfig() {
+    const config = getConfig();
+    if (!config.apiUrl) {
+        console.error("Error: API URL not configured. Run: husky config set api-url <url>");
+        process.exit(1);
+    }
+    return config;
+}
+// ============================================================================
+// Command Definition
+// ============================================================================
+export const insightsCommand = new Command("insights")
+    .description("View aggregated session insights and analytics");
+// -------------------------------------------------------------------------
+// Errors
+// -------------------------------------------------------------------------
+insightsCommand
+    .command("errors")
+    .description("List recent errors from analyzed sessions")
+    .option("--since <duration>", "Time window (e.g., 7d, 24h, 2w)", "7d")
+    .option("-l, --limit <num>", "Max errors to show", "20")
+    .option("--type <type>", "Filter by error type")
+    .option("--preventable", "Show only preventable errors")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    ensureConfig();
+    const api = getApiClient();
+    try {
+        // Get analyzed sessions
+        const result = await api.get("/api/sessions?status=analyzed&limit=50");
+        const sinceDate = parseDuration(options.since);
+        const limit = parseInt(options.limit, 10);
+        // Extract errors from summaries
+        const allErrors = [];
+        for (const session of result.sessions) {
+            if (!session.summary?.errors)
+                continue;
+            const analyzedAt = new Date(session.analyzedAt || session.createdAt);
+            if (analyzedAt < sinceDate)
+                continue;
+            for (const error of session.summary.errors) {
+                if (options.type && error.type !== options.type)
+                    continue;
+                if (options.preventable && !error.preventable)
+                    continue;
+                allErrors.push({
+                    sessionId: session.id,
+                    analyzedAt,
+                    error,
+                });
+            }
+        }
+        // Sort by date, most recent first
+        allErrors.sort((a, b) => b.analyzedAt.getTime() - a.analyzedAt.getTime());
+        const errors = allErrors.slice(0, limit);
+        if (options.json) {
+            console.log(JSON.stringify({ success: true, errors, count: errors.length }));
+            return;
+        }
+        console.log(`\n  Errors (last ${options.since}, ${errors.length} found)\n`);
+        if (errors.length === 0) {
+            console.log("  No errors found.");
+            console.log("");
+            return;
+        }
+        // Group by error type
+        const byType = new Map();
+        for (const e of errors) {
+            const list = byType.get(e.error.type) || [];
+            list.push(e);
+            byType.set(e.error.type, list);
+        }
+        for (const [type, typeErrors] of byType) {
+            console.log(`  [${type}] (${typeErrors.length})`);
+            for (const e of typeErrors.slice(0, 5)) {
+                const preventable = e.error.preventable ? " (preventable)" : "";
+                console.log(`    ${formatDate(e.analyzedAt)} | ${truncate(e.error.description, 50)}${preventable}`);
+                console.log(`       ${truncate(e.error.solution, 55)}`);
+            }
+            if (typeErrors.length > 5) {
+                console.log(`    ... and ${typeErrors.length - 5} more`);
+            }
+            console.log("");
+        }
+    }
+    catch (error) {
+        console.error("Error:", error.message);
+        process.exit(1);
+    }
+});
+// -------------------------------------------------------------------------
+// Learnings
+// -------------------------------------------------------------------------
+insightsCommand
+    .command("learnings")
+    .description("List learnings from analyzed sessions")
+    .option("--since <duration>", "Time window (e.g., 7d, 24h, 2w)", "7d")
+    .option("-l, --limit <num>", "Max learnings to show", "20")
+    .option("-t, --tags <tags>", "Filter by tags (comma-separated)")
+    .option("--confidence <level>", "Filter by confidence (low, medium, high)")
+    .option("--saved-only", "Show only learnings saved to brain")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    ensureConfig();
+    const api = getApiClient();
+    try {
+        const result = await api.get("/api/sessions?status=analyzed&limit=50");
+        const sinceDate = parseDuration(options.since);
+        const limit = parseInt(options.limit, 10);
+        const filterTags = options.tags ? options.tags.split(",").map((t) => t.trim()) : [];
+        const allLearnings = [];
+        for (const session of result.sessions) {
+            if (!session.summary?.learnings)
+                continue;
+            const analyzedAt = new Date(session.analyzedAt || session.createdAt);
+            if (analyzedAt < sinceDate)
+                continue;
+            for (const learning of session.summary.learnings) {
+                if (options.confidence && learning.confidence !== options.confidence)
+                    continue;
+                if (options.savedOnly && !learning.savedToBrain)
+                    continue;
+                if (filterTags.length > 0) {
+                    const hasTag = filterTags.some((t) => learning.tags.includes(t));
+                    if (!hasTag)
+                        continue;
+                }
+                allLearnings.push({
+                    sessionId: session.id,
+                    analyzedAt,
+                    learning,
+                });
+            }
+        }
+        allLearnings.sort((a, b) => b.analyzedAt.getTime() - a.analyzedAt.getTime());
+        const learnings = allLearnings.slice(0, limit);
+        if (options.json) {
+            console.log(JSON.stringify({ success: true, learnings, count: learnings.length }));
+            return;
+        }
+        console.log(`\n  Learnings (last ${options.since}, ${learnings.length} found)\n`);
+        if (learnings.length === 0) {
+            console.log("  No learnings found.");
+            console.log("");
+            return;
+        }
+        for (const l of learnings) {
+            const tags = l.learning.tags.length > 0 ? ` [${l.learning.tags.join(", ")}]` : "";
+            const confidence = l.learning.confidence;
+            const saved = l.learning.savedToBrain ? " " : "";
+            console.log(`  ${formatDate(l.analyzedAt)} | [${confidence}]${saved} ${truncate(l.learning.content, 60)}${tags}`);
+        }
+        console.log("");
+    }
+    catch (error) {
+        console.error("Error:", error.message);
+        process.exit(1);
+    }
+});
+// -------------------------------------------------------------------------
+// Improvements
+// -------------------------------------------------------------------------
+insightsCommand
+    .command("improvements")
+    .description("List suggested improvements from analyzed sessions")
+    .option("--since <duration>", "Time window (e.g., 7d, 24h, 2w)", "30d")
+    .option("-l, --limit <num>", "Max improvements to show", "20")
+    .option("--priority <priority>", "Filter by priority (low, medium, high)")
+    .option("--area <area>", "Filter by area")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    ensureConfig();
+    const api = getApiClient();
+    try {
+        const result = await api.get("/api/sessions?status=analyzed&limit=100");
+        const sinceDate = parseDuration(options.since);
+        const limit = parseInt(options.limit, 10);
+        const allImprovements = [];
+        for (const session of result.sessions) {
+            if (!session.summary?.improvements)
+                continue;
+            const analyzedAt = new Date(session.analyzedAt || session.createdAt);
+            if (analyzedAt < sinceDate)
+                continue;
+            for (const improvement of session.summary.improvements) {
+                if (options.priority && improvement.priority !== options.priority)
+                    continue;
+                if (options.area && !improvement.area.toLowerCase().includes(options.area.toLowerCase()))
+                    continue;
+                allImprovements.push({
+                    sessionId: session.id,
+                    analyzedAt,
+                    improvement,
+                });
+            }
+        }
+        // Sort by priority (high first), then by date
+        const priorityOrder = { high: 0, medium: 1, low: 2 };
+        allImprovements.sort((a, b) => {
+            const pA = priorityOrder[a.improvement.priority] ?? 3;
+            const pB = priorityOrder[b.improvement.priority] ?? 3;
+            if (pA !== pB)
+                return pA - pB;
+            return b.analyzedAt.getTime() - a.analyzedAt.getTime();
+        });
+        const improvements = allImprovements.slice(0, limit);
+        if (options.json) {
+            console.log(JSON.stringify({ success: true, improvements, count: improvements.length }));
+            return;
+        }
+        console.log(`\n  Suggested Improvements (last ${options.since}, ${improvements.length} found)\n`);
+        if (improvements.length === 0) {
+            console.log("  No improvements found.");
+            console.log("");
+            return;
+        }
+        // Group by area
+        const byArea = new Map();
+        for (const i of improvements) {
+            const list = byArea.get(i.improvement.area) || [];
+            list.push(i);
+            byArea.set(i.improvement.area, list);
+        }
+        for (const [area, areaImprovements] of byArea) {
+            console.log(`   ${area}`);
+            for (const i of areaImprovements) {
+                const priority = i.improvement.priority.toUpperCase().padEnd(6);
+                console.log(`    [${priority}] ${truncate(i.improvement.suggestion, 55)}`);
+            }
+            console.log("");
+        }
+    }
+    catch (error) {
+        console.error("Error:", error.message);
+        process.exit(1);
+    }
+});
+// -------------------------------------------------------------------------
+// Stats
+// -------------------------------------------------------------------------
+insightsCommand
+    .command("stats")
+    .description("Show aggregated statistics across sessions")
+    .option("--since <duration>", "Time window (e.g., 7d, 24h, 2w)", "7d")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    ensureConfig();
+    const api = getApiClient();
+    try {
+        // Get all sessions (not just analyzed)
+        const result = await api.get("/api/sessions?limit=100");
+        const sinceDate = parseDuration(options.since);
+        // Filter by date
+        const sessions = result.sessions.filter((s) => {
+            const createdAt = new Date(s.createdAt);
+            return createdAt >= sinceDate;
+        });
+        // Calculate stats
+        const totalSessions = sessions.length;
+        const analyzedSessions = sessions.filter((s) => s.status === "analyzed").length;
+        const activeSessions = sessions.filter((s) => s.status === "active").length;
+        let totalLogs = 0;
+        let totalErrors = 0;
+        let totalDurationMinutes = 0;
+        const toolUsage = {};
+        const errorTypes = {};
+        let totalLearnings = 0;
+        let totalImprovements = 0;
+        for (const session of sessions) {
+            totalLogs += session.logCount || 0;
+            totalErrors += session.errorCount || 0;
+            if (session.summary) {
+                totalDurationMinutes += session.summary.stats.durationMinutes || 0;
+                totalLearnings += session.summary.learnings.length;
+                totalImprovements += session.summary.improvements.length;
+                // Aggregate tool usage
+                for (const [tool, count] of Object.entries(session.summary.stats.toolUsage || {})) {
+                    toolUsage[tool] = (toolUsage[tool] || 0) + count;
+                }
+                // Aggregate error types
+                for (const error of session.summary.errors) {
+                    errorTypes[error.type] = (errorTypes[error.type] || 0) + 1;
+                }
+            }
+        }
+        const stats = {
+            period: options.since,
+            totalSessions,
+            analyzedSessions,
+            activeSessions,
+            totalLogs,
+            totalErrors,
+            totalDurationMinutes,
+            totalLearnings,
+            totalImprovements,
+            toolUsage,
+            errorTypes,
+        };
+        if (options.json) {
+            console.log(JSON.stringify({ success: true, stats }));
+            return;
+        }
+        console.log(`\n  Session Stats (last ${options.since})`);
+        console.log(`  ${"".repeat(40)}`);
+        console.log("");
+        console.log(`  Sessions:        ${totalSessions}`);
+        console.log(`    Active:        ${activeSessions}`);
+        console.log(`    Analyzed:      ${analyzedSessions}`);
+        console.log("");
+        console.log(`  Activity:`);
+        console.log(`    Total logs:    ${totalLogs.toLocaleString()}`);
+        console.log(`    Total errors:  ${totalErrors.toLocaleString()}`);
+        console.log(`    Duration:      ${Math.round(totalDurationMinutes / 60)} hours`);
+        console.log("");
+        console.log(`  Analysis:`);
+        console.log(`    Learnings:     ${totalLearnings}`);
+        console.log(`    Improvements:  ${totalImprovements}`);
+        console.log("");
+        // Top tools
+        const sortedTools = Object.entries(toolUsage)
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 5);
+        if (sortedTools.length > 0) {
+            console.log(`  Top Tools:`);
+            for (const [tool, count] of sortedTools) {
+                console.log(`    ${tool.padEnd(20)} ${count.toLocaleString()}`);
+            }
+            console.log("");
+        }
+        // Error types
+        const sortedErrors = Object.entries(errorTypes)
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 5);
+        if (sortedErrors.length > 0) {
+            console.log(`  Error Types:`);
+            for (const [type, count] of sortedErrors) {
+                console.log(`    ${type.padEnd(20)} ${count}`);
+            }
+            console.log("");
+        }
+    }
+    catch (error) {
+        console.error("Error:", error.message);
+        process.exit(1);
+    }
+});
+export default insightsCommand;

package/dist/commands/llm-context.js

@@ -289,6 +289,42 @@ husky brain stats                       # Statistiken
 \`\`\`
 `;
 }
+function getSessionSection() {
+    return `
+---
+
+## Session Logging (Self-Improving System)
+
+> [!NOTE]
+> Sessions werden automatisch geloggt und bei VM-Shutdown exportiert.
+> Analysierte Sessions ermoeglichen semantische Suche nach aehnlichen Problemen/Loesungen.
+
+\`\`\`bash
+# Session Management
+husky session current                   # Zeigt aktuelle Session
+husky session list --limit 10           # Sessions auflisten
+husky session log --tool "Bash" ...     # Tool-Call loggen (via Hook)
+husky session export --to-firestore     # Logs exportieren
+
+# Analyse & Embeddings
+husky session analyze                   # Analyse triggern (async)
+husky session embed                     # Embeddings generieren
+husky session summary                   # Analyse-Summary anzeigen
+
+# Semantische Suche (mit Vector Embeddings)
+husky session search "trigger fehler"   # Nach aehnlichen Problemen suchen
+husky session search "RLS" --type errors      # Nur Fehler
+husky session search "fix" --type learnings   # Nur Learnings
+\`\`\`
+
+### Insights (Aggregierte Analytics)
+\`\`\`bash
+husky insights errors --since 7d        # Fehler der letzten 7 Tage
+husky insights learnings --since 7d     # Learnings anzeigen
+husky insights stats --since 7d         # Aggregierte Statistiken
+\`\`\`
+`;
+}
 function getVMSection() {
     return `
 ---
@@ -428,6 +464,8 @@ export function generateLLMContext(role, permissions) {
     }
     // Brain - always included
     context += getBrainSection(effectiveRole);
+    // Session Logging - always included
+    context += getSessionSection();
     // Tips - always included
     context += getTips();
     return context;

package/dist/commands/session.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Session Command - Agent Session Logging & Analysis
+ *
+ * Part of the self-improving system. Provides commands for:
+ * - Logging tool calls during a session
+ * - Exporting session data before VM shutdown
+ * - Triggering analysis
+ * - Searching for similar problems/solutions
+ */
+import { Command } from "commander";
+export declare const sessionCommand: Command;
+export default sessionCommand;

package/dist/commands/session.js

@@ -0,0 +1,665 @@
+/**
+ * Session Command - Agent Session Logging & Analysis
+ *
+ * Part of the self-improving system. Provides commands for:
+ * - Logging tool calls during a session
+ * - Exporting session data before VM shutdown
+ * - Triggering analysis
+ * - Searching for similar problems/solutions
+ */
+import { Command } from "commander";
+import { getConfig } from "./config.js";
+import { getApiClient } from "../lib/api-client.js";
+import * as fs from "fs";
+import * as path from "path";
+// ============================================================================
+// Helpers
+// ============================================================================
+const DEFAULT_AGENT_ID = process.env.HUSKY_AGENT_ID || "default";
+const DEFAULT_VM_NAME = process.env.HUSKY_VM_NAME || process.env.HOSTNAME || "local";
+// Local session state file for tracking current session
+const SESSION_STATE_FILE = path.join(process.env.HOME || "/tmp", ".husky", "current-session.json");
+function loadLocalState() {
+    try {
+        if (fs.existsSync(SESSION_STATE_FILE)) {
+            return JSON.parse(fs.readFileSync(SESSION_STATE_FILE, "utf-8"));
+        }
+    }
+    catch {
+        // Ignore errors
+    }
+    return null;
+}
+function saveLocalState(state) {
+    const dir = path.dirname(SESSION_STATE_FILE);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    }
+    fs.writeFileSync(SESSION_STATE_FILE, JSON.stringify(state, null, 2), { mode: 0o600 });
+}
+function clearLocalState() {
+    try {
+        if (fs.existsSync(SESSION_STATE_FILE)) {
+            fs.unlinkSync(SESSION_STATE_FILE);
+        }
+    }
+    catch {
+        // Ignore errors
+    }
+}
+function truncate(text, maxLen) {
+    if (text.length <= maxLen)
+        return text;
+    return text.slice(0, maxLen - 3) + "...";
+}
+function formatDate(date) {
+    const d = typeof date === "string" ? new Date(date) : date;
+    return d.toLocaleString("de-DE", {
+        day: "2-digit",
+        month: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+    });
+}
+function ensureConfig() {
+    const config = getConfig();
+    if (!config.apiUrl) {
+        console.error("Error: API URL not configured. Run: husky config set api-url <url>");
+        process.exit(1);
+    }
+    return config;
+}
+// ============================================================================
+// Command Definition
+// ============================================================================
+export const sessionCommand = new Command("session")
+    .description("Agent session logging and analysis (self-improving system)");
+// -------------------------------------------------------------------------
+// Session Management
+// -------------------------------------------------------------------------
+sessionCommand
+    .command("init")
+    .description("Initialize a new session (typically called at VM startup)")
+    .option("--vm-name <name>", "VM name", DEFAULT_VM_NAME)
+    .option("--agent-id <id>", "Agent ID", DEFAULT_AGENT_ID)
+    .option("--agent-name <name>", "Agent display name")
+    .option("--task-id <id>", "Associated task ID")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    ensureConfig();
+    const api = getApiClient();
+    try {
+        const session = await api.post("/api/sessions", {
+            vmName: options.vmName,
+            agentId: options.agentId,
+            agentName: options.agentName,
+            taskId: options.taskId,
+        });
+        // Save local state
+        saveLocalState({
+            sessionId: session.id,
+            vmName: options.vmName,
+            agentId: options.agentId,
+            startedAt: new Date().toISOString(),
+            pendingLogs: [],
+        });
+        // Set environment variable for hooks
+        console.log(`export HUSKY_SESSION_ID="${session.id}"`);
+        if (options.json) {
+            console.log(JSON.stringify({ success: true, session }));
+        }
+        else {
+            console.log(`  Session initialized: ${session.id}`);
+            console.log(`  VM: ${options.vmName}`);
+            console.log(`  Agent: ${options.agentId}`);
+        }
+    }
+    catch (error) {
+        console.error("Error:", error.message);
+        process.exit(1);
+    }
+});
+sessionCommand
+    .command("current")
+    .description("Show current session info")
+    .option("--vm-name <name>", "VM name filter", DEFAULT_VM_NAME)
+    .option("--agent-id <id>", "Agent ID filter")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    // First check local state
+    const localState = loadLocalState();
+    if (localState) {
+        if (options.json) {
+            console.log(JSON.stringify({
+                success: true,
+                source: "local",
+                sessionId: localState.sessionId,
+                vmName: localState.vmName,
+                agentId: localState.agentId,
+                startedAt: localState.startedAt,
+                pendingLogs: localState.pendingLogs.length,
+            }));
+        }
+        else {
+            console.log(`\n  Current Session (local state)`);
+            console.log(`  ID: ${localState.sessionId}`);
+            console.log(`  VM: ${localState.vmName}`);
+            console.log(`  Agent: ${localState.agentId}`);
+            console.log(`  Started: ${formatDate(localState.startedAt)}`);
+            console.log(`  Pending logs: ${localState.pendingLogs.length}`);
+            console.log("");
+        }
+        return;
+    }
+    // Fall back to API
+    ensureConfig();
+    const api = getApiClient();
+    try {
+        const params = new URLSearchParams();
+        if (options.vmName)
+            params.set("vmName", options.vmName);
+        if (options.agentId)
+            params.set("agentId", options.agentId);
+        const result = await api.get(`/api/sessions/current?${params.toString()}`);
+        if (options.json) {
+            console.log(JSON.stringify({ success: true, source: "api", session: result.session }));
+        }
+        else {
+            const s = result.session;
+            console.log(`\n  Current Session`);
+            console.log(`  ID: ${s.id}`);
+            console.log(`  VM: ${s.vmName}`);
+            console.log(`  Agent: ${s.agentId}`);
+            console.log(`  Status: ${s.status}`);
+            console.log(`  Logs: ${s.logCount} (${s.errorCount} errors)`);
+            console.log(`  Started: ${formatDate(s.startedAt)}`);
+            console.log("");
+        }
+    }
+    catch (error) {
+        if (options.json) {
+            console.log(JSON.stringify({ success: false, error: error.message }));
+        }
+        else {
+            console.log("  No active session found");
+        }
+    }
+});
+sessionCommand
+    .command("list")
+    .description("List recent sessions")
+    .option("-s, --status <status>", "Filter by status (active, exported, analyzed)")
+    .option("--vm-name <name>", "Filter by VM name")
+    .option("--agent-id <id>", "Filter by agent ID")
+    .option("-l, --limit <num>", "Max results", "20")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    ensureConfig();
+    const api = getApiClient();
+    try {
+        const params = new URLSearchParams();
+        if (options.status)
+            params.set("status", options.status);
+        if (options.vmName)
+            params.set("vmName", options.vmName);
+        if (options.agentId)
+            params.set("agentId", options.agentId);
+        params.set("limit", options.limit);
+        const result = await api.get(`/api/sessions?${params.toString()}`);
+        if (options.json) {
+            console.log(JSON.stringify({ success: true, sessions: result.sessions }));
+            return;
+        }
+        console.log(`\n  Sessions (${result.sessions.length})\n`);
+        if (result.sessions.length === 0) {
+            console.log("  No sessions found.");
+            return;
+        }
+        for (const s of result.sessions) {
+            const date = formatDate(s.createdAt);
+            const status = s.status.padEnd(10);
+            const logs = `${s.logCount} logs`.padEnd(12);
+            console.log(`  ${date} | ${status} | ${logs} | ${s.vmName}/${s.agentId}`);
+        }
+        console.log("");
+    }
+    catch (error) {
+        console.error("Error:", error.message);
+        process.exit(1);
+    }
+});
+// -------------------------------------------------------------------------
+// Logging
+// -------------------------------------------------------------------------
+sessionCommand
+    .command("log")
+    .description("Add a log entry to current session (for PostToolUse hook)")
+    .option("--session-id <id>", "Session ID (or uses current)")
+    .option("--tool <name>", "Tool name", "unknown")
+    .option("--input <text>", "Tool input (truncated to 1KB)")
+    .option("--output <text>", "Tool output (truncated to 5KB)")
+    .option("--status <status>", "Status: success, error, warning", "success")
+    .option("--error-type <type>", "Error type if status is error")
+    .option("--duration <ms>", "Duration in milliseconds")
+    .option("--buffer", "Buffer locally instead of sending immediately")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    const localState = loadLocalState();
+    const sessionId = options.sessionId || localState?.sessionId || process.env.HUSKY_SESSION_ID;
+    if (!sessionId) {
+        if (options.json) {
+            console.log(JSON.stringify({ success: false, error: "No session ID" }));
+        }
+        else {
+            console.error("Error: No session ID. Run 'husky session init' first.");
+        }
+        process.exit(1);
+    }
+    const logEntry = {
+        tool: options.tool,
+        toolInput: truncate(options.input || "", 1024),
+        toolOutput: truncate(options.output || "", 5120),
+        status: options.status,
+        errorType: options.errorType,
+        duration: options.duration ? parseInt(options.duration, 10) : undefined,
+        timestamp: new Date().toISOString(),
+    };
+    // Buffer mode: store locally
+    if (options.buffer && localState) {
+        localState.pendingLogs.push(logEntry);
+        saveLocalState(localState);
+        if (options.json) {
+            console.log(JSON.stringify({ success: true, buffered: true, pending: localState.pendingLogs.length }));
+        }
+        return;
+    }
+    // Send to API
+    ensureConfig();
+    const api = getApiClient();
+    try {
+        const vmName = localState?.vmName || DEFAULT_VM_NAME;
+        const agentId = localState?.agentId || DEFAULT_AGENT_ID;
+        await api.post(`/api/sessions/${sessionId}/logs`, {
+            vmName,
+            agentId,
+            ...logEntry,
+        });
+        if (options.json) {
+            console.log(JSON.stringify({ success: true, sessionId }));
+        }
+    }
+    catch (error) {
+        // Fail silently in non-json mode (don't disrupt main workflow)
+        if (options.json) {
+            console.log(JSON.stringify({ success: false, error: error.message }));
+        }
+    }
+});
+// -------------------------------------------------------------------------
+// Export (for VM shutdown)
+// -------------------------------------------------------------------------
+sessionCommand
+    .command("export")
+    .description("Export buffered logs to Firestore (for VM shutdown)")
+    .option("--session-id <id>", "Session ID (or uses current)")
+    .option("--to-firestore", "Export to Firestore (default)")
+    .option("--force", "Export even if no pending logs")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    const localState = loadLocalState();
+    const sessionId = options.sessionId || localState?.sessionId || process.env.HUSKY_SESSION_ID;
+    if (!sessionId) {
+        if (options.json) {
+            console.log(JSON.stringify({ success: false, error: "No session ID" }));
+        }
+        else {
+            console.error("Error: No session ID. Run 'husky session init' first.");
+        }
+        process.exit(1);
+    }
+    if (!localState?.pendingLogs.length && !options.force) {
+        if (options.json) {
+            console.log(JSON.stringify({ success: true, logsExported: 0, message: "No pending logs" }));
+        }
+        else {
+            console.log("  No pending logs to export.");
+        }
+        return;
+    }
+    ensureConfig();
+    const api = getApiClient();
+    try {
+        const vmName = localState?.vmName || DEFAULT_VM_NAME;
+        const agentId = localState?.agentId || DEFAULT_AGENT_ID;
+        const logs = (localState?.pendingLogs || []).map((log) => ({
+            vmName,
+            agentId,
+            ...log,
+        }));
+        if (logs.length > 0) {
+            const result = await api.post(`/api/sessions/${sessionId}/export`, { logs });
+            // Clear local state after successful export
+            clearLocalState();
+            if (options.json) {
+                console.log(JSON.stringify(result));
+            }
+            else {
+                console.log(`  Exported ${result.logsImported} logs to session ${sessionId}`);
+            }
+        }
+        else {
+            // Just update status
+            await api.patch(`/api/sessions/${sessionId}`, { status: "exported" });
+            if (options.json) {
+                console.log(JSON.stringify({ success: true, logsExported: 0 }));
+            }
+            else {
+                console.log(`  Session ${sessionId} marked as exported`);
+            }
+        }
+    }
+    catch (error) {
+        console.error("Error:", error.message);
+        process.exit(1);
+    }
+});
+// -------------------------------------------------------------------------
+// Analysis
+// -------------------------------------------------------------------------
+sessionCommand
+    .command("analyze")
+    .description("Trigger session analysis")
+    .option("--session-id <id>", "Session ID (or uses current)")
+    .option("--sync", "Wait for analysis to complete (not recommended)")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    const localState = loadLocalState();
+    const sessionId = options.sessionId || localState?.sessionId || process.env.HUSKY_SESSION_ID;
+    if (!sessionId) {
+        if (options.json) {
+            console.log(JSON.stringify({ success: false, error: "No session ID" }));
+        }
+        else {
+            console.error("Error: No session ID.");
+        }
+        process.exit(1);
+    }
+    ensureConfig();
+    const api = getApiClient();
+    try {
+        const result = await api.post(`/api/sessions/${sessionId}/analyze`, { async: !options.sync });
+        if (options.json) {
+            console.log(JSON.stringify(result));
+        }
+        else {
+            if (result.taskId) {
+                console.log(`  Analysis task created: ${result.taskId}`);
+            }
+            else {
+                console.log(`  ${result.message || "Analysis triggered"}`);
+            }
+        }
+    }
+    catch (error) {
+        console.error("Error:", error.message);
+        process.exit(1);
+    }
+});
+// -------------------------------------------------------------------------
+// Get Logs (for analyzer worker)
+// -------------------------------------------------------------------------
+sessionCommand
+    .command("get-logs")
+    .description("Get logs for a session (for analyzer worker)")
+    .option("--session-id <id>", "Session ID", "")
+    .option("-l, --limit <num>", "Max results", "500")
+    .option("--offset <num>", "Offset", "0")
+    .option("--status <status>", "Filter by status")
+    .option("--json", "Output as JSON")
+    .option("--format <format>", "Output format (json, text)", "text")
+    .action(async (options) => {
+    if (!options.sessionId) {
+        console.error("Error: --session-id is required");
+        process.exit(1);
+    }
+    ensureConfig();
+    const api = getApiClient();
+    try {
+        const params = new URLSearchParams();
+        params.set("limit", options.limit);
+        params.set("offset", options.offset);
+        if (options.status)
+            params.set("status", options.status);
+        const result = await api.get(`/api/sessions/${options.sessionId}/logs?${params.toString()}`);
+        if (options.json || options.format === "json") {
+            console.log(JSON.stringify(result));
+            return;
+        }
+        console.log(`\n  Logs for session ${options.sessionId} (${result.count})\n`);
+        for (const log of result.logs) {
+            const time = formatDate(log.timestamp);
+            const status = log.status === "error" ? "" : log.status === "warning" ? "" : "";
+            console.log(`  ${time} | ${status} ${log.tool.padEnd(20)} | ${truncate(log.toolInput, 50)}`);
+        }
+        console.log("");
+    }
+    catch (error) {
+        console.error("Error:", error.message);
+        process.exit(1);
+    }
+});
+// -------------------------------------------------------------------------
+// Save Summary (for analyzer worker)
+// -------------------------------------------------------------------------
+sessionCommand
+    .command("save-summary")
+    .description("Save analysis summary (for analyzer worker)")
+    .option("--session-id <id>", "Session ID", "")
+    .option("--file <path>", "JSON file with summary data")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    if (!options.sessionId) {
+        console.error("Error: --session-id is required");
+        process.exit(1);
+    }
+    if (!options.file) {
+        console.error("Error: --file is required");
+        process.exit(1);
+    }
+    let summaryData;
+    try {
+        const content = fs.readFileSync(options.file, "utf-8");
+        summaryData = JSON.parse(content);
+    }
+    catch (error) {
+        console.error("Error reading summary file:", error.message);
+        process.exit(1);
+    }
+    ensureConfig();
+    const api = getApiClient();
+    try {
+        const result = await api.post(`/api/sessions/${options.sessionId}/summary`, summaryData);
+        if (options.json) {
+            console.log(JSON.stringify(result));
+        }
+        else {
+            console.log(`  Summary saved for session ${options.sessionId}`);
+            console.log(`  Learnings: ${result.summary.learnings.length}`);
+            console.log(`  Errors: ${result.summary.errors.length}`);
+            console.log(`  Improvements: ${result.summary.improvements.length}`);
+        }
+    }
+    catch (error) {
+        console.error("Error:", error.message);
+        process.exit(1);
+    }
+});
+// -------------------------------------------------------------------------
+// Search
+// -------------------------------------------------------------------------
+sessionCommand
+    .command("search <query>")
+    .description("Search for similar problems/solutions across sessions")
+    .option("--type <type>", "Search type: all, errors, learnings", "all")
+    .option("-l, --limit <num>", "Max results", "10")
+    .option("--json", "Output as JSON")
+    .action(async (query, options) => {
+    ensureConfig();
+    const api = getApiClient();
+    try {
+        const result = await api.post("/api/sessions/search", {
+            query,
+            type: options.type,
+            limit: parseInt(options.limit, 10),
+        });
+        if (options.json) {
+            console.log(JSON.stringify(result));
+            return;
+        }
+        console.log(`\n  Search: "${query}" (${result.count} results)\n`);
+        if (result.results.length === 0) {
+            console.log("  No matching sessions found.");
+            console.log("");
+            return;
+        }
+        for (const r of result.results) {
+            const dateInfo = r.analyzedAt ? formatDate(r.analyzedAt) : "not analyzed";
+            const similarity = r.similarity ? ` ${r.similarity}% match` : "";
+            console.log(`  Session ${r.sessionId.slice(0, 8)}... (${dateInfo})${similarity}`);
+            if (r.match.learnings.length > 0) {
+                for (const l of r.match.learnings.slice(0, 2)) {
+                    console.log(`     ${truncate(l.content, 70)}`);
+                }
+            }
+            if (r.match.errors.length > 0) {
+                for (const e of r.match.errors.slice(0, 2)) {
+                    console.log(`     ${truncate(e.description, 70)}`);
+                }
+            }
+            console.log("");
+        }
+    }
+    catch (error) {
+        console.error("Error:", error.message);
+        process.exit(1);
+    }
+});
+// -------------------------------------------------------------------------
+// Summary
+// -------------------------------------------------------------------------
+sessionCommand
+    .command("summary")
+    .description("Get analysis summary for a session")
+    .option("--session-id <id>", "Session ID (or uses current)")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    const localState = loadLocalState();
+    const sessionId = options.sessionId || localState?.sessionId || process.env.HUSKY_SESSION_ID;
+    if (!sessionId) {
+        console.error("Error: No session ID.");
+        process.exit(1);
+    }
+    ensureConfig();
+    const api = getApiClient();
+    try {
+        const result = await api.get(`/api/sessions/${sessionId}/summary`);
+        if (options.json) {
+            console.log(JSON.stringify(result));
+            return;
+        }
+        const s = result.summary;
+        console.log(`\n  Session Summary: ${sessionId.slice(0, 8)}...`);
+        console.log(`  Analyzed: ${formatDate(s.analyzedAt)} by ${s.analyzedBy}`);
+        console.log("");
+        console.log(`  Stats:`);
+        console.log(`    Total logs: ${s.stats.totalLogs}`);
+        console.log(`    Errors: ${s.stats.errorCount}`);
+        console.log(`    Duration: ${s.stats.durationMinutes} min`);
+        console.log("");
+        if (s.learnings.length > 0) {
+            console.log(`  Learnings (${s.learnings.length}):`);
+            for (const l of s.learnings) {
+                const saved = l.savedToBrain ? " [saved to brain]" : "";
+                console.log(`    - ${truncate(l.content, 70)}${saved}`);
+            }
+            console.log("");
+        }
+        if (s.errors.length > 0) {
+            console.log(`  Errors (${s.errors.length}):`);
+            for (const e of s.errors) {
+                console.log(`    - [${e.type}] ${truncate(e.description, 60)}`);
+                console.log(`       ${truncate(e.solution, 60)}`);
+            }
+            console.log("");
+        }
+        if (s.improvements.length > 0) {
+            console.log(`  Improvements (${s.improvements.length}):`);
+            for (const i of s.improvements) {
+                console.log(`    - [${i.priority}] ${i.area}: ${truncate(i.suggestion, 50)}`);
+            }
+            console.log("");
+        }
+    }
+    catch (error) {
+        if (error.message.includes("not found")) {
+            console.log("  Session has not been analyzed yet.");
+            console.log("  Run: husky session analyze --session-id " + sessionId);
+        }
+        else {
+            console.error("Error:", error.message);
+            process.exit(1);
+        }
+    }
+});
+// -------------------------------------------------------------------------
+// Embed
+// -------------------------------------------------------------------------
+sessionCommand
+    .command("embed")
+    .description("Generate vector embeddings for a session (requires analysis)")
+    .option("--session-id <id>", "Session ID (or uses current)")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    const localState = loadLocalState();
+    const sessionId = options.sessionId || localState?.sessionId || process.env.HUSKY_SESSION_ID;
+    if (!sessionId) {
+        console.error("Error: No session ID. Use --session-id or set HUSKY_SESSION_ID.");
+        process.exit(1);
+    }
+    ensureConfig();
+    const api = getApiClient();
+    try {
+        if (!options.json) {
+            console.log(`Generating embeddings for session ${sessionId.slice(0, 8)}...`);
+        }
+        const result = await api.post(`/api/sessions/${sessionId}/embed`);
+        if (options.json) {
+            console.log(JSON.stringify(result));
+            return;
+        }
+        console.log(`✓ Generated ${result.embeddingsGenerated} embeddings`);
+        console.log("");
+        const learnings = result.embeddings.filter(e => e.type === "learning");
+        const errors = result.embeddings.filter(e => e.type === "error");
+        if (learnings.length > 0) {
+            console.log(`  Learnings embedded: ${learnings.length}`);
+        }
+        if (errors.length > 0) {
+            console.log(`  Errors embedded: ${errors.length}`);
+        }
+        console.log("");
+        console.log("  Session can now be found via semantic search:");
+        console.log("  husky session search \"your query\"");
+    }
+    catch (error) {
+        if (error.message.includes("must be analyzed")) {
+            console.error("Error: Session must be analyzed before embedding.");
+            console.error("Run: husky session analyze --session-id " + sessionId);
+        }
+        else {
+            console.error("Error:", error.message);
+        }
+        process.exit(1);
+    }
+});
+export default sessionCommand;

package/dist/index.js

@@ -39,6 +39,8 @@ import { businessCommand } from "./commands/business.js";
 import { planCommand } from "./commands/plan.js";
 import { diagramsCommand } from "./commands/diagrams.js";
 import { supervisorCommand } from "./commands/supervisor.js";
+import { sessionCommand } from "./commands/session.js";
+import { insightsCommand } from "./commands/insights.js";
 import { checkVersion } from "./lib/version-check.js";
 // Read version from package.json
 const require = createRequire(import.meta.url);
@@ -86,6 +88,8 @@ program.addCommand(businessCommand);
 program.addCommand(planCommand);
 program.addCommand(diagramsCommand);
 program.addCommand(supervisorCommand);
+program.addCommand(sessionCommand);
+program.addCommand(insightsCommand);
 // Handle --llm flag specially
 if (process.argv.includes("--llm")) {
     printLLMContext();

package/dist/types/session.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Session Types - Shared between session.ts and insights.ts
+ */
+export interface SessionSummary {
+    sessionId: string;
+    analyzedAt: Date;
+    analyzedBy: string;
+    learnings: Array<{
+        content: string;
+        tags: string[];
+        confidence: string;
+        savedToBrain: boolean;
+        brainMemoryId?: string;
+    }>;
+    errors: Array<{
+        type: string;
+        description: string;
+        solution: string;
+        preventable: boolean;
+    }>;
+    improvements: Array<{
+        area: string;
+        suggestion: string;
+        priority: string;
+    }>;
+    stats: {
+        totalLogs: number;
+        errorCount: number;
+        durationMinutes: number;
+        toolUsage: Record<string, number>;
+    };
+}
+export interface AgentSession {
+    id: string;
+    vmName: string;
+    agentId: string;
+    agentName?: string;
+    taskId?: string;
+    status: string;
+    logCount: number;
+    errorCount: number;
+    startedAt: Date;
+    lastActivityAt: Date;
+    exportedAt?: Date;
+    analyzedAt?: Date;
+    embeddedAt?: Date;
+    embeddingCount?: number;
+    summary?: SessionSummary;
+    createdAt: Date;
+}
+export interface SessionLogEntry {
+    id: string;
+    sessionId: string;
+    vmName: string;
+    agentId: string;
+    timestamp: Date;
+    tool: string;
+    toolInput: string;
+    toolOutput: string;
+    status: "success" | "error" | "warning";
+    errorType?: string;
+    duration?: number;
+}
+export interface SearchResult {
+    sessionId: string;
+    similarity?: number;
+    analyzedAt?: Date;
+    match: {
+        learnings: Array<{
+            content: string;
+            tags: string[];
+            score?: number;
+        }>;
+        errors: Array<{
+            description: string;
+            solution: string;
+            score?: number;
+        }>;
+    };
+}

package/dist/types/session.js

@@ -0,0 +1,4 @@
+/**
+ * Session Types - Shared between session.ts and insights.ts
+ */
+export {};

package/package.json

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