archbyte 0.1.1 → 0.2.0

package/bin/archbyte.js

@@ -27,7 +27,7 @@ const program = new Command();
 program
   .name('archbyte')
   .description('ArchByte - See what agents build. As they build it.')
-  .version('0.1.1')
+  .version('0.2.0')
   .addHelpText('after', `
   Quick start:
     $ archbyte login       Sign in
@@ -92,9 +92,9 @@ program
   .option('-v, --verbose', 'Show detailed output')
   .option('--provider <name>', 'Model provider: anthropic, openai, google, ollama')
   .option('--api-key <key>', 'Model API key (overrides config)')
-  .option('--premium-only', 'Run only premium agents (requires existing analysis)')
   .option('--static', 'Static-only analysis (no model, free)')
   .option('--skip-llm', 'Alias for --static')
+  .option('--full', 'Force full re-scan (skip incremental detection)')
   .option('--dry-run', 'Preview without running')
   .action(async (options) => {
     await requireLicense('analyze');
@@ -104,7 +104,7 @@ program
 program
   .command('generate')
   .description('Generate diagram from analysis JSON')
-  .option('-i, --input <path>', 'Input analysis JSON (default: .archbyte/analysis.json)')
+  .option('-i, --input <path>', 'Input analysis (default: .archbyte/archbyte.yaml or analysis.json)')
   .option('-o, --output <path>', 'Output diagram (default: .archbyte/architecture.json)')
   .option('-v, --verbose', 'Show detailed output')
   .action(async (options) => {
@@ -173,6 +173,7 @@ program
   .option('-c, --config <path>', 'Path to archbyte.yaml config')
   .option('-i, --interval <duration>', 'Patrol interval: 30s, 5m, 1h (default: 5m)')
   .option('--on-violation <action>', 'Action on new violations: log, json (default: log)')
+  .option('--rescan', 'Incremental re-scan when git commit changes')
   .option('--history', 'Show patrol history dashboard')
   .action(async (options) => {
     await requireLicense('analyze');

package/dist/agents/pipeline/agents/component-identifier.js

@@ -45,8 +45,9 @@ export const componentIdentifier = {
     name: "Component Identifier",
     modelTier: "fast",
     phase: "parallel",
-    buildPrompt(ctx) {
+    buildPrompt(ctx, priorResults) {
         const system = getPrompt("pipeline/component-identifier");
+        const incremental = priorResults?.["__incremental__"];
         const fileTree = formatFileTree(ctx);
         const configs = formatConfigs(ctx);
         const structureInfo = [
@@ -64,11 +65,25 @@ export const componentIdentifier = {
         const dockerInfo = ctx.infra.docker.composeFile
             ? `\n\nDocker Compose services:\n${ctx.infra.docker.services.map((s) => `- ${s.name}${s.image ? ` (image: ${s.image})` : ""}${s.buildContext ? ` (build: ${s.buildContext})` : ""}${s.dependsOn?.length ? ` depends_on: ${s.dependsOn.join(", ")}` : ""}`).join("\n")}`
             : "";
+        let incrementalInfo = "";
+        if (incremental) {
+            const existing = Object.entries(incremental.existingSpec.components)
+                .map(([id, c]) => `- ${id}: ${c.name} (type=${c.type}, layer=${c.layer}, path=${c.path})`)
+                .join("\n");
+            incrementalInfo = `\n\n## INCREMENTAL SCAN — Existing Components (preserve unaffected ones)
+${existing}
+
+Changed files: ${incremental.changedFiles.join(", ")}
+Affected components: ${incremental.affectedComponents.length > 0 ? incremental.affectedComponents.join(", ") : "none (check for new components)"}
+
+IMPORTANT: Return ALL components — both existing unaffected ones AND updated/new ones. Only re-analyze components whose paths overlap with the changed files.`;
+        }
         const user = `Analyze this project and identify ALL architecturally significant components.
 
 ${structureInfo}
 ${docNotes}
 ${dockerInfo}
+${incrementalInfo}
 
 ## File Tree (depth 3, ${ctx.fileTree.totalFiles} files, ${ctx.fileTree.totalDirs} dirs)
 ${fileTree}

package/dist/agents/pipeline/agents/connection-mapper.js

@@ -85,6 +85,23 @@ export const connectionMapper = {
                 parts.push(`- ${r.kind}: ${r.name}${r.namespace ? ` (ns=${r.namespace})` : ""}`);
             }
         }
+        // Incremental context
+        const incremental = priorResults?.["__incremental__"];
+        if (incremental) {
+            const existingConns = incremental.existingSpec.connections
+                .map((c) => `- ${c.from} → ${c.to} (${c.type}${c.async ? ", async" : ""}): ${c.description}`)
+                .join("\n");
+            const existingFlows = incremental.existingSpec.flows
+                .map((f) => `- ${f.name}: ${f.description}`)
+                .join("\n");
+            parts.push(`\n## INCREMENTAL SCAN — Existing Connections (preserve unaffected)`);
+            if (existingConns)
+                parts.push(`Connections:\n${existingConns}`);
+            if (existingFlows)
+                parts.push(`Flows:\n${existingFlows}`);
+            parts.push(`Affected components: ${incremental.affectedComponents.join(", ") || "none"}`);
+            parts.push("Re-evaluate connections involving affected components. Keep connections between unaffected components as-is. Return ALL connections.");
+        }
         return { system, user: parts.join("\n") };
     },
     parseResponse(raw) {
@@ -116,6 +133,7 @@ export const connectionMapper = {
                     result.flows.push({
                         name: f.name,
                         description: typeof f.description === "string" ? f.description : "",
+                        category: typeof f.category === "string" ? f.category : "system",
                         steps: Array.isArray(f.steps) ? f.steps.filter((s) => typeof s === "string") : [],
                     });
                 }

package/dist/agents/pipeline/agents/flow-detector.js

@@ -8,8 +8,9 @@ export const flowDetector = {
     name: "Flow Detector",
     modelTier: "fast",
     phase: "parallel",
-    buildPrompt(ctx) {
+    buildPrompt(ctx, priorResults) {
         const system = getPrompt("pipeline/flow-detector");
+        const incremental = priorResults?.["__incremental__"];
         const parts = [];
         // Event patterns from static scanner
         if (ctx.events.hasEDA) {
@@ -62,6 +63,13 @@ export const flowDetector = {
                 }
             }
         }
+        // Incremental context
+        if (incremental) {
+            parts.push(`\n## INCREMENTAL SCAN — Scope to changes`);
+            parts.push(`Changed files: ${incremental.changedFiles.join(", ")}`);
+            parts.push(`Affected components: ${incremental.affectedComponents.join(", ") || "none"}`);
+            parts.push("Focus event detection on the changed files. Preserve existing patterns for unchanged areas.");
+        }
         return { system, user: parts.join("\n") };
     },
     parseResponse(raw) {

package/dist/agents/pipeline/agents/service-describer.js

@@ -8,8 +8,9 @@ export const serviceDescriber = {
     name: "Service Describer",
     modelTier: "fast",
     phase: "parallel",
-    buildPrompt(ctx) {
+    buildPrompt(ctx, priorResults) {
         const system = getPrompt("pipeline/service-describer");
+        const incremental = priorResults?.["__incremental__"];
         const parts = [];
         // Structure info
         parts.push(`Project: ${ctx.structure.projectName || "(unknown)"}`);
@@ -57,6 +58,22 @@ export const serviceDescriber = {
         if (ctx.infra.cloud.provider) {
             parts.push(`\nCloud: ${ctx.infra.cloud.provider}, services: ${ctx.infra.cloud.services.join(", ")}`);
         }
+        // Incremental context
+        if (incremental) {
+            const existingDbs = Object.entries(incremental.existingSpec.databases)
+                .map(([id, d]) => `- ${id}: ${d.name} (${d.type})`)
+                .join("\n");
+            const existingExt = Object.entries(incremental.existingSpec["external-services"])
+                .map(([id, s]) => `- ${id}: ${s.name} (${s.type})`)
+                .join("\n");
+            parts.push(`\n## INCREMENTAL SCAN — Existing Data (preserve unless evidence of change)`);
+            if (existingDbs)
+                parts.push(`Databases:\n${existingDbs}`);
+            if (existingExt)
+                parts.push(`External services:\n${existingExt}`);
+            parts.push(`Changed files: ${incremental.changedFiles.join(", ")}`);
+            parts.push("Return ALL databases and external services — both existing and any new ones.");
+        }
         return { system, user: parts.join("\n") };
     },
     parseResponse(raw) {

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

@@ -1,11 +1,12 @@
 import type { StaticContext } from "../static/types.js";
 import type { StaticAnalysisResult } from "../static/types.js";
 import type { LLMProvider, ArchByteConfig } from "../runtime/types.js";
+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): Promise<StaticAnalysisResult & {
+export declare function runPipeline(ctx: StaticContext, provider: LLMProvider, config: ArchByteConfig, onProgress?: (msg: string) => void, incrementalContext?: IncrementalContext): Promise<StaticAnalysisResult & {
     tokenUsage?: {
         input: number;
         output: number;

package/dist/agents/pipeline/index.js

@@ -19,12 +19,18 @@ function isAuthError(err) {
  * 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) {
+export async function runPipeline(ctx, provider, config, onProgress, incrementalContext) {
     const agentResults = {};
     const agentMeta = [];
+    // Pass incremental context to agents via priorResults
+    if (incrementalContext) {
+        agentResults["__incremental__"] = incrementalContext;
+    }
     // === Phase 1: Parallel agents ===
     onProgress?.(`Phase 1: Running ${PARALLEL_AGENTS.length} agents in parallel...`);
-    const parallelResults = await Promise.allSettled(PARALLEL_AGENTS.map((agent) => runAgent(agent, ctx, provider, config, undefined, onProgress)));
+    // Pass agentResults to parallel agents too (contains __incremental__ if set)
+    const parallelPrior = incrementalContext ? agentResults : undefined;
+    const parallelResults = await Promise.allSettled(PARALLEL_AGENTS.map((agent) => runAgent(agent, ctx, provider, config, parallelPrior, onProgress)));
     let authFailed = false;
     for (let i = 0; i < PARALLEL_AGENTS.length; i++) {
         const agent = PARALLEL_AGENTS[i];
@@ -70,7 +76,7 @@ export async function runPipeline(ctx, provider, config, onProgress) {
     }
     // === Merge results ===
     onProgress?.("Merging agent outputs...");
-    const merged = mergeAgentOutputs(ctx, agentResults["component-identifier"] ?? null, agentResults["service-describer"] ?? null, agentResults["flow-detector"] ?? null, agentResults["connection-mapper"] ?? null, agentResults["validator"] ?? null);
+    const merged = mergeAgentOutputs(ctx, agentResults["component-identifier"] ?? null, agentResults["service-describer"] ?? null, agentResults["flow-detector"] ?? null, agentResults["connection-mapper"] ?? null, agentResults["validator"] ?? null, incrementalContext);
     // === Deterministic validation ===
     merged.validation = validateAnalysis(merged);
     if (merged.validation.repairs.length > 0) {

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

@@ -1,7 +1,7 @@
 import type { StaticAnalysisResult, StaticContext } from "../static/types.js";
-import type { ComponentIdentifierOutput, ServiceDescriberOutput, FlowDetectorOutput, ConnectionMapperOutput, ValidatorOutput } from "./types.js";
+import type { ComponentIdentifierOutput, ServiceDescriberOutput, FlowDetectorOutput, ConnectionMapperOutput, ValidatorOutput, IncrementalContext } from "./types.js";
 /**
  * Merge all pipeline agent outputs into a StaticAnalysisResult
  * compatible with the existing buildAnalysisFromStatic() in cli/analyze.ts.
  */
-export declare function mergeAgentOutputs(ctx: StaticContext, componentId: ComponentIdentifierOutput | null, serviceDesc: ServiceDescriberOutput | null, flowDet: FlowDetectorOutput | null, connMap: ConnectionMapperOutput | null, validatorOut: ValidatorOutput | null): StaticAnalysisResult;
+export declare function mergeAgentOutputs(ctx: StaticContext, componentId: ComponentIdentifierOutput | null, serviceDesc: ServiceDescriberOutput | null, flowDet: FlowDetectorOutput | null, connMap: ConnectionMapperOutput | null, validatorOut: ValidatorOutput | null, incrementalContext?: IncrementalContext): StaticAnalysisResult;

package/dist/agents/pipeline/merger.js

@@ -4,7 +4,7 @@
  * Merge all pipeline agent outputs into a StaticAnalysisResult
  * compatible with the existing buildAnalysisFromStatic() in cli/analyze.ts.
  */
-export function mergeAgentOutputs(ctx, componentId, serviceDesc, flowDet, connMap, validatorOut) {
+export function mergeAgentOutputs(ctx, componentId, serviceDesc, flowDet, connMap, validatorOut, incrementalContext) {
     // Start with components from component-identifier
     const components = [];
     if (componentId?.components) {
@@ -20,6 +20,21 @@ export function mergeAgentOutputs(ctx, componentId, serviceDesc, flowDet, connMa
             });
         }
     }
+    // Incremental merge: if agent returned components, they should include all.
+    // But if agent returned nothing, fall back to existing spec components.
+    if (incrementalContext && components.length === 0) {
+        for (const [id, c] of Object.entries(incrementalContext.existingSpec.components)) {
+            components.push({
+                id,
+                name: c.name,
+                type: c.type,
+                layer: c.layer,
+                path: c.path,
+                description: c.description,
+                technologies: c.tech,
+            });
+        }
+    }
     const componentIds = new Set(components.map((c) => c.id));
     // Add databases from service-describer as components
     if (serviceDesc?.databases) {
@@ -55,6 +70,21 @@ export function mergeAgentOutputs(ctx, componentId, serviceDesc, flowDet, connMa
             }
         }
     }
+    // Incremental fallback: if service-describer returned nothing, restore from spec
+    if (incrementalContext && !serviceDesc) {
+        for (const [id, d] of Object.entries(incrementalContext.existingSpec.databases)) {
+            if (!componentIds.has(id)) {
+                components.push({ id, name: d.name, type: "database", layer: "data", path: "", description: d.description, technologies: [d.type] });
+                componentIds.add(id);
+            }
+        }
+        for (const [id, s] of Object.entries(incrementalContext.existingSpec["external-services"])) {
+            if (!componentIds.has(id)) {
+                components.push({ id, name: s.name, type: "service", layer: "external", path: "", description: s.description, technologies: [s.type] });
+                componentIds.add(id);
+            }
+        }
+    }
     // Apply validator type corrections
     if (validatorOut?.componentTypeCorrections) {
         for (const comp of components) {
@@ -176,11 +206,39 @@ export function mergeAgentOutputs(ctx, componentId, serviceDesc, flowDet, connMa
     }
     // Remove connections flagged by validator
     const removedKeys = new Set(validatorOut?.removedConnectionKeys ?? []);
-    const filteredConnections = removedKeys.size > 0
+    let filteredConnections = removedKeys.size > 0
         ? connections.filter((c) => !removedKeys.has(`${c.from}::${c.to}::${c.type}`))
         : connections;
+    // Incremental fallback: if connection-mapper returned nothing, restore existing connections
+    if (incrementalContext && !connMap && filteredConnections.length === 0) {
+        for (const c of incrementalContext.existingSpec.connections) {
+            if (!componentIds.has(c.from) || !componentIds.has(c.to))
+                continue;
+            const key = `${c.from}::${c.to}::${c.type}`;
+            if (connKeys.has(key))
+                continue;
+            connKeys.add(key);
+            filteredConnections.push({
+                from: c.from,
+                to: c.to,
+                type: c.type,
+                description: c.description,
+                confidence: 80,
+                async: c.async,
+            });
+        }
+    }
     // Build flows
-    const flows = connMap?.flows ?? [];
+    let flows = connMap?.flows ?? [];
+    // Incremental fallback: restore existing flows if connection-mapper returned none
+    if (incrementalContext && flows.length === 0 && incrementalContext.existingSpec.flows.length > 0) {
+        flows = incrementalContext.existingSpec.flows.map((f) => ({
+            name: f.name,
+            description: f.description,
+            category: f.category,
+            steps: f.steps.map((s) => `${s.from} \u2192 ${s.to}`),
+        }));
+    }
     // Override structure fields from service-describer
     const structure = { ...ctx.structure };
     if (serviceDesc?.primaryLanguage && structure.language === "unknown") {
@@ -203,6 +261,7 @@ export function mergeAgentOutputs(ctx, componentId, serviceDesc, flowDet, connMa
             flows: flows.map((f) => ({
                 name: f.name,
                 description: f.description,
+                category: f.category,
                 steps: f.steps,
             })),
         },

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

@@ -64,6 +64,7 @@ export interface ConnectionMapperOutput {
     flows: Array<{
         name: string;
         description: string;
+        category: string;
         steps: string[];
     }>;
 }
@@ -81,6 +82,48 @@ export interface ValidatorOutput {
     confidence: number;
     issues: string[];
 }
+export interface IncrementalContext {
+    existingSpec: {
+        components: Record<string, {
+            name: string;
+            type: string;
+            layer: string;
+            path: string;
+            tech: string[];
+            description: string;
+        }>;
+        databases: Record<string, {
+            name: string;
+            type: string;
+            description: string;
+        }>;
+        "external-services": Record<string, {
+            name: string;
+            type: string;
+            description: string;
+        }>;
+        connections: Array<{
+            from: string;
+            to: string;
+            type: string;
+            description: string;
+            async: boolean;
+        }>;
+        flows: Array<{
+            id: string;
+            name: string;
+            description: string;
+            category: string;
+            steps: Array<{
+                from: string;
+                to: string;
+                label: string;
+            }>;
+        }>;
+    };
+    changedFiles: string[];
+    affectedComponents: string[];
+}
 export interface PipelineAgentResult {
     agentId: string;
     data: unknown;

package/dist/agents/prompt-data.js

@@ -1,15 +1,8 @@
 // Auto-generated by prompts-encode.ts — DO NOT EDIT
 // Run: node agents/prompts-encode.ts
 import { registerPrompt } from "./prompts.js";
-registerPrompt("premium/api-contract-verifier", "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");
-registerPrompt("premium/compliance-checker", "GB0WSCMLEUUgUgAHLwkYDCAcAA1iGBoELQsQATFZFQIkHBdGYiAbEDNSCQcgWR0WYQYMSCcPFQk0ExcNYhhUFi4UFx8jCxFFIAAAACsNEQY1BxENYhgTBCgcEBxiGhsILB0NSCEWGRUtGwIGIRxUAzMTDg01FgYOMlJLOw06RklhOio4AzhYRQY2MzpuWSQmCF8nOxFQVAQvFkMBJhwaESgUGkglGAQWb3hpKSwYGBw7F0McKhxUFTMdCQ0hDVQELxZDGicNARcvUgJICCo7K2EdAQInGgBFNhsXAGINHAwyUhAcMAwXETQABlJIAn5FYVAQHS8UFRc4UFlIYBsGDCQUQwstFAQJKBMNCydZBAoyBhYaJ1kVFjIXEBsvHBoRY15pSGJbFRUxHgoLIxsYAAcAAgUnDhsXKgFBUmIiVjYOMVFKbllWIgUiMUpuWRERIlw+REhZVEcuBAYaIxUYNiIdEQ1gQ1QLNB8BDTBZXFVsQ1NYa1V+RWFQBRojFBESLgAIG2BDVB5LUkNIYlsnKgJAQVJiAn5FYVJDSGJbBwYuAAZKeFkaECwQBhpuc1RFYVJDSGAKAAQ1BxBKeFlWBi4fEwQrGBoRYQ5DGCMLAAwgHg8RHRobCDEeCgksDVQZYRwMBh0aGwgxHgoJLA1UGWEcDBwdGAQVLRsACSAVEUdteENIYllURWMUCgYmEBoCMlBZSBlzVEVhUkNIYlkPb2FSQ0hiWVRFYVJBCy0XABcuHkFSYls3JndcUkhvWTgKJhsACS5ZFQslUjMAOwodBiAeQykhGhEWMlIgBywNBgotAUFESFlURWFSQ0hiWVRHMgYCHDcKVl9hUA4NNlkIRTETERwrGBhFPVIECTJZCEUvHRc3IwkECSgRAgouHFZJS1JDSGJZVEVhUkNKJw8dASQcAA1gQ1RHNhoCHGIOFRZhFAwdLB1WSUtSQ0hiWVRFYVJDSiUYBEd7UkEfKhgAQjJSDgExCh0LJlJLASRZFQs4W0FESFlURWFSQ0hiWVRHMxcABy8UEQslExcBLRdWX2FQCwc1WQAKYQAGBScdHQQ1F0FiYllURWFSQ0g/c1RFYVJDSB9zVEVhUh5ESFlURWFQJCwSK1ZfYQlDRmxXVBhteENIYllWLQgiIilgQ1QeYVxNRmIEWG9hUkNIYCk3LB42MDtgQ1QeYVxNRmIEfkVhD09iYllWASAGAiAjFxAJKBwESnhZD29hUkNIYAkdDAUXFw0hDREBY0hDCi0WGAAgHE9iYllURWMCCwEGHAAAIgYGDGBDVAcuHQ8NIxdYb2FSQ0hgCRUcLBcNHAYYAAQFFxcNIQ0RAWNIQwotFhgAIBxPYmJZVEVjFgIcIz8YCjYBQVJiIlYJKAEXSC0fVAEgBgJIJBUbEmEWBhshCx0VNRsMBjFbKUlLUkNIYlsHES4AAg8nNRsGIAYKBywKVl9hKUEfKhwGAGEBBgYxEAAMNxdDDCMNFUUoAUMbNhYGACVQPkRIWVRFYVAGBiELDRU1GwwGAw0mADIGQVJiGxsKLRcCBm5zVEVhUkENLBoGHDEGCgcsMBoxMxMNGysNVl9hEAwHLhwVC0tSQxVuc1RFYwAGCy0UGQAvFgIcKxYaFmNIQzNgCQYMLgAKHCsDEQFhEQwFMhUdBC8RBkgrFAQXLgQGBScXABZjL2kVSHM9CzIGER0hDR0KLwFZYnNXVCkuHQhIJBYGRRE7KkcSMT1FKRMNDC4QGgJhWhYbJwtUASAGAkRiEREELQYLSDAcFwozFhBEYgkRFzIdDQkuWR0LJx1KYnBXVCYpFwADYh8bF2EWAhwjWRELIgAaGDYQGwthWgIcYgsRFjVSAgYmWR0LYQYRCSwKHRFoeFBGYjUbCipSBQcwWRUQJRsXSC4WEwIoHARIIxcQRSARAA0xClQGLhwXGi0VB291XEMrKhwXDmEUDBpiHRURIFIRDTYcGhEoHQ1HJhwYADUbDAZiCRsJKBEKDTFZHQthEQwMJ1kbF2ERDAYkEBNvdFxDOicPHQA2UgIdNhERCzUbAAk2EBsLYRMNDGIYAREpHREBOBgADC4cQwUnGhwELxsQBTFzQkthMQsNIRJUAy4AQy8GKSZIMgIGCysfHQZhAgIcNhwGCzJSSwstFwcALwZPSCYYAARhAgwaNhgWDC0bFxFuWQYMJhoXSDYWVAAzExAdMBxdb3ZcQyQtFh9FJx0RSDIYDQgkHBdIMgsbBiQBEAEsHlRNETEqRQYqJ0UzFw8NNBgaBiRbaVBsWT0BJBwXASQAVAEgBgJIMQ0bFyAVBkguFhcENRsMBjFZXAEgBgIKIwoRFm1SAAkhEREWbVIFAS4cVBY1HRENMVB+XG9SLAYuAFQEMgEGGzFZEhcgHwYfLQsfFmEGCwk2WRUXJFIRDS4cAgQvBkMcLVkADSRSBw02HBcRJBZDDCMNFUU1CxMNMXNFVW9SMQ02DAYLYT0tJBtZAA0kUik7DTdUCiMYBgs2VVQLLlIMHCocBkU1Fxsc");
-registerPrompt("premium/dependency-risk-scorer", "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");
-registerPrompt("premium/drift-detector", "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");
-registerPrompt("premium/migration-planner", "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");
-registerPrompt("premium/performance-analyzer", "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");
-registerPrompt("premium/security-auditor", "GB0WSCMLEUUgUhANIQwGDDULQwk3HR0RYRMEDSwNVBYxFwABIxUdHygcBEgrF1QEMxELATYcFxE0AAIEYgoRBjQAChw7WRULIB4aGysKWkUYHRYaYhMbB2EbEEg2FlQMJRcNHCsfDUUyFwAdMBAAHGEEFgQsHAYEIxsPATYQERZtUg4BMRobCycbBB0wGAAMLhwQRGIYGgFhEw0cK1QEBDUGBhosClQENVIXACdZFRciGgocJxoAEDMXQwQnDxEJb3hpKSwYGBw7F0McKhxUFTMdCQ0hDVQELxZDGicNARcvUgJICCo7K2EdAQInGgBFNhsXAGINHAwyUhAcMAwXETQABlJIAn5FYVAQHS8UFRc4UFlIYBsGDCQUQwc0HAYELR5DGycaARcoBhpIMhYHETQABkgjCgcAMgEODSwNVklLUkNKMBAHDg0XFQ0uW05FYxERATYQFwQtUh9IKhATDWEOQwUnHR0QLFIfSC4WA0dteENIYAoXCjMXQVJiFwEIIxcRSGpJWVRxQk9INRERFyRSUlhyWR0WYRQWBC4AVBYkERYaJ1BYb2FSQQ4rFxAMLxUQSnhZL29hUkNIOXNURWFSQ0hgEBBHe1JBOwc6WVVxQ0FESFlURWFSQ0oxHAIAMxsXEWBDVEciAAocKxoVCWEOQwArHhxFPVIODSYQAQhhDkMELQ5UGWEbDQ4tW1hvYVJDSGJZVgYgBgYPLQsNR3tSQQk3DRwALwYKCyMNHQovUh9IIwwADS4AChIjDR0KL1IfSCsXHgAiBgoHLFkIRSQKEwcxDAYAYQ5DCy0XEgwmBxEJNhAbC2EOQwswAAQRLhURCTIRDUU9UgcNMhwaASQcAAEnClQZYR4MDyUQGgJjXmlIYllURWFQFwE2FRFHe1JBGyoWBhFhBgocLhxWSUtSQ0hiWVRHJRcQCzAQBBEoHQ1KeFlWASQGAgEuHBBFJRcQCzAQBBEoHQ1ILR9UESkXQx43FRoAMxMBAS4QABxjXmlIYllURWFQDwchGAAMLhxBUmJbEgwtF0MYIw0cRS4AQwstFAQKLxcNHGBVfkVhUkNIYlsGACIdDgUnFxAENRsMBmBDVEcpHRRINhZUAygKQwE2W1hvYVJDSGJZVgo2ExAYEBwSR3tSQScVOCc1YRECHCceGxc4UgoOYhgEFS0bAAkgFRFFaRdND2xZNVVwSFFYcEhZJzMdCA0sWTUGIhcQG2I6Gws1AAwEa1t+RWFSQxVIWVQ4bXhDSGAYAREpNA8HNQpWX2EpaUhiWVQeS1JDSGJZVEcvEw4NYENURyceDB9iFxUIJFBPYmJZVEVhUkEcOwkRR3tSQSIVLVQZYQEGGzEQGwthDkMnAwwADWEOQykSMFQOJAtDFGIbFRYoEUMUYhQgKRJQT2JiWVRFYVJBGycaARckUFlIIBYbCSQTDURIWVRFYVJDSisKBxAkAUFSYiJWCSgBF0gtH1QMMgEWDTFbKW9hUkNIP3NURRxeaUhiWwcAIgAGHAcBBAoyBxENYENUPktSQ0hiAn5FYVJDSGJbEgwtF0FSYlsEBDUaQURIWVRFYVJDSjYABABjSENKAyk9RSoXGkg+WQQEMgEUBzAdVBlhBgwDJxdUGWERBho2EBIMIhMXDWIFVAYuHA0NIQ0dCi9SEBwwEBoCY15pSGJZVEVhUBANNBwGDDULQVJiWxcXKAYKCyMVVBlhGgoPKlkIRSwXBwE3FFZvYVJDSD9zVEUcXmlIYlsGACIdDgUnFxAENRsMBjFbTkUaUBMaKxYGDDUbGQ0mWRgMMgZDByRZBwAiBxEBNgBUDCwCEQc0HBkALwYQSh9zCW9LOw0bNgsBBjUbDAYxQ35Ub1IwDSMLFw1hFAwaYhgBESkXDRwrGhURKB0NRyMMAA0uAAoSIw0dCi9SEwk2DREXLwFDQAguIElhAQYbMRAbCzJeQycDDAANbVIiOAtZHwA4AUpicFdUJikXAANiHxsXYRoCGiYaGwEkFkMbJxoGADUBT0gDKT1FKhcaG25ZBAQyARQHMB0HRWkVEQ0yWRIKM1IABy8UGwthAgIcNhwGCzJbaVtsWTgKLhlDDi0LVDYQPkMBLBMRBjUbDAZuWSw2El5DCy0UGQQvFkMBLBMRBjUbDAZiDxEGNR0RG0hNWkUCGgYLKVk3KhMhQwstFxIMJgcRCTYQGwttUiA7ElkcACAWBhoxVVQWJBEWGisNDUUpFwIMJwsHb3RcQyksGBgcOxdDDCcJEQslFw0LO1kSDC0XEEgkFgZFKhwMHyxZAhAtHAYaIxsYAGECAhw2HAYLMnhVRmI6HAAiGUMOLQtUFiQRFhonWQAXIBwQGC0LAEVpOjc8EipYRRU+MEFITlpFDR0MA2IfGxdhHgwPJRAaAmEdBUgxHBoWKAYKHidZEAQ1E2lQbFk3DSQRCEgkEBgAYQcTBC0YEEUpEw0MLhAaAm1SCgYyDABFNxMPASYYAAwuHGlRbFkmADcbBh9iHBoTKAAMBi8cGhFhBAIaKxgWCSRSCwksHRgMLxVpWXJXVDckBhYaLFk7Kw0rQxwqHFQvEj0tSC0bHgAiBk9ILBZUCjUaBhpiDREdNQ==");
 registerPrompt("pipeline/component-identifier", "GB0WSCMLEUUgHEMNOgkRFzVSEAckDQMEMxdDCTAaHAw1FwAcbFktCjQAQwItG1QMMlIXB2IQEAAvBgoOO1kREyQAGkgjCxcNKAYGCzYMBgQtHhpIMRATCygUCgsjFwBFIh0OGC0XEQs1UgoGYhhUFi4UFx8jCxFFMQAMAicaAEtLeCJIYBobCDEdDQ0sDVZFKAFDCWIdHRY1Gw0LNlkQADEeDBEjGxgAYQcNATZVVBYkABUBIRxYRSACEwQrGhURKB0NRGIVHQczExERblkbF2EBCg8sEBIMIhMNHGIUGwE0HgZGYjAaBi0HBw14c1lFAxMAAycXEEUyFxEeKxoRFm1SIjgLClhFNh0RAycLB29sUiUaLRcAAC8WQwkyCRgMIhMXAS0XB0VpBQYKblkZCiMbDw1rc1lFDRsBGiMLHQAyXRMJIRIVAiQBQ0ArF1QILhwMGicJGxZoeE5IATU9RTUdDAQxc1lFBRMXCSAYBwAyUksBJFkRHTEeCgsrDRgcYREMBiQQExAzFwdEYhxaAm9SCgZiHRsGKhcRRSEWGRUuAQZBSFRUIDkGBhosGBhFMhcRHisaERZhWgZGJVdUNyQWChtuWSYEIxAKHA8oWEUEHgIbNhAXFiQTEQsqUH5vBx0RSCcYFw1hEQwFMhYaAC8GT0gyCxsTKBYGUkhUVAwlSEMDJxsVB2wRAhsnWQcJNBVDQCdXE0ttUkEJMhBZFiQAFQ0wW1hFYwUGCm8fBgovBgYGJltdb2xSDQkvHE5FKQcOCSxUBgAgFgIKLhxUCyAfBmJvWQAcMRdZSC0XEUUuFENKJAsbCzUXDQxgVVRHIAIKSm5ZVhYkABUBIRxWSWFQFAcwEhEXY15DSi4QFhcgABpKbllWBi0bQURiWxAENRMBCTEcVklhUAQJNhwDBDhQT0hgGhUGKRdBRGJbBRAkBwZKSFRUCSALBhp4WRsLJFIMDmJbBBckAQYGNhgADC4cQURiWxUVMR4KCyMNHQovUE9IYB0VESBQT0hgHAwRJAANCS5bfkhhAgIcKkNUFyQeAhwrDxFFJRsRDSENGxc4UhMJNhFUTSRcBEZuWVYWJAAVDTBbWEVjExMYMVYDACNQSmJvWRAAMhERATINHQovSENZb0tUFiQcFw0sGhFFJRcQCzAQBBEoHQ1ILR9UFTQAEwcxHH5IYQYGCyoXGwkuFQoNMUNUBDMAAhFiFhJFKhcaSDYcFw0vHQ8HJRARFmFaBkYlV1hFGlA3ETIcJwYzGxMcYFVURwQKExonCgdHbVJBOC0KAAIzFzA5DlspTEt4MQ0xCRsLJVIUATYRVCoPPjpII1k+Ng48QwcgExEGNUhDE2JbFwosAgwGJxcAFmNIQzNsV1o4YQ8=");
-registerPrompt("pipeline/connection-mapper", "GB0WSCMLEUUgHEMNOgkRFzVSEAckDQMEMxdDCTAaHAw1FwAcbFktCjQAQwItG1QMMlIXB2IUFRVhMy8kYhobCy8XABwrFhoWYRAGHDUcEQthEQwFMhYaAC8GEEgrF1QEYQEMDjYOFRckUhARMQ0RCG94aSstFxoAIgYKByxZABwxFxBSSFRURygfEwcwDVZfYRYKGicaAEUiHQcNYhAZFS4AF0cmHAQALxYGBiEAfkhhUAscNglWX2EgJjsWVhM3ETFMIBYtJEUiEw8EMXNZRWMWAhwjGxUWJFBZSCEWGRUuHAYGNlkGACAWEEc1Cx0RJAFDHC1ZFUUlExcJIBgHAEtfQ0onDxELNVBZSCMKDQsiUgYeJxcASiwXEBsjHhFFaQIWCm0KAQdtUhIdJwwRFmh4TkhgHgYVIlBZSCUrJCZhEQIELgp+SGFQFA0gChsGKhcXSnhZIwAjIQwLKRwARSIdDQYnGgAMLhwQYm9ZVgMoHgZKeFkHDSAABgxiHx0JJAEaGzYcGUUgEQANMQp+bwcdEUgnGBcNYREMBiwcFxEoHQ1SSFRUAzMdDlJiChsQMxEGSCEWGRUuHAYGNlk9IWFaDh0xDVQIIAYAAGIYGkUkCgobNhAaAmERDAUyFhoALwZDIQZZER0gERcEO1B+SGEGDFJiDRUXJhcXSCEWGRUuHAYGNlk9IWFaDh0xDVQIIAYAAGIYGkUkCgobNhAaAmERDAUyFhoALwZDIQZZER0gERcEO1B+SGEGGhgnQ1QKLxdDByRZAA0kUhcRMhwHRSAQDB4nc1lFJRcQCzAQBBEoHQ1SYhsGDCQUQwwnChcXKAIXAS0XVAonUhcAJ1kGAC0TFwEtFwcNKAJpRWIYBxwvEVlINgsBAGEbBUgjCg0LIhoRBywWARZhWgYeJxcAFm1SEh0nDBEWaHhpKS4KG0UoFgYGNhASHGFYSQ4uFgMWa1hDisLtVAAvFk4cLVQRCyVSEQ0zDBEWNVITCTYRB0U1GhEHNx4cRTUaBkgxAAcRJB9ZYm9ZGgQsF1lIJBUbEmEcAgUnWVwAbxVNRGJbIRYkAEM6Jx4dFjUAAhwrFhpHaHhOSCYcBwYzGxMcKxYaX2EFCwk2WRwEMQIGBjFzWUUyBgYYMUNUBDMAAhFiFhJFMgYRASweB0lhFwILKlkxPQAxNyQbWR0LYQYLDWIfGxcsExdIYBobCDEdDQ0sDT0BYZDl+mIaGwgxHQ0NLA09AWNSSw1sHlpJYVAUDSBUEhcuHBcNLB1Uh8fgQwkyEFkWJAAVDTBbWEVjExMBbwoRFzcXEUig/+ZFMR0QHCULERYwHkFBbFkxBCIaQxs2HARFLAcQHGIaGws1EwoGYhwMBCIGDxFiFhoAYZDl+mIYBhcuBUMfKw0cRSBSFQkuEBBFIh0OGC0XEQs1UiosYhYaRSQTAABiCh0BJFxDLC1ZOioVUhYbJ1kSFyQXThwnAQBFJRcQCzAQBBEoHQ0bYhgHRTIGBhgxV35vCD8zJxAtNSsVSEM9MRxUESkXQy0aODcxYREMBTIWGgAvBkMhBgpUAzMdDkg2ERFFIh0OGC0XEQs1AUMEKwoAS2E3FQ0wAFQDMx0ORzYWVAwvUgAHLBcRBjUbDAYxWTUrBVIGHicLDUUiHQ4YLRcRCzVSKixiEBpFJx4MH2IKAAAxAUMFNwoARTMXBQ0wHBoGJFICSDQYGAwlUgAHLwkbCyQcF0gLPVQDMx0OSDYREUUtGxAcYhgWCjcXTUgGFlQrDiZDASwPEQs1UgAHLwkbCyQcF0gLPQdFLgBDHTEcVAMzFwZFNhwMEWEWBhshCx0VNRsMBjFXfm8TFxAYLRcQRTYbFwBiNjopGFICSAgqOythHQECJxoAX0sJaUhiWxcKLxwGCzYQGwsyUFlIGVdaSxxeaUhiWxIJLgUQSnhZL0tvXD5iPw==");
+registerPrompt("pipeline/connection-mapper", "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");
 registerPrompt("pipeline/flow-detector", "GB0WSCMLEUUgHEMNOgkRFzVSEAckDQMEMxdDCTAaHAw1FwAcbFk1CyAeGhInWQANJFITGi0TEQY1UgAHLA0RHTVSAgYmWR0BJBwXASQATm9LQ01IaFMREyQcFystFxoAIgYKBywKXk97UiYeJxcASCUACh4nF1QGLh8OHSwQFwQ1GwwGYgkVETUXEQYxWVwIJAEQCSUcVBQ0FxYNMVVUFTQQTBs3G1hFNhcBAC0WHxZtUgYeJxcARSQfChw2HAYWaFxpSGJZMgozUgYJIRFORTpSEx0gFR0WKRcRRGIKAQcyEREBIBwGSWERCwksFxEJbVIXDSERGgotHQQRYgR+RWFSTkgyDBYJKAELDTBWBxAjAQAaKxsRF3tSAAcvCRsLJBwXSAs9B0VpGQYKIxtZBiABBkgxFQECMltpSGJZWUUiGgIGLBwYX2EXFQ0sDVsRLgIKC20IAQA0F0MGIxQRb2FSQ0ViDREGKRwMBC0eDV9hBgsNYgoEACIbBQEhWQAAIhoNBy4WExxhBxANJllcAG8VTURiWxETJBwXRScUHRE1FxFKbllWEiQQCwctElZMS3hRRmJTXgQxGzEHNw0RFmtYWUgDKT1FMx0WHCcKWwAvFhMHKxcAFmEWBhwnGgAAJVIFGi0UVAYuFgZIMhgAESQADRtsc1RFYTQMGmIcFQYpSEMTYgkVESleQwUnDRwKJV5DACMXEAkkACUBLhxUGEt4IDoLLT0mAD5ZSA0XGBxhAAYYLQsARSQEBgY2WRcKLxwGCzYQGwsyUgIGJlkGCjQGBhtiDRwENVILCTQcVCYOPCA6By0xRQQkKiwHNzcgYRsNSDYREUUxAAweKx0RAWERDAwnWQcELAIPDTFVVBY1ExcBIVkHBiAcDQ0wWQYAMgcPHDFVVAozUicHIRIRF2EBBho0EBcAMlxDISRZAA0kUhAcIw0dBmEBAAksFxEXYQECETFZVisuUgYeJxcASCUACh4nF1QVIAYXDTAXB0UlFxcNIQ0RAWNeQxonDQEXL1IGBTINDUUkBAYGNjobCy8XABwrFhoWb1InB2I3OzFhGw0eJxcARTETFxwnCxoWYQYLCTZZFRckUg0HNlkREygWBgYhHBBFKBxDHCocVAwvAhYcbHN+NyQBEwcsHVQSKAYLSA03ODxhE0MiETY6RS4QCQ0hDU5vOnhDSGAcAgAvBiAHLBcRBjUbDAYxW05FGlxNRh9VfkVhUAIYKysbEDUXEEp4WS9Lb1w+Yj9zfiwnUg0HYgkVETUXEQYxWRIKNBwHRGILERE0AA1IJxQEEThSAhowGA0Wbw==");
 registerPrompt("pipeline/service-describer", "GB0WSCMLEUUgHEMNOgkRFzVSEAckDQMEMxdDCTAaHAw1FwAcbFk1CyAeGhInWQANJFITGi0TEQY1UgAHLA0RHTVSAgYmWR0BJBwXASQATm9LQ01IaFMEFy4YBgs2PREWIgAKGDYQGwtrWFlIA1kXCSQTEUhwVEdFMhcNHCcXFwBhFgYbIQsdFTUbDAZiFhJFNhoCHGINHAwyUhMaLRMRBjVSBwcnClpvc1xDQmgJBgwsExERDhgaAjQTBA1oU05FFRoGSC8YHQthAhEHJQsVCCwbDQ9iFRULJgcCDydZXABvFU1EYlsgHDEXMAswEAQRY15DShIAAA0uHEFEYlszCmNeQ0oQDAcRY1tNYnFXVE9rFgIcIxsVFiQBSUJ4WTAENRMBCTEcB0U0AQYMYhAaRTUaChtiCQYKKxcAHGxzQEthWEkNOg0RFy8TDzsnCwIMIhcQQmhDVCA5BgYaLBgYRTIXER4rGhEWbjMzITFZFwovARYFJx1UBzhSFwArClQVMx0JDSENWm9LNAwaYh0VESAQAhsnClQELxZDDToNERcvEw87JwsCDCIXEERiCQYKNxsHDXhzWUUoFllIKRwWBCNfAAkxHFQWLQcEYm9ZGgQsF1lIKgwZBC9fEQ0jHRUHLRdDBiMUEW9sUhcRMhxORTUXAAAsFhgKJgtDHDsJEUVpF00PbFVURzEdEBwlCxEWMB5BRGJbBgAlGxBKbllWFjUAChgnW11vbFIHDTEaBgwxBgoHLENUEikTF0grDVMWYQcQDSZZEgozeE5INwoRAQMLWUgjCwYEOFIMDmIaGwgxHQ0NLA1ULAUBQxwqGABFNAEGSDYRHRZhWhYbJ1kfACMTAUUhGAcAYQEPHSUKVAggBgAAKxcTRTUaBkghFhkVLhwGBjZZGgQsFxBBSHM3NwgmKisDNU5FDhwPEWIQGgYtBwcNYh0VESAQAhsnClQELxZDDToNERcvEw9IMRwGEygRBhtiDRwENVILCTQcVCYOPCA6By0xRQQkKiwHNzcgYRsNSDYREUUiHQcNIBgHAHt4TkgSGBcOIBUGRyYcBAAvFgYGIQBUDCwCDBo2ClRNJFwERm5ZVhUmUE9IYAsRASgBQURiWwcRMxsTDWBVVEcBExQbbwoQDm4RDwEnFwBIMkFBQUhUVCAvBAoaLRcZAC8GQx4jCx0EIx4GG2ILEQMkAAYGIRAaAmEGCw0vWVwAbxVNRGI9NTEAMCI7ByYhNw1eQzoHPT02HicxJG5ZJzETOzMtHSoxJhM3NzcJPC1MS19DLC0aHwAzUiAHLwkbFiRSEA0wDx0GJAFDHysNHEUsExcLKhAaAmEbDgklHAdvbFIgBywfHQI0AAIcKxYaRScbDw0xWQYAJxcRDSwaHQsmUhcAJxR+SGE2ChonGgBFNAECDydZHQthEQwMJ1kHBCwCDw0xWQQXLgQKDCcdfm8FHUMmDS1UAjQXEBtiFgZFKBwFDTBZBwAzBAoLJwpUESkTF0gvEBMNNVIBDWIMBwAnBw9GYj0bRQ89N0grFxcJNBYGSDEcBhMoEQYbYhMBFjVSAQ0hGAEWJFIXACdZBBcuGAYLNllWBi4HDwxgWQEWJFIXACcUWkUIFEMcKhwGAGEbEEgsFlQGLhwAGicNEUUkBAoMJxcXAG1SBwdiFxsRYRsNCy4MEABhGxdGSHMmADICDAYmWQMMNRpDJww1LUUgUik7DTdUCiMYBgs2WRkENRELASweVBEpGxBIMRocACwTWWI5c1RFYwIRBygcFxEFFxALMBAEESgdDUp4WVZLb1xBREhZVEcxAAoFIwsNKSAcBB0jHhFHe1JBRmxXVklLUkNKJhgABCMTEA0xW05FGlxNRh9VfkVhUAYQNhwGCyAeMA0wDx0GJAFBUmIiWktvL2kV");
 registerPrompt("pipeline/validator", "GB0WSCMLEUUgUhAHJA0DBDMXQwkwGhwMNRcAHDcLEUUzFxUBJw4RF29SNQkuEBAENRdDHCocVAQvEw8RMRAHRTMXEB0uDQdFIBwHSDEMEwIkARdIIRYGFyQRFwEtFwdLS3ggACcaH0UnHRFSSEhaRWtYLBoyERULYREMBTIWGgAvBhBCaENUJi4fEwcsHBoRMlIUATYRVB8kAAxIIRYaCyQRFwEtFwdFNRoCHGIKHAo0HgdIIBxUBi4cDQ0hDREBS0BNSGhTIxcuHARIIRYZFS4cBgY2WQAcMRcQQmhDVABvFU1EYhhUNyQTABxiGAQVYQYaGCcdVAQyUkEbJwsCDCIXQUgxERsQLRZDCidZVgMzHQ0cJxcQR0tBTUhoUzkMMgEKBiVZFwovHAYLNhAbCzJYSVJiNhYTKB0WG2ILEQkgBgoHLAocDDEBQwYtDVQGIAIXHTAcEG91XENCaC4RBCpSBw0xGgYMMQYKBywKXk97UiAHLwkbCyQcFxtiDh0RKVIGBTINDUUuAEMdLBoYACAAQwwnChcXKAIXAS0XB0Wj8vdIMgsbEygWBkggHAARJABDBywcB290XENCaD0BFS0bAAk2HFsXJBYWBiYYGhFhEQwFMhYaAC8GEEJoQ1QmLh8TBywcGhEyUhcAIw1UFikdFgQmWRYAYR8GGiUcEG9LIAYbMhYaAWEFChwqWTsrDStDCWIzJyoPUgwKKBwXEXt4GGJiWVYGLh8TBywcGhEVCxMNARYGFyQRFwEtFwdHe1IYSGAaGwgxHQ0NLA1ZDCVQWUhgGhsXMxcAHG8NDRUkUEMVbnNURWMRDAUyFhoALwYnDTEaBgwxBgoHLApWX2EJQ0ohFhkVLhwGBjZUHQFjSENKIBwAESQAQwwnChcXKAIXAS0XVkU8XmlIYlsVASUXBystFxoAIgYKBywKVl9hKRhIYB8GCixQWUhgEBBHbVJBHC1bTkVjGwdKbllWETgCBkp4WVYROAIGSm5ZVgEkAQAaKwkADC4cQVJiWxAAMhFBRGJbFRY4HABKeFkSBC0BBkg/JFhvYVJBGicUGxMkFiAHLBcRBjUbDAYJHA0WY0hDM2AfBgosSFkcLUNOETgCBkofVX5FYVAABywfHQEkHAANYENUVW9KVkRIWVRHKAEQHScKVl9hKUEMJwoXFygCFwEtF1QKJ1ICBjtZBgAsEwoGKxcTRSgBEB0nClY4Sw9pYhcKEUUkHxMcO1kbBysXABwxVhUXMxMaG2IQEkUvHUMLLQsGACIGCgcsClQLJBcHDSZXVDEpF0MLLRcSDCUXDQsnWQcGLgAGSGpJWVRoUhENJBURBjUBQxEtDAZFLgQGGiMVGEUiHQ0OKx0RCyIXQwEsWQANJFICBiMVDRYoAUMZNxgYDDULTQ==");

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

@@ -96,6 +96,7 @@ export interface ConnectionResult {
     flows: Array<{
         name: string;
         description: string;
+        category?: string;
         steps: string[];
     }>;
 }

package/dist/cli/analyze.d.ts

@@ -4,10 +4,10 @@ interface AnalyzeOptions {
     verbose?: boolean;
     provider?: string;
     apiKey?: string;
-    premiumOnly?: boolean;
     static?: boolean;
     skipLlm?: boolean;
     dryRun?: boolean;
+    full?: boolean;
 }
 export declare function handleAnalyze(options: AnalyzeOptions): Promise<void>;
 /**
@@ -15,13 +15,4 @@ export declare function handleAnalyze(options: AnalyzeOptions): Promise<void>;
  * flat analysis.json format expected by generate.ts.
  */
 export declare function buildAnalysisFromStatic(result: StaticAnalysisResult, projectRoot: string): Record<string, unknown>;
-/**
- * Aggregate agent results into the analysis.json format expected by the generator.
- * Used by legacy mode (--legacy flag) only.
- */
-export declare function buildAnalysis(agents: Array<{
-    agentId: string;
-    data: unknown;
-    confidence: number;
-}>, projectRoot: string): Record<string, unknown>;
 export {};