archbyte 0.6.1 → 0.7.1

package/dist/agents/observability/reader.js

@@ -0,0 +1,86 @@
+// Session Reader — reads session data from .archbyte/sessions/
+import { readFile, readdir } from "fs/promises";
+import { existsSync, readFileSync } from "fs";
+import path from "path";
+function sessionsDir(projectRoot) {
+    return path.join(projectRoot, ".archbyte", "sessions");
+}
+/** Load session index — reads index.json, or scans session dirs if missing */
+export async function loadSessionIndex(projectRoot) {
+    const dir = sessionsDir(projectRoot);
+    const indexPath = path.join(dir, "index.json");
+    // Try cached index first
+    if (existsSync(indexPath)) {
+        try {
+            const raw = readFileSync(indexPath, "utf-8");
+            return JSON.parse(raw);
+        }
+        catch {
+            // Corrupted — rebuild
+        }
+    }
+    // Scan session directories
+    return rebuildIndex(projectRoot);
+}
+/** Rebuild index by scanning all session dirs */
+async function rebuildIndex(projectRoot) {
+    const dir = sessionsDir(projectRoot);
+    if (!existsSync(dir))
+        return { sessions: [] };
+    const entries = await readdir(dir, { withFileTypes: true });
+    const sessions = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const sessionPath = path.join(dir, entry.name, "session.json");
+        if (!existsSync(sessionPath))
+            continue;
+        try {
+            const raw = await readFile(sessionPath, "utf-8");
+            const session = JSON.parse(raw);
+            sessions.push({
+                sessionId: session.sessionId,
+                startedAt: session.startedAt,
+                completedAt: session.completedAt,
+                status: session.status,
+                runCount: session.summary.totalRuns,
+                phases: session.summary.phases,
+                source: session.source,
+            });
+        }
+        catch {
+            // Skip corrupted session files
+        }
+    }
+    // Sort newest first
+    sessions.sort((a, b) => new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime());
+    return { sessions };
+}
+/** Load a full session by ID */
+export async function loadSession(projectRoot, sessionId) {
+    const sessionPath = path.join(sessionsDir(projectRoot), sessionId, "session.json");
+    if (!existsSync(sessionPath))
+        return null;
+    try {
+        const raw = await readFile(sessionPath, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+/** Read recent activity log entries (newest first) */
+export async function loadRecentActivity(projectRoot, limit = 50) {
+    const logPath = path.join(sessionsDir(projectRoot), "activity.log");
+    if (!existsSync(logPath))
+        return [];
+    try {
+        const raw = await readFile(logPath, "utf-8");
+        const lines = raw.trim().split("\n").filter(Boolean);
+        // Return newest first, limited
+        return lines.slice(-limit).reverse();
+    }
+    catch {
+        return [];
+    }
+}

package/dist/agents/observability/types.d.ts

@@ -0,0 +1,125 @@
+export interface TranscriptEvent {
+    timestamp: string;
+    type: 'user' | 'assistant' | 'thinking' | 'tool_use' | 'tool_result' | 'system';
+    agentId?: string;
+    agentSlug?: string;
+    text?: string;
+    toolName?: string;
+    toolUseId?: string;
+    toolInput?: string;
+    toolResult?: string;
+    toolSuccess?: boolean;
+    model?: string;
+    usage?: {
+        inputTokens: number;
+        outputTokens: number;
+        cacheReadTokens: number;
+        cacheCreationTokens: number;
+    };
+}
+export interface CloudStats {
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    totalCacheReadTokens: number;
+    totalCacheCreationTokens: number;
+    estimatedCost: {
+        input: number;
+        output: number;
+        cacheRead: number;
+        cacheCreation: number;
+        total: number;
+    };
+    models: string[];
+    apiCalls: number;
+}
+export interface PayloadFile {
+    path: string;
+    timestamp: string;
+    agentId?: string;
+}
+export interface AgentRun {
+    runId: string;
+    sessionId: string;
+    phase: string;
+    passId: string;
+    agent: string;
+    model: string;
+    iteration: number;
+    startedAt: string;
+    completedAt?: string;
+    elapsedSeconds?: number;
+    status: "running" | "success" | "error" | "skipped";
+    error?: string;
+    tokens?: {
+        input: number;
+        output: number;
+    };
+    cost?: {
+        input: number;
+        output: number;
+        total: number;
+    };
+    toolCalls?: Array<{
+        name: string;
+        durationMs: number;
+        success: boolean;
+    }>;
+    artifacts?: {
+        prompt?: string;
+        output?: string;
+        error?: string;
+    };
+    agentType?: string;
+    transcript?: TranscriptEvent[];
+}
+export interface AgentSession {
+    sessionId: string;
+    projectName?: string;
+    startedAt: string;
+    completedAt?: string;
+    status: "running" | "success" | "error" | "partial";
+    source: string;
+    projectMeta?: {
+        topic?: string;
+        mode?: string;
+        model?: string;
+        style?: string;
+    };
+    summary: {
+        totalRuns: number;
+        successfulRuns: number;
+        failedRuns: number;
+        skippedRuns: number;
+        totalElapsedSeconds: number;
+        totalTokens: {
+            input: number;
+            output: number;
+        };
+        phases: string[];
+        models: string[];
+    };
+    runs: AgentRun[];
+    transcript?: TranscriptEvent[];
+    cloudStats?: CloudStats;
+    payload?: PayloadFile[];
+}
+export interface SessionIndex {
+    sessions: Array<{
+        sessionId: string;
+        startedAt: string;
+        completedAt?: string;
+        status: AgentSession["status"];
+        runCount: number;
+        phases: string[];
+        source: string;
+        category?: string;
+        label?: string;
+        touchedDirs?: string[];
+        eventCount?: number;
+        dirMetrics?: Record<string, {
+            reads: number;
+            writes: number;
+        }>;
+        estimatedCost?: number;
+    }>;
+}

package/dist/agents/observability/types.js

@@ -0,0 +1,3 @@
+// Agent Session Observability — generic schema
+// Any agent framework (archbyte pipeline, custom) emits these types.
+export {};

package/dist/agents/observability/writer.d.ts

@@ -0,0 +1,9 @@
+import type { AgentRun, AgentSession } from "./types.js";
+export declare function createSession(projectRoot: string, sessionId: string, opts?: {
+    projectName?: string;
+    source?: string;
+}): Promise<AgentSession>;
+export declare function writeRun(projectRoot: string, sessionId: string, run: AgentRun): Promise<void>;
+export declare function completeSession(projectRoot: string, sessionId: string, runs: AgentRun[]): Promise<void>;
+export declare function updateSessionIndex(projectRoot: string): Promise<void>;
+export declare function appendActivityLog(projectRoot: string, entry: Record<string, unknown>): Promise<void>;

package/dist/agents/observability/writer.js

@@ -0,0 +1,100 @@
+// Session Writer — writes session data to .archbyte/sessions/
+import { mkdir, writeFile, appendFile } from "fs/promises";
+import path from "path";
+import { loadSessionIndex } from "./reader.js";
+function sessionsDir(projectRoot) {
+    return path.join(projectRoot, ".archbyte", "sessions");
+}
+export async function createSession(projectRoot, sessionId, opts) {
+    const dir = path.join(sessionsDir(projectRoot), sessionId);
+    await mkdir(path.join(dir, "runs"), { recursive: true });
+    const session = {
+        sessionId,
+        projectName: opts?.projectName,
+        startedAt: new Date().toISOString(),
+        status: "running",
+        source: opts?.source ?? "archbyte",
+        summary: {
+            totalRuns: 0,
+            successfulRuns: 0,
+            failedRuns: 0,
+            skippedRuns: 0,
+            totalElapsedSeconds: 0,
+            totalTokens: { input: 0, output: 0 },
+            phases: [],
+            models: [],
+        },
+        runs: [],
+    };
+    await writeFile(path.join(dir, "session.json"), JSON.stringify(session, null, 2), "utf-8");
+    return session;
+}
+export async function writeRun(projectRoot, sessionId, run) {
+    const runDir = path.join(sessionsDir(projectRoot), sessionId, "runs", run.runId);
+    await mkdir(runDir, { recursive: true });
+    await writeFile(path.join(runDir, "meta.json"), JSON.stringify(run, null, 2), "utf-8");
+    // Write optional artifacts
+    if (run.artifacts?.prompt) {
+        await writeFile(path.join(runDir, "prompt.md"), run.artifacts.prompt, "utf-8");
+    }
+    if (run.artifacts?.output) {
+        await writeFile(path.join(runDir, "output.md"), run.artifacts.output, "utf-8");
+    }
+    if (run.artifacts?.error) {
+        await writeFile(path.join(runDir, "error.txt"), run.artifacts.error, "utf-8");
+    }
+    // Append to activity log
+    await appendActivityLog(projectRoot, {
+        type: "run",
+        sessionId,
+        runId: run.runId,
+        agent: run.agent,
+        status: run.status,
+        timestamp: run.completedAt ?? run.startedAt,
+    });
+}
+export async function completeSession(projectRoot, sessionId, runs) {
+    const dir = path.join(sessionsDir(projectRoot), sessionId);
+    const successfulRuns = runs.filter((r) => r.status === "success").length;
+    const failedRuns = runs.filter((r) => r.status === "error").length;
+    const skippedRuns = runs.filter((r) => r.status === "skipped").length;
+    const totalElapsed = runs.reduce((s, r) => s + (r.elapsedSeconds ?? 0), 0);
+    const totalTokensIn = runs.reduce((s, r) => s + (r.tokens?.input ?? 0), 0);
+    const totalTokensOut = runs.reduce((s, r) => s + (r.tokens?.output ?? 0), 0);
+    const phases = [...new Set(runs.map((r) => r.phase))];
+    const models = [...new Set(runs.map((r) => r.model))];
+    const hasErrors = failedRuns > 0;
+    const allFailed = failedRuns === runs.length;
+    const session = {
+        sessionId,
+        startedAt: runs[0]?.startedAt ?? new Date().toISOString(),
+        completedAt: new Date().toISOString(),
+        status: allFailed ? "error" : hasErrors ? "partial" : "success",
+        source: "archbyte",
+        summary: {
+            totalRuns: runs.length,
+            successfulRuns,
+            failedRuns,
+            skippedRuns,
+            totalElapsedSeconds: totalElapsed,
+            totalTokens: { input: totalTokensIn, output: totalTokensOut },
+            phases,
+            models,
+        },
+        runs,
+    };
+    await writeFile(path.join(dir, "session.json"), JSON.stringify(session, null, 2), "utf-8");
+    // Rebuild index
+    await updateSessionIndex(projectRoot);
+}
+export async function updateSessionIndex(projectRoot) {
+    const index = await loadSessionIndex(projectRoot);
+    await mkdir(sessionsDir(projectRoot), { recursive: true });
+    await writeFile(path.join(sessionsDir(projectRoot), "index.json"), JSON.stringify(index, null, 2), "utf-8");
+}
+export async function appendActivityLog(projectRoot, entry) {
+    const logPath = path.join(sessionsDir(projectRoot), "activity.log");
+    await mkdir(sessionsDir(projectRoot), { recursive: true });
+    const line = JSON.stringify({ ...entry, _ts: new Date().toISOString() }) + "\n";
+    await appendFile(logPath, line, "utf-8");
+}

package/dist/agents/pipeline/index.d.ts

@@ -6,7 +6,7 @@ import type { IncrementalContext } from "./types.js";
  * Run the multi-agent pipeline: 3 parallel fast agents → 2 sequential agents.
  * Each agent gets a single chat() call with pre-collected static context.
  */
-export declare function runPipeline(ctx: StaticContext, provider: LLMProvider, config: ArchByteConfig, onProgress?: (msg: string) => void, incrementalContext?: IncrementalContext, onDebug?: (agentId: string, model: string, system: string, user: string) => void): Promise<StaticAnalysisResult & {
+export declare function runPipeline(ctx: StaticContext, provider: LLMProvider, config: ArchByteConfig, onProgress?: (msg: string) => void, incrementalContext?: IncrementalContext, onDebug?: (agentId: string, model: string, system: string, user: string) => void, projectRoot?: string): Promise<StaticAnalysisResult & {
     tokenUsage?: {
         input: number;
         output: number;

package/dist/agents/pipeline/index.js

@@ -1,5 +1,7 @@
 // Pipeline — Orchestrator
 // Runs static context collection → parallel LLM agents → sequential LLM agents
+import { writeFile, mkdir } from "fs/promises";
+import path from "path";
 import { resolveModel } from "../runtime/types.js";
 import { validateAnalysis } from "../static/validator.js";
 import { componentIdentifier } from "./agents/component-identifier.js";
@@ -92,14 +94,40 @@ function getFallbackData(agentId, inc) {
  * Run the multi-agent pipeline: 3 parallel fast agents → 2 sequential agents.
  * Each agent gets a single chat() call with pre-collected static context.
  */
-export async function runPipeline(ctx, provider, config, onProgress, incrementalContext, onDebug) {
+export async function runPipeline(ctx, provider, config, onProgress, incrementalContext, onDebug, projectRoot) {
     const agentResults = {};
     const agentMeta = [];
     const skippedAgents = [];
+    const sessionId = `archbyte-${Date.now()}`;
+    const sessionRuns = [];
     // Pass incremental context to agents via priorResults
     if (incrementalContext) {
         agentResults["__incremental__"] = incrementalContext;
     }
+    // Helper: record an agent run for session observability
+    function recordRun(agent, result, status, error) {
+        const model = resolveModel(config.provider, agent.modelTier, config.modelOverrides, config.model);
+        const run = {
+            runId: `${agent.id}-${Date.now()}`,
+            sessionId,
+            phase: agent.id === "connection-mapper" || agent.id === "validator" ? "sequential" : "parallel",
+            passId: agent.id,
+            agent: agent.name,
+            model,
+            iteration: 1,
+            startedAt: result ? new Date(Date.now() - result.duration).toISOString() : new Date().toISOString(),
+            completedAt: new Date().toISOString(),
+            elapsedSeconds: result ? result.duration / 1000 : 0,
+            status,
+            error,
+            tokens: result?.tokenUsage ? { input: result.tokenUsage.input, output: result.tokenUsage.output } : undefined,
+            artifacts: result?.prompt || result?.rawOutput ? {
+                ...(result.prompt ? { prompt: result.prompt } : {}),
+                ...(result.rawOutput ? { output: result.rawOutput } : {}),
+            } : undefined,
+        };
+        sessionRuns.push(run);
+    }
     // === Phase 1: Parallel agents ===
     onProgress?.(`Phase 1: Running ${PARALLEL_AGENTS.length} agents in parallel...`);
     // Pass agentResults to parallel agents too (contains __incremental__ if set)
@@ -123,17 +151,21 @@ export async function runPipeline(ctx, provider, config, onProgress, incremental
     let authFailed = false;
     for (let i = 0; i < parallelTasks.length; i++) {
         const { agent, skipReason } = parallelTasks[i];
-        if (skipReason)
-            continue; // Already handled
+        if (skipReason) {
+            recordRun(agent, null, "skipped");
+            continue;
+        }
         const result = parallelResults[i];
         if (result.status === "fulfilled" && result.value) {
             agentResults[agent.id] = result.value.data;
             agentMeta.push(result.value);
             onProgress?.(`  ${agent.name}: done (${(result.value.duration / 1000).toFixed(1)}s)`);
+            recordRun(agent, result.value, "success");
         }
         else {
             const reason = result.status === "rejected" ? result.reason : "null response";
             onProgress?.(`  ${agent.name}: failed (${reason})`);
+            recordRun(agent, null, "error", String(reason));
             if (result.status === "rejected" && isAuthError(result.reason)) {
                 authFailed = true;
             }
@@ -153,6 +185,7 @@ export async function runPipeline(ctx, provider, config, onProgress, incremental
             onProgress?.(`  ${agent.name}: skipped (${skipReason})`);
             const fallback = getFallbackData(agent.id, incrementalContext);
             agentResults[agent.id] = fallback;
+            recordRun(agent, null, "skipped");
             continue;
         }
         try {
@@ -161,13 +194,16 @@ export async function runPipeline(ctx, provider, config, onProgress, incremental
                 agentResults[agent.id] = result.data;
                 agentMeta.push(result);
                 onProgress?.(`  ${agent.name}: done (${(result.duration / 1000).toFixed(1)}s)`);
+                recordRun(agent, result, "success");
             }
             else {
                 onProgress?.(`  ${agent.name}: returned null`);
+                recordRun(agent, null, "error", "returned null");
             }
         }
         catch (err) {
             onProgress?.(`  ${agent.name}: failed (${err instanceof Error ? err.message : String(err)})`);
+            recordRun(agent, null, "error", err instanceof Error ? err.message : String(err));
             if (isAuthError(err)) {
                 throw new Error(`API key authentication failed. Check your API key with: archbyte config set api-key <your-key>\n` +
                     `  Current provider: ${config.provider}. Get a valid key from your provider's dashboard.`);
@@ -204,6 +240,50 @@ export async function runPipeline(ctx, provider, config, onProgress, incremental
         console.error();
         onProgress?.(`Token usage: ${totalInput} in / ${totalOutput} out${skippedAgents.length > 0 ? ` (${skippedAgents.length} skipped)` : ""}`);
     }
+    // === Write runs to .archbyte/runs/ (best-effort, fire-and-forget) ===
+    if (projectRoot) {
+        const sessionStartedAt = sessionRuns.length > 0
+            ? sessionRuns.reduce((earliest, r) => r.startedAt < earliest ? r.startedAt : earliest, sessionRuns[0].startedAt)
+            : new Date().toISOString();
+        const sessionCompletedAt = new Date().toISOString();
+        const writeRuns = async () => {
+            const runsDir = path.join(projectRoot, ".archbyte", "runs");
+            for (const run of sessionRuns) {
+                const agentDir = path.join(runsDir, run.passId);
+                await mkdir(agentDir, { recursive: true });
+                // meta.json — AgentRun fields minus artifacts
+                const { artifacts, ...meta } = run;
+                await writeFile(path.join(agentDir, "meta.json"), JSON.stringify(meta, null, 2));
+                // prompt.md and output.md from artifacts
+                if (artifacts?.prompt) {
+                    await writeFile(path.join(agentDir, "prompt.md"), artifacts.prompt);
+                }
+                if (artifacts?.output) {
+                    await writeFile(path.join(agentDir, "output.md"), artifacts.output);
+                }
+            }
+            // session.json — lightweight summary
+            const successCount = sessionRuns.filter(r => r.status === "success").length;
+            const failedCount = sessionRuns.filter(r => r.status === "error").length;
+            const session = {
+                sessionId,
+                startedAt: sessionStartedAt,
+                completedAt: sessionCompletedAt,
+                status: failedCount > 0 ? "partial" : "success",
+                source: "archbyte",
+                mode: "pipeline",
+                totalRuns: sessionRuns.length,
+                successfulRuns: successCount,
+                failedRuns: failedCount,
+                totalTokens: { input: totalInput, output: totalOutput },
+                totalElapsedSeconds: sessionRuns.reduce((s, r) => s + (r.elapsedSeconds ?? 0), 0),
+            };
+            await writeFile(path.join(projectRoot, ".archbyte", "session.json"), JSON.stringify(session, null, 2));
+        };
+        writeRuns().catch((err) => {
+            console.error("[pipeline] Failed to write runs:", err);
+        });
+    }
     return { ...merged, tokenUsage: { input: totalInput, output: totalOutput }, skippedAgents: skippedAgents.length > 0 ? skippedAgents : undefined };
 }
 // Agents that produce large structured output (lists of components/connections) need more tokens
@@ -248,5 +328,7 @@ async function runAgent(agent, ctx, provider, config, priorResults, onProgress,
         data,
         duration: Date.now() - start,
         tokenUsage: { input: response.usage.inputTokens, output: response.usage.outputTokens },
+        prompt: system + "\n\n---\n\n" + user,
+        rawOutput: text,
     };
 }

package/dist/agents/pipeline/types.d.ts

@@ -171,4 +171,6 @@ export interface PipelineAgentResult {
         input: number;
         output: number;
     };
+    prompt?: string;
+    rawOutput?: string;
 }

package/dist/agents/prompt-data.js

@@ -6,3 +6,12 @@ registerPrompt("pipeline/connection-mapper", "GB0WSCMLEUUgHEMNOgkRFzVSEAckDQMEMx
 registerPrompt("pipeline/flow-detector", "GB0WSCMLEUUgHEMNOgkRFzVSEAckDQMEMxdDCTAaHAw1FwAcbFk1CyAeGhInWQANJFITGi0TEQY1UgAHLA0RHTVSAgYmWR0BJBwXASQATm9LQ01IaFMREyQcFystFxoAIgYKBywKXk97UiYeJxcASCUACh4nF1QGLh8OHSwQFwQ1GwwGYgkVETUXEQYxWVwIJAEQCSUcVBQ0FxYNMVVUFTQQTBs3G1hFNhcBAC0WHxZtUgYeJxcARSQfChw2HAYWaFxpSGJZMgozUgYJIRFORTpSEx0gFR0WKRcRRGIKAQcyEREBIBwGSWERCwksFxEJbVIXDSERGgotHQQRYgR+RWFSTkgyDBYJKAELDTBWBxAjAQAaKxsRF3tSAAcvCRsLJBwXSAs9B0VpGQYKIxtZBiABBkgxFQECMltpSGJZWUUiGgIGLBwYX2EXFQ0sDVsRLgIKC20IAQA0F0MGIxQRb2FSQ0ViDREGKRwMBC0eDV9hBgsNYgoEACIbBQEhWQAAIhoNBy4WExxhBxANJllcAG8VTURiWxETJBwXRScUHRE1FxFKbllWEiQQCwctElZMS3hRRmJTXgQxGzEHNw0RFmtYWUgDKT1FMx0WHCcKWwAvFhMHKxcAFmEWBhwnGgAAJVIFGi0UVAYuFgZIMhgAESQADRtsc1RFYTQMGmIcFQYpSEMTYgkVESleQwUnDRwKJV5DACMXEAkkACUBLhxUGEt4IDoLLT0mAD5ZSA0XGBxhAAYYLQsARSQEBgY2WRcKLxwGCzYQGwsyUgIGJlkGCjQGBhtiDRwENVILCTQcVCYOPCA6By0xRQQkKiwHNzcgYRsNSDYREUUxAAweKx0RAWERDAwnWQcELAIPDTFVVBY1ExcBIVkHBiAcDQ0wWQYAMgcPHDFVVAozUicHIRIRF2EBBho0EBcAMlxDISRZAA0kUhAcIw0dBmEBAAksFxEXYQECETFZVisuUgYeJxcASCUACh4nF1QVIAYXDTAXB0UlFxcNIQ0RAWNeQxonDQEXL1IGBTINDUUkBAYGNjobCy8XABwrFhoWb1InB2I3OzFhGw0eJxcARTETFxwnCxoWYQYLCTZZFRckUg0HNlkREygWBgYhHBBFKBxDHCocVAwvAhYcbHN+NyQBEwcsHVQSKAYLSA03ODxhE0MiETY6RS4QCQ0hDU5vOnhDSGAcAgAvBiAHLBcRBjUbDAYxW05FGlxNRh9VfkVhUAIYKysbEDUXEEp4WS9Lb1w+Yj9zfiwnUg0HYgkVETUXEQYxWRIKNBwHRGILERE0AA1IJxQEEThSAhowGA0Wbw==");
 registerPrompt("pipeline/service-describer", "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");
 registerPrompt("pipeline/validator", "GB0WSCMLEUUgUhAHJA0DBDMXQwkwGhwMNRcAHDcLEUUzFxUBJw4RF29SNQkuEBAENRdDHCocVAQvEw8RMRAHRTMXEB0uDQdFIBwHSDEMEwIkARdIIRYGFyQRFwEtFwdLS3ggACcaH0UnHRFSSEhaRWtYNBotFxNFIh0OGC0XEQs1UhcRMhwHT2tIQw1sHlpJYRNDOicYFxFhExMYYg0NFSQWQwkxWVYWJAAVASEcVkUyGgwdLh1UByRSQQ4wFhoRJBwHSkhLWkVrWDQNIxJUASQBABorCQAMLhwQQmhDVCYuHxMHLBwaETJSFAE2EVQALAIXEWIWBkU0HAAEJxgGRSUXEAswEAQRKB0NG2Kb9PFhAhEHNBAQAGEQBhw2HAZFLhwGG0hKWkVrWDENJgwaASAcF0ghFhoLJBEXAS0XB09rSEMsNwkYDCITFw1iFgZFNBwNDSEcBxYgABpIIRYaCyQRFwEtFwdFNRoCHGIKHAo0HgdIIBxUFyQfDB4nHX5Rb1JJQhULGwsmUgAHLBcRBjUbDAZiDQ0VJAFJQnhZEUsmXE9IIxdUDCwCDBo2WRcKLxwGCzYQGwthBgsJNlkHDS4HDwxiGxFFYxoXHDJbfm8CICo8Czo1KWExLCYRLSYkCDw3O3hzWUUYHRZILxgNRQ48LzFiCxEDJAAGBiEcVAYuHxMHLBwaEWE7JxtiDRwENVICBDAcFQE4UgYQKwoARSgcQxwqHFQGLh8TBywcGhEyUg8BMQ1UBCMdFQ1sc1lFBR1DJg0tVAwvBAYGNlkaADZSAAcvCRsLJBwXG25ZEAQ1EwEJMRwHSWEdEUgnAQAAMxwCBGIKERc3GwANMVd+SGE2DEgMNiBFIBYHSCEWGgskERcBLRcHRTUdQwstFAQKLxcNHDFZAA0gBkMMLRdTEWEXGwExDVQML1IXACdZGAwyBk1ib1k7Cy0LQwkmHVQGLhwNDSENHQovAUMRLQxUBDMXQwArHhwJOFIABywfHQEkHBdIIxsbEDVSAQkxHBBFLhxDHCocVAYuHxMHLBwaEWECAhwqClhFNRcAACwWGAomGwYbblkVCyVSBhArCgAMLxVDCy0XGgAiBgoHLApab2xSMxonHxEXYQAGBS0PHQsmUgEJJlkXCi8cBgs2EBsLMlIMHicLVAQlFgoGJVkHFSQRFgQjDR0TJFIMBicKWm9sUioOYg0cAGETDQkuAAcMMlIPBy0SB0UzFwIbLRcVBy0XT0gwHAAQMxxDDS8JABxhEQwaMBwXESgdDRtsWTgAMgFDATFZGQozF01iSCsRFjEdDQxiDh0RKVIsJg4gVARhODAnDFkbBysXABx4cw9vYVJBCy0UBAovFw0cFgAEAAIdERonGgAMLhwQSnhZD0VjEQwFMhYaAC8GTgEmW05FYxEMGjAcFxFsBhoYJ1tUGG14Q0hgGhsIMR0NDSwNMAAyEREBMg0dCi8BQVJiAlRHIh0OGC0XEQs1XwoMYENURyMXFxwnC1QBJAEAGisJAAwuHEFIP1V+RWFQAgwmHBAmLhwNDSENHQovAUFSYiIPRWMUEQcvW05FYxsHSm5ZVhEuUFlIYBAQR21SQRw7CRFHHF5pSGJbFwovFAoMJxcXAGNIQ1hsQUFJS1JDSisKBxAkAUFSYiJWASQBABorCQAMLhxDByRZFQs4UhENLxgdCygcBEgrCgcQJAFBNUgEfm8UAQZIJxQEEThSDAooHBcRMl0CGjAYDRZhGwVILBZUBi4AEQ0hDR0KLwFDBiccEAAlXEM8KhxUBi4cBQEmHBoGJFIQCy0LEUVpQk5Za1kGACceBgs2ClQcLgcRSC0PERcgHg9IIRYaAygWBgYhHFQML1IXACdZFQsgHhobKwpUFDQTDwE2AFo=");
+// Premium agent prompts
+registerPrompt("premium/security-auditor", "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");
+registerPrompt("premium/compliance-checker", "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");
+registerPrompt("premium/performance-analyzer", "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");
+registerPrompt("premium/dependency-risk-scorer", "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");
+registerPrompt("premium/migration-planner", "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");
+registerPrompt("premium/api-contract-verifier", "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");
+registerPrompt("premium/infra-agent-auditor", "YlIqBiQLFRY1ABYLNgwGAGEzBA0sDVQkNBYKHC0Lfm8YHRZIIwsRRSAcQwEsHwYEMgYRHSENARckUgIPJxcARSAAAAArDREGNQcRDWIYAQEoBgwabFktCjQAQwItG1QMMlIXB2IcAgQtBwIcJ1kXCiUXAQkxHAdFNRoCHGIbAQwtFkMBLB8GBDIGER0hDQEXJFICDycXABZhEwQJKxcHEWEGCw1iCh0dbAIPCSwcVAQzEQsBNhwXETQABkgvFhAALVIFGi0UVBEpF0MhLB8GBDIGER0hDQEXJFIiDycXABZhNRYBJhxaRRgdFkgjCgcAMgFDBSMNARcoBhpEYh0RESQRF0gjFwAMbAICHDYcBgsyXkMJLB1UDCUXDRwrHw1FIh0RDWIJBgwvEQoYLhxUEygdDwk2EBsLMlxpYgMXFQk4CAZINhERRTEADAInGgBFIBwHSDAcABAzHEMJYjMnKg9SDAooHBcRYQUKHCpZAA0oAUMbNgsBBjUHEQ14cw9vYVJBGzcUGQQzC0FSYlsWFygXBUgtDxEXIB4PSCsXEhcgARcaNxoAEDMXQwklHBoRYR8CHDcLHRE4UgIbMRwHFiwXDRxgVX5FYVAMHicLFQktIQAHMBxWX2EcFgUgHAZFaUJOWXJJWEU2GgYaJ1lFVXFSChtiHwEJLQtDBSMNARckUgILMBYHFmETDwRiCRgELxcQQW5zVEVjAg8JLBwHR3tSGGJiWVRFYxsNDycKAAwuHEFSYgJ+RWFSQ0hiWxAANRcAHCcdVl9hEAwHLhwVC214Q0hiWVRFYx8CHDcLHRE4UFlIYBcbCyRSH0ggGAcMIlIfSC8YABAzF0FESFlURWFSQ0ohFhkVLhwGBjYKVl9hKRhIYBcVCCRQWUhgCgAXKBwESm5ZVgMoHgZKeFlWFjUACgYlW1hFYxYGGyELHRU1GwwGYENURzIGEQEsHlZFPC9PYmJZVEVhUkEPIwkHR3tSOEoxDQYMLxVBNUhZVEVhD09iYllURWMCDAQrGg1He1IYYmJZVEVhUkEMJw0RBjUXB0p4WRYKLh4GCSxVfkVhUkNIYlsZBDUHEQE2AFZfYVANBywcVBlhEAIbKxpUGWEfAhw3CxFHbXhDSGJZVEVjEQwFMhYaAC8GEEp4WS8eYVANCS8cVl9hUBAcMBAaAmNeQ0okEBgAY0hDSjENBgwvFUFEYlsQADIREQEyDR0KL1BZSGAKABcoHARKYgQpSUtSQ0hiWVRHJhMTG2BDVD5jARcaKxcTRxx4Q0hiWQlJS1JDSGJbER0kERYcKxYaR3tSGGJiWVRFYVJBDCcNEQY1FwdKeFkWCi4eBgksVX5FYVJDSGJbGQQ1BxEBNgBWX2FQDQcsHFQZYRACGysaVBlhHwIcNwsRR214Q0hiWVRFYxEMBTIWGgAvBhBKeFkvHmFQDQkvHFZfYVAQHDAQGgJjXkNKJBAYAGNIQ0oxDQYMLxVBRGJbEAAyEREBMg0dCi9QWUhgCgAXKBwESmIEKUlLUkNIYllURyYTExtgQ1Q+YwEXGisXE0cceENIYlkJSUtSQ0hiWx0LNRcEGiMNHQovUFlIOXNURWFSQ0hgHRERJBEXDSZbTkUjHQwEJxgaSUtSQ0hiWVRHLBMXHTAQABxjSENKLBYaAGEOQwojCh0GYQ5DBSMNARckUE9iYllURWFSQQstFAQKLxcNHDFbTkUaCUNKLBgZAGNIQ0oxDQYMLxVBRGJbEgwtF0FSYlsHETMbDQ9gVVRHJRcQCzAQBBEoHQ1KeFlWFjUACgYlW1QYHF5pSGJZVEVhUAQJMgpWX2EpQRs2Cx0LJlA+YmJZVEU8XmlIYllURyIaAgYlHDcKLwYRBy5bTkU6eENIYllURWMWBhwnGgAAJVBZSCAWGwkkEw1ESFlURWFSQ0ovGAAQMxsXEWBDVEcvHQ0NYgVUByABCgtiBVQIIAYWGidbWG9hUkNIYllWBi4fEwcsHBoRMlBZSBkCVEcvEw4NYENURzIGEQEsHlZJYVAFAS4cVl9hUBAcMBAaAmNeQ0omHAcGMxsTHCsWGkd7UkEbNgsdCyZQQxUfVX5FYVJDSGJbEwQxAUFSYiJWFjUACgYlWylvYVJDSD9VfkVhUkNKLRsHADMEAgorFR0ROFBZSDlzVEVhUkNIYB0RESQRFw0mW05FIx0MBCcYGklLUkNIYllURywTFx0wEAAcY0hDSiwWGgBhDkMKIwodBmEOQwUjDQEXJFBPYmJZVEVhUkELLRQECi8XDRwxW05FGglDSiwYGQBjSENKMQ0GDC8VQURiWxIMLRdBUmJbBxEzGw0PYFVURyUXEAswEAQRKB0NSnhZVhY1AAoGJVtUGBxeaUhiWVRFYVAECTIKVl9hKUEbNgsdCyZQPmJiWVRFPHhDSD9VfkVhUAIGNhAkBDUGBhosClZfYSlpSGJZVB5LUkNIYllURzETFxwnCxpHe1JBGyoWBhFhHAIFJ1kbA2EGCw1iGBoRKF8TCTYNERcvUE9iYllURWFSQRsnDxEXKAYaSnhZVgYzGxcBIRgYRT1SCwElEVQZYR8GDCsMGUU9Ug8HNVtYb2FSQ0hiWVYJLhECHCsWGkd7UkEOKxURRTETFwBiFgZFIh0OGC0XEQs1UE9iYllURWFSQRonGhsILBcNDCMNHQovUFlIYBEbEmEGDEgkEAxFKAZBYmJZVEU8eENIH1V+RWFQAAcwHCIMLh4CHCsWGhZjSEMzSFlURWEJaUhiWVRFYVATGisXFwwxHgZKeFlWCyAfBkgtH1QRKRdDHisWGAQ1FwdIIRYGAGECEQEsGh0VLRdBREhZVEVhUkNKJw8dASQcAA1gQ1RHNhoCHGIOFRZhFAwdLB1WSUtSQ0hiWVRHMhcVDTAQABxjSENKIQsdESgRAgRiBVQNKBULSD5ZGQAlGxYFYgVUCS4FQWJiWVRFPHhDSB9VfkVhUBENIRYZCCQcBwk2EBsLMlBZSBlbBBcoHREBNhAOACVSDwExDVQKJ1IKBTILGxMkHwYGNgpWOEsPaWILFwcRMwcAHCsWGhZhkOP8YgoXBC9SFwAnWRcKJRcBCTEcVAMuAEMbKx4aBC0BQw4wFhlFIB4PSCMLFw0oBgYLNgwGAGEWDAUjEBoWe3hpS2FZPQsmFxAcKxYaRREeAgYnWVwmKVJSSKD54EUAAAAAKw0RBjUHEQ1uWTcNYUBDisLtVDc0HBcBLxxdb3BcQyQtFh9FJx0RSDEQEwsgHkMaLQwAADMBT0g1HBYNLh0ISCoYGgEtFxEbblkABDIZQwwrCgQENRELSCsXAAAzFAILJwpYRS8dEQUjFR0fJBZDHCMKH0UyEQsNLxgHb3NcQysqHBcOYRQMGmI1OChhABYGNhAZAGEbDRwnHgYENRsMBmJRNwkgBwcNYiowLm1SLBgnFzUsbVIvCSweNw0gGw1EYhoBFjUdDkgkCxUIJAUMGikKXW9yXEMkLRYfRScdEUg2GAcOYQMWDTcQGgJhARobNhwZFmFaMQ0mEAdJYTAWBC40JUlhITI7blkgACwCDBojFVhFAhcPDTAAXW91XEMrKhwXDmEUDBpiDhsXKhcRSC8WEAAtAU9IIQsVFilSEQ0hFgIAMwtPSCocFRc1EAYJNlkZACIaAgYrChkWS3hAS2IpGwkoERpIEhUVCyRSSysqWUxFo/L3SBIWGAwiC09IARFUUGGQ4/xiOgYAJRcNHCsYGBZoeFZGYioRBDMRC0gkFgZFIAcXBywWGRxhBgoNMFkQACcbDQE2EBsLMl5DHC0WGEUzFxAcMBAXESgdDRtuWRYQJRUGHGIVHQgoBhBEYjE9MQ1SAAAnGh8VLhsNHDFzQkthPgwHKVkSCjNSEwcuEBccbBMQRSEWEABhAgIcNhwGCzJSSycSOFhFAhcHCTBVVAY0ARcHL1kECi0bABFiHBoCKBwGG2tzQ0thMQsNIRJUBjMXBw0sDR0ELVILCSwdGAwvFUOKwu1UCS4dCEgkFgZFIgAGDCcXAAwgHkMKMBYfADMBT0gxERsXNV8PATQcEEU1HQgNLApUTRImMERiNjUQNRpDCy4QEQs1LQAaJx0RCzUbAgQxVVQiAiJDAS8JERcyHQ0JNhAbC2h4W0ZiPxgEJlILCTAdFwolFwdIMRwXFyQGEERiFRsLJl8PATQcEEU1HQgNLApUDC9SBgY0WQIEMwFPSAMuJ0UqFxobYhAaRSIdDQ4rHlQDKB4GG0hzV0ZhNxsNIQwADC4cQzguGBoAYVogAGJKVIfB5kM8LRYYFm1SIABiTVSHweZDOyMXEAcuCgoGJVB+XG9SLwctElQDLgBDHC0WGEUzFwQBMQ0GBDUbDAZiCRURNRcRBjFVVCgCIkMbJwsCADNSBw0kEBoMNRsMBjFVVBYqGw8EYh8dCSQBaVlyV1QmKRcAA2IfGxdhBgwHLlkVCS0dFEcmHBocYR4KGzYKWEU1CxMNJlk3KQhSFBojCQQAMwFpWXNXVDYkExELKlkSCjNSEAksHRYKORsND2Kb9PFhNgwLKRwGRSIdDRwjEBoAMwFPSA8WEAQtXkMjegpULy4QEERiCxEEJV8MBi4AVAMoHgYbOwoAACwBaVlwV1QmKRcAA2IfGxdhHAYcNRYGDmEXBBonCgdFIh0NHDAWGBZtUg4NNhgQBDUTQw0sHQQKKBwXSCAVGwYqGw0PYlFFU3hcUV12V0VTeFxRXXZQfm9iUUMhLA0RAjMTFwEtF1Q1LRMNDWJRNw1hREOKwu1UISAGAkgSFRULJF5DKypZRVVhkOP8YjgBES4cDAUtDAdFDgIQQUhIR0thPgwHKVkSCjNSEQ0xFgEXIhdDBi0LGQQtGxkJNhAbC2EeAhEnCwdJYTsCK2IaGxczFw8JNhAbC21SEQ0xFgEXIhdDDzAYBA1hEBYBLh0RFzJ4UlxsWTcNJBEISCQWBkUiHQ0cJwEARTIXEQEjFR0fIAYKByxVVDcANUMYKwkRCSgcBhtuWQIAIgYMGmI9NkUoHBcNJQsVESgdDWJzTFpFEhcCGiERVAMuAEMbIRERATQeCgYlVVQLLgYKDisaFREoHQ1IMBYBESgcBERiHAcGIB4CHCsWGkUiGgIBLApYRSUTCgQ7WRAMJhcQHDFzfkZiUiAAIxcTAGExDAY2CxsJYSIPCSwcVE0CGkNfYpv08WExCwksHhFFAh0NHDAWGExLQ1VGYjUbCipSBQcwWSQ3bBACGycdVBIuAAgOLhYDFm1SExonVCQ3YQQCBCsdFREoHQ1ILhYbFTJ4Ul9sWTcNJBEISCQWBkUlFxcNMBQdCygBFwEhWQIELRsHCTYQGwthBgwHLgpUTQIaBgspFgJJYQYFBCsXAElhPTMpblkAADMAAg4tCxlFNxMPASYYAABoeFJQbFknACAAAABiHxsXYRARCSwaHEUvEw4BLB5UBi4cFQ0sDR0KLwFPSCEWGQgoBkMFJwoHBCYXQxs2GBoBIAAHG0hzV0ZhPQEbJwsCBCMbDwE2AFQ1LRMNDWJRNw1hS0OKwu1UKiMBBho0GBYMLRsXEWtzRVxvUjANIwsXDWEUDBpiNgQALyYGBCcUEREzC0MbMhgaFm1SFxojGh0LJlIQDTYMBElhEwAcKxYaRTUAAgEuWRETJBwXG0hLREthMQsNIRJUAy4AQwstCwYALRMXAS0XVCwFAU9IMQ0GECIGFhonHVQJLhUEASweWEUtHQRIMBwQBCIGCgcsWRsDYQEGCzAcABZLQFJGYjUbCipSBQcwWRkANQAKCzFZFwotHgYLNhAbC21SBwkxERYKIAAHG25ZFQkkABcBLB5UFzQeBhtIc1dGYTERBzEKWQY0BhcBLB5UBi4cAA0wFwdvc0BNSBYcBxEoHARIajocRXBDSlJiNRsKKlIFBzBZABcgGAYLNhYGHGEGBhs2ClhFIBYVDTAKFRcoEw9HMgsbCDEGQwEsExEGNRsMBmINERY1AU9INxcdEWEGBhs2ClQDLgBDHC0WGBZLQFBGYiwsRWkxC0hzS11fYTELDSESVAMuAEMFNxUADGwGBgYjFxccbVIxKgM6WEUuAARFLhwCAC1SChstFRURKB0NRGIJBgomAAYbMRACAGEWChshFRsWNAAGYnBNWkUTGxADYlE3DWFDUEF4WTgKLhlDDi0LVBcoAQhILxgAFygRBhtuWRUQNR0NBy8AVAEkEQobKxYaRSwTFxorGhEWbVIABy8JGAwgHAANYhQVFTEbDQ9iUTosEiZPSA0uNTYRXkM7DTpGTG1SBAdvFR0TJFIAACcaHwkoARcbSHNXRmExDBonWSQXKBwAATIVERZhBgxINBwGDCcLaUViWzUCJBwXG2I3ERMkAEMsJwkYCjhSJwEwHBcRLQtBSKD54EUgFQYGNgpUCDQBF0gyCxsVLgEGSCERFQsmFxBINBAVRREgEERiFxsRYRMTGC4AVBEpFw5ib1lWKSQTEBxiKQYMNxsPDSUcVAc4UicNJBgBCTVQQ4rC7VQRLh0PG2IYGgFhERENJhwaESgTDxtiChwKNB4HSCAcVBYiHRMNJlkZDC8bDgkuFQ1vbFJBIDcUFQtsGw1FNhERSA0dDBhiHxsXYTAPCTENVDcgFgodMVtUh8HmQwwnCgAXNBEXATQcVAQiBgoHLApUCDQBF0gwHAUQKAAGSCMJBBcuBAIESFRURw4QEA0wDxUHKB4KHDtZHRZhPAwGbxcRAi4GCgkgFRFHYZDj/GIYGAlhEwQNLA1UBCIGCgcsClQINAEXSCAcVBEzEwANIxsYAEt4UV1sWSYANQcRBmI2OikYUhcAJ1k+Ng48QwcgExEGNV5DBi1ZGxEpFxFINhwMEUs=");
+registerPrompt("premium/drift-detector", "GB0WSCMLEUUgUgcaKx8ARSUXFw0hDRsXYRMEDSwNVAMuAEMpMBocJzgGBkRiEBAALwYKDjsQGgJhExELKhAAACIGFhojFVQBMxsFHGIbERE2FwYGYh0bBjQfBgY2HBBFKBwXDSwNVAQvFkMJIQ0BBC1SCgUyFREIJBwXCTYQGwtveGkxLQwGRTUTEANiEAdFNR1DDCcNEQY1UgIaIREdESQRFx0wGBhFJQAKDjZDfm9wXENCaD0bBjQfBgY2GAAMLhxDHjFZPQgxHgYFJxcABDUbDAZoU05FAh0OGCMLEUU2GgIcYh0bBjQfBgY2GAAMLhxDGyMAB0U1GgZIIwsXDSgGBgs2DAYAYQELBzcVEEUjF0NAEDw1IQw3T0gDKzctCCYmKxYsJiBvHwdEYh0RFigVDUgmFhcWbVIiLBAKXUU2GxcAYg4cBDVSFwAnWRcKJRdDCSENAQQtHhpIKxQECSQfBgY2ClpFDR0MA2IfGxd7eENIYlRUIS4RFgUnFwAAJVIABy8JGwskHBcbYg0cBDVSDQdiFRsLJhcRSCcBHRY1eENIYlRULCwCDw0vHBoRJBZDCy0UBAovFw0cMVkaCjVSDg0sDR0KLxcHSCsXVAEuERBiYllUSGE2BhshCx0HJBZDASwNERcgERcBLRcHRTUaAhxiHR0DJxcRSCQLGwhhEwAcNxgYRSIdBw1iCRURKQFpSGJZWUUOBxcMIw0RAWEGBgsqFxsJLhUaSDAcEgAzFw0LJwpUDC9SBwchCn5vc1xDQmg6GwsnGwQdMBgADC4cQx4xWSYAIB4KHDtTXl9hMQwFMhgGAGERDAYkEBMQMxMXAS0XVAMoHgYbYlEwCiIZBhpiOhsIMR0QDW5ZP10yUg4JLBASADIGEERiOj1KAjZDCy0XEgwmAU9IIwsXDSMLFw1sABUILVtDHysNHEUgERcdIxVUFTMdCQ0hDVQWNQAWCzYMBgBvUiAAJxofRScdEVJIWVRFbFIwDTAPHQYkAUMMJx8dCyQWQwEsWTAKIhkGGmI6GwgxHRANYhsBEWEfChsxEBoCYRQRBy9ZFwolFwEJMRx+RWFSTkgHFwIMMx0NBScXAEU3ExEBIxsYADJSEQ0kHAYALxEGDGIbARFhHAYeJwtUASQUCgYnHX5FYVJOSAAMHQklUhcJMB4RETJSFwAjDVQXJBQGGicXFwBhHAwGbxwMDDIGBgY2WQQENRoQYmJZVEhhMSpHAT1UFSgCBgQrFxEWYQYGGzYQGgJhHwwMNxURFmEGCwk2WRwENxdDCiccGkUzFw4HNBwQb0tBTUhoUz0LNRcNDCcdVCcuBw0MIwsdADJSFRtiOBcRNBMPSAYcBAAvFgYGIRARFmtYWUgBEREGKlIKDmIYBgYpGxcNIQ0BFyAeQwotDBoBIAAKDTFZFRckUgENKxcTRTMXEBgnGgAAJUhpSGJZWUUNExoNMFkCDC4eAhwrFhoWYVoGRiVXWEUUO0MMKwsRBjUeGkgrFAQKMwYKBiVZEAQ1EwEJMRxUCC4WFgQnCl1vYVJDRWI6HRciBw8JMFkQADEXDQwnFxcMJAFDCicNAwAkHEMFLR0BCSQBaUhiWVlFAgAMGzFUGQolBw8NYhAZFS4AFxtiDRwENVIVAS0VFREkUgoGNhwaASQWQwExFhgENRsMBkhZVEVsUjAAIwsRAWEBFwk2HFQKM1IEBC0bFQlhAQoGJRURES4cEEggCxEEKhsND2IcGgYgAhAdLhgADC4caWJ2V1RPazYGCSZZNwolF0NOYiwaEDIXB0gHAQQKMwYQQmhDVCwlFw0cKx8NRSIdBw1iDRwENVICGDIcFRcyUhcHYhsRRTQcFhsnHU5vYVJDRWI8DBUuABcNJlkSEC8RFwEtFwdKIh4CGzEcB0UvFxUNMFkdCDEdERwnHVQALQEGHyocBgBLUkNIb1kmCjQGBkgqGBoBLRcRG2IfGxdhFgYYMBwXBDUXB0gnFxAVLhsNHDFzVEVhX0MuJxgAEDMXQw4uGBMWYRQMGmIaGwgxHgYcJx1UCjNSAgojFxAKLxcHSCQcFRE0AAYbSFlURWxSNycGNlsjCCouLWIaGwgsFw0cMVkdCyUbAAk2EBoCYQcNDisXHRYpFwdINRYGDkt4MQ0xCRsLJVIUATYRVARhODAnDFkbBysXABx4cw9vYVJBDDAQEhEyUFlIGXNURWFSGGJiWVRFYVJBGycPERcoBhpKeFlWDSgVCxQvHBAMNB8fBC0OVklLUkNIYllURyITFw0lFgYcY0hDSiYWF0goHxMEJxQRCzUTFwEtFwgGLhwFASVUBgAgHgocOwUWCjQcBwkwAFkTKB0PCTYQGws9FgYJJlQXCiUXQURIWVRFYVJDSjYQAAkkUFlIYCocCjMGQxwrDRgAY15pSGJZVEVhUAcNMRoGDDEGCgcsW05FYzYGHCMQGAAlUgcNMRoGDDEGCgcsWRsDYQYLDWIdBgwnBkFESFlURWFSQ0onAQQAIgYGDGBDVEcWGgIcYg4VFmEWDAs3FBELNRcHRysXAAAvFgYMYFV+RWFSQ0hiWxUGNQcCBGBDVEcWGgIcYg4VFmEUDB0sHVZJS1JDSGJZVEcnGw8NMVtORRpQAg4kHBcRJBZDDisVERZjL2lIYllUGEtSQzVuc1RFYxAMHSwdFRc4JAoHLhgADC4cEEp4WS9vYVJDSDlzVEVhUkNIYB8GCixQWUhgChsQMxEGSC8WEBAtF0wEIwARF2NeaUhiWVRFYVAXB2BDVEc1ExEPJw1UCC4WFgQnVhgEOBcRSm5zVEVhUkNIYB8dCSRQWUhgHx0JJFIUATYRVBMoHQ8JNhAbC2NeaUhiWVRFYVAKBTIWBhERExcAYENURzUaBkgyCxsHLRcOCTYQF0UoHxMHMA1Wb2FSQ0g/c1RFHF5pSGJbHAAgHhcAERobFyRQWUhyV0RIcFxTREhZVEcyBw4FIwsNR3tSQSc0HAYELR5DDDAQEhFhExAbJwoHCCQcF0pIBH4=");