archbyte 0.1.0

package/dist/agents/pipeline/index.js

@@ -0,0 +1,128 @@
+// Pipeline — Orchestrator
+// Runs static context collection → parallel LLM agents → sequential LLM agents
+import { resolveModel } from "../runtime/types.js";
+import { validateAnalysis } from "../static/validator.js";
+import { componentIdentifier } from "./agents/component-identifier.js";
+import { serviceDescriber } from "./agents/service-describer.js";
+import { flowDetector } from "./agents/flow-detector.js";
+import { connectionMapper } from "./agents/connection-mapper.js";
+import { validator } from "./agents/validator.js";
+import { mergeAgentOutputs } from "./merger.js";
+const PARALLEL_AGENTS = [componentIdentifier, serviceDescriber, flowDetector];
+const SEQUENTIAL_AGENTS = [connectionMapper, validator];
+/** Check if an error is an authentication/API key issue */
+function isAuthError(err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return /401|authentication_error|invalid.*api.?key|unauthorized|invalid.*key/i.test(msg);
+}
+/**
+ * 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) {
+    const agentResults = {};
+    const agentMeta = [];
+    // === 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)));
+    let authFailed = false;
+    for (let i = 0; i < PARALLEL_AGENTS.length; i++) {
+        const agent = PARALLEL_AGENTS[i];
+        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)`);
+        }
+        else {
+            const reason = result.status === "rejected" ? result.reason : "null response";
+            onProgress?.(`  ${agent.name}: failed (${reason})`);
+            if (result.status === "rejected" && isAuthError(result.reason)) {
+                authFailed = true;
+            }
+        }
+    }
+    if (authFailed) {
+        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.`);
+    }
+    // === Phase 2: Sequential agents ===
+    onProgress?.(`Phase 2: Running ${SEQUENTIAL_AGENTS.length} agents sequentially...`);
+    for (const agent of SEQUENTIAL_AGENTS) {
+        try {
+            const result = await runAgent(agent, ctx, provider, config, agentResults, onProgress);
+            if (result) {
+                agentResults[agent.id] = result.data;
+                agentMeta.push(result);
+                onProgress?.(`  ${agent.name}: done (${(result.duration / 1000).toFixed(1)}s)`);
+            }
+            else {
+                onProgress?.(`  ${agent.name}: returned null`);
+            }
+        }
+        catch (err) {
+            onProgress?.(`  ${agent.name}: failed (${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.`);
+            }
+        }
+    }
+    // === 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);
+    // === Deterministic validation ===
+    merged.validation = validateAnalysis(merged);
+    if (merged.validation.repairs.length > 0) {
+        onProgress?.(`Applied ${merged.validation.repairs.length} deterministic repair(s)`);
+    }
+    // Log token usage
+    const totalInput = agentMeta.reduce((s, a) => s + (a.tokenUsage?.input ?? 0), 0);
+    const totalOutput = agentMeta.reduce((s, a) => s + (a.tokenUsage?.output ?? 0), 0);
+    if (totalInput > 0) {
+        onProgress?.(`Token usage: ${totalInput} in / ${totalOutput} out`);
+    }
+    return { ...merged, tokenUsage: { input: totalInput, output: totalOutput } };
+}
+// Agents that produce large structured output (lists of components/connections) need more tokens
+const MAX_TOKENS = {
+    "component-identifier": 8192,
+    "connection-mapper": 8192,
+    "service-describer": 4096,
+    "flow-detector": 4096,
+    "validator": 4096,
+};
+async function runAgent(agent, ctx, provider, config, priorResults, onProgress) {
+    const start = Date.now();
+    const model = resolveModel(config.provider, agent.modelTier, config.modelOverrides);
+    const { system, user } = agent.buildPrompt(ctx, priorResults);
+    onProgress?.(`  ${agent.name}: calling ${model}...`);
+    const maxTokens = MAX_TOKENS[agent.id] ?? 4096;
+    const response = await provider.chat({
+        model,
+        system,
+        messages: [{ role: "user", content: user }],
+        maxTokens,
+    });
+    // Detect truncation
+    if (response.stopReason === "max_tokens") {
+        onProgress?.(`  ${agent.name}: response truncated at ${maxTokens} tokens — output may be incomplete`);
+    }
+    const text = response.content
+        .filter((b) => b.type === "text")
+        .map((b) => b.text ?? "")
+        .join("");
+    if (!text)
+        return null;
+    const data = agent.parseResponse(text);
+    if (!data) {
+        onProgress?.(`  ${agent.name}: could not parse response (${text.length} chars, stop=${response.stopReason})`);
+        return null;
+    }
+    return {
+        agentId: agent.id,
+        data,
+        duration: Date.now() - start,
+        tokenUsage: { input: response.usage.inputTokens, output: response.usage.outputTokens },
+    };
+}

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

@@ -0,0 +1,7 @@
+import type { StaticAnalysisResult, StaticContext } from "../static/types.js";
+import type { ComponentIdentifierOutput, ServiceDescriberOutput, FlowDetectorOutput, ConnectionMapperOutput, ValidatorOutput } 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;

package/dist/agents/pipeline/merger.js

@@ -0,0 +1,212 @@
+// Pipeline — Merger
+// Assembles all agent outputs into a StaticAnalysisResult
+/**
+ * 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) {
+    // Start with components from component-identifier
+    const components = [];
+    if (componentId?.components) {
+        for (const c of componentId.components) {
+            components.push({
+                id: c.id,
+                name: c.name,
+                type: c.type,
+                layer: c.layer,
+                path: c.path,
+                description: c.description,
+                technologies: c.technologies,
+            });
+        }
+    }
+    const componentIds = new Set(components.map((c) => c.id));
+    // Add databases from service-describer as components
+    if (serviceDesc?.databases) {
+        for (const db of serviceDesc.databases) {
+            if (!componentIds.has(db.id)) {
+                components.push({
+                    id: db.id,
+                    name: db.name,
+                    type: "database",
+                    layer: "data",
+                    path: "",
+                    description: db.description,
+                    technologies: [db.type],
+                });
+                componentIds.add(db.id);
+            }
+        }
+    }
+    // Add external services from service-describer as components
+    if (serviceDesc?.externalServices) {
+        for (const svc of serviceDesc.externalServices) {
+            if (!componentIds.has(svc.id)) {
+                components.push({
+                    id: svc.id,
+                    name: svc.name,
+                    type: "service",
+                    layer: "external",
+                    path: "",
+                    description: svc.description,
+                    technologies: [svc.type],
+                });
+                componentIds.add(svc.id);
+            }
+        }
+    }
+    // Apply validator type corrections
+    if (validatorOut?.componentTypeCorrections) {
+        for (const comp of components) {
+            const corrected = validatorOut.componentTypeCorrections[comp.id];
+            if (corrected)
+                comp.type = corrected;
+        }
+    }
+    // Apply validator description improvements
+    if (validatorOut?.componentDescriptions) {
+        for (const comp of components) {
+            const better = validatorOut.componentDescriptions[comp.id];
+            if (better && better.length > (comp.description?.length ?? 0)) {
+                comp.description = better;
+            }
+        }
+    }
+    // Build connections
+    const connections = [];
+    const connKeys = new Set();
+    // Connections from connection-mapper
+    if (connMap?.connections) {
+        for (const c of connMap.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);
+            connections.push({
+                from: c.from,
+                to: c.to,
+                type: c.type,
+                description: c.description,
+                confidence: 80,
+                async: c.async,
+            });
+        }
+    }
+    // Add database connections from service-describer usedBy
+    if (serviceDesc?.databases) {
+        for (const db of serviceDesc.databases) {
+            for (const userId of db.usedBy) {
+                if (!componentIds.has(userId))
+                    continue;
+                const key = `${userId}::${db.id}::database`;
+                if (connKeys.has(key))
+                    continue;
+                connKeys.add(key);
+                connections.push({
+                    from: userId,
+                    to: db.id,
+                    type: "database",
+                    description: `${userId} uses ${db.name}`,
+                    confidence: 75,
+                    async: false,
+                });
+            }
+        }
+    }
+    // Add external service connections from service-describer usedBy
+    if (serviceDesc?.externalServices) {
+        for (const svc of serviceDesc.externalServices) {
+            for (const userId of svc.usedBy) {
+                if (!componentIds.has(userId))
+                    continue;
+                const key = `${userId}::${svc.id}::http`;
+                if (connKeys.has(key))
+                    continue;
+                connKeys.add(key);
+                connections.push({
+                    from: userId,
+                    to: svc.id,
+                    type: "http",
+                    description: `${userId} uses ${svc.name}`,
+                    confidence: 75,
+                    async: false,
+                });
+            }
+        }
+    }
+    // Add event connections from flow-detector
+    if (flowDet?.eventConnections) {
+        for (const ec of flowDet.eventConnections) {
+            if (!componentIds.has(ec.publisher) || !componentIds.has(ec.subscriber))
+                continue;
+            const key = `${ec.publisher}::${ec.subscriber}::event`;
+            if (connKeys.has(key))
+                continue;
+            connKeys.add(key);
+            connections.push({
+                from: ec.publisher,
+                to: ec.subscriber,
+                type: "event",
+                description: `${ec.channel} via ${ec.technology}`,
+                confidence: 70,
+                async: true,
+            });
+        }
+    }
+    // Add validator corrections
+    if (validatorOut?.addedConnections) {
+        for (const c of validatorOut.addedConnections) {
+            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);
+            connections.push({
+                from: c.from,
+                to: c.to,
+                type: c.type,
+                description: c.description,
+                confidence: 65,
+                async: c.async,
+            });
+        }
+    }
+    // Remove connections flagged by validator
+    const removedKeys = new Set(validatorOut?.removedConnectionKeys ?? []);
+    const filteredConnections = removedKeys.size > 0
+        ? connections.filter((c) => !removedKeys.has(`${c.from}::${c.to}::${c.type}`))
+        : connections;
+    // Build flows
+    const flows = connMap?.flows ?? [];
+    // Override structure fields from service-describer
+    const structure = { ...ctx.structure };
+    if (serviceDesc?.primaryLanguage && structure.language === "unknown") {
+        structure.language = serviceDesc.primaryLanguage;
+    }
+    // Override docs from service-describer
+    const docs = { ...ctx.docs };
+    if (serviceDesc?.projectDescription && serviceDesc.projectDescription.length > (docs.projectDescription?.length ?? 0)) {
+        docs.projectDescription = serviceDesc.projectDescription;
+    }
+    return {
+        structure,
+        docs,
+        components: { components },
+        infra: ctx.infra,
+        events: ctx.events,
+        envs: ctx.envs,
+        connections: {
+            connections: filteredConnections,
+            flows: flows.map((f) => ({
+                name: f.name,
+                description: f.description,
+                steps: f.steps,
+            })),
+        },
+        validation: { valid: true, repairs: [], errors: [] },
+        gaps: [],
+    };
+}

package/dist/agents/pipeline/response-parser.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Extract JSON from LLM response text using 4 fallback strategies.
+ * Returns null if all fail.
+ */
+export declare function extractJSON(raw: string): Record<string, unknown> | null;

package/dist/agents/pipeline/response-parser.js

@@ -0,0 +1,43 @@
+// Pipeline — Response Parser
+// 4-strategy JSON extraction (reused from agents/llm/response-parser.ts)
+/**
+ * Extract JSON from LLM response text using 4 fallback strategies.
+ * Returns null if all fail.
+ */
+export function extractJSON(raw) {
+    // Strategy 1: Direct parse
+    try {
+        const obj = JSON.parse(raw);
+        if (typeof obj === "object" && obj !== null)
+            return obj;
+    }
+    catch {
+        // Continue
+    }
+    // Strategy 2: Extract from markdown code block
+    const codeBlockMatch = raw.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
+    if (codeBlockMatch) {
+        try {
+            const obj = JSON.parse(codeBlockMatch[1]);
+            if (typeof obj === "object" && obj !== null)
+                return obj;
+        }
+        catch {
+            // Continue
+        }
+    }
+    // Strategy 3: Extract first {...} block
+    const braceMatch = raw.match(/\{[\s\S]*\}/);
+    if (braceMatch) {
+        try {
+            const obj = JSON.parse(braceMatch[0]);
+            if (typeof obj === "object" && obj !== null)
+                return obj;
+        }
+        catch {
+            // Continue
+        }
+    }
+    // Strategy 4: Return null
+    return null;
+}

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

@@ -0,0 +1,92 @@
+import type { ModelTier } from "../runtime/types.js";
+import type { StaticContext } from "../static/types.js";
+export interface PipelineAgent {
+    id: string;
+    name: string;
+    modelTier: ModelTier;
+    phase: "parallel" | "sequential";
+    buildPrompt(ctx: StaticContext, priorResults?: Record<string, unknown>): {
+        system: string;
+        user: string;
+    };
+    parseResponse(raw: string): unknown | null;
+}
+export interface ComponentIdentifierOutput {
+    components: Array<{
+        id: string;
+        name: string;
+        type: string;
+        layer: string;
+        path: string;
+        description: string;
+        technologies: string[];
+    }>;
+}
+export interface ServiceDescriberOutput {
+    projectDescription: string;
+    primaryLanguage: string;
+    databases: Array<{
+        id: string;
+        name: string;
+        type: string;
+        description: string;
+        usedBy: string[];
+    }>;
+    externalServices: Array<{
+        id: string;
+        name: string;
+        type: string;
+        description: string;
+        usedBy: string[];
+    }>;
+}
+export interface FlowDetectorOutput {
+    eventConnections: Array<{
+        publisher: string;
+        subscriber: string;
+        channel: string;
+        technology: string;
+    }>;
+    apiRoutes: Array<{
+        path: string;
+        method: string;
+        handlerFile: string;
+    }>;
+}
+export interface ConnectionMapperOutput {
+    connections: Array<{
+        from: string;
+        to: string;
+        type: string;
+        description: string;
+        async: boolean;
+    }>;
+    flows: Array<{
+        name: string;
+        description: string;
+        steps: string[];
+    }>;
+}
+export interface ValidatorOutput {
+    componentTypeCorrections: Record<string, string>;
+    componentDescriptions: Record<string, string>;
+    addedConnections: Array<{
+        from: string;
+        to: string;
+        type: string;
+        description: string;
+        async: boolean;
+    }>;
+    removedConnectionKeys: string[];
+    confidence: number;
+    issues: string[];
+}
+export interface PipelineAgentResult {
+    agentId: string;
+    data: unknown;
+    duration: number;
+    tokenUsage?: {
+        input: number;
+        output: number;
+    };
+}

package/dist/agents/pipeline/types.js

@@ -0,0 +1,3 @@
+// Pipeline Agent Framework — Types
+// Simpler than ArchByteAgent: no tools, just prompt → JSON
+export {};

package/dist/agents/prompt-data.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/agents/prompt-data.js

@@ -0,0 +1,15 @@
+// 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", "GB0WSCMLEUUgHEMJMBocDDUXABw3CxUJYRYRASQNVAEkBgYLNhAbC2ETBA0sDVpFGB0WGmITGwdhGxBINhZUBi4fEwkwHFQRKRdDASwNEQslFwdIIwsXDSgGBgs2DAYAYVoCG2IdERYiAAoKJx1UDC9SBwchDBkALwYCHCsWGklhEQwGJBATRScbDw0xVVQELxZDDCcKHQIvUgcHIQpdRTYbFwBiDRwAYRMAHDcYGEUoHxMEJxQRCzUTFwEtF1QELxZDASYcGhEoFBpIJgsdAzVcaWIDFxUJOAgGSDYREUUxAAwCJxoARSAcB0gwHAAQMxxDCWIzJyoPUgwKKBwXEWEFChwqWQANKAFDGzYLAQY1BxENeHMPb2FSQRs3FBkEMwtBUmJbFhcoFwVIJgsdAzVSAhsxHAcWLBcNHGBVfkVhUAcaKx8AKSQEBgRgQ1RHLx0NDWIFVAkuBUMUYhQbASQAAhwnWQhFMhsEBisfHQYgHBdIPlkXFygGCgsjFVZJS1JDSjEaGxckUFlILAwZByQAQ0ByVEVVcV5DHyocBgBhQ1NYYhAHRTEXEQ4nGgBFIB4KDywUEQs1W09iYllWDC8GBgYmHBAkMxELATYcFxE0AAZKeFkPb2FSQ0hgChsQMxEGG2BDVD5jHgobNlkbA2EWDAsxVhcKLxQKDzFZAA0gBkMMJwoXFygQBkgrFwAALxYGDGIYBgYpGxcNIQ0BFyRQPkRIWVRFYVAHDTEaBgwxBgoHLFtORWMFCwk2WQANJFICGiERHREkERcdMBxUDDJSEB0yCRsWJBZDHC1ZGAouGUMEKxIRR0tSQxVuc1RFYxYRASQNB0d7UjhiYllURTp4Q0hiWVRFYxsHSnhZViETOyU8b0lEVGNeaUhiWVRFYVAQDTQcBgw1C0FSYlsXFygGCgsjFVQZYRoKDypZCEUsFwcBNxRUGWEeDB9gVX5FYVJDSGJbFwQ1FwQHMABWX2FQEBwwDBcRNAACBGIFVAEkAgYGJhwaBjhSH0gsGBkMLxVDFGIbGxAvFgIaO1kIRTETFxwnCxpFPVIKBiQLFRY1ABYLNgwGAGNeaUhiWVRFYVAXATYVEUd7UkEbKhYGEWEGChwuHFZJS1JDSGJZVEcoHBcNLB0RAWNIQ0o1ERURYQUCG2IKARUxHRANJlkACmEQBkg2ERFFIhMQDWBVfkVhUkNIYlsVBjUHAgRgQ1RHNhoCHGIYFxE0Ew8EO1kRHSgBFxtiEBpFIh0HDWBVfkVhUkNIYlsYCiITFwEtF1ZfYVAFAS4cVAozUgAHLwkbCyQcF0gyGAANY15pSGJZVEVhUAcNMRoGDDEGCgcsW05FYxYGHCMQGAAlUgYQMhUVCyAGCgcsWRsDYQYLDWIdBgwnBkFESFlURWFSQ0owHBcKLB8GBiYYAAwuHEFSYlscCjZSFwdiCxEELRsEBmBzVEVhUh5iYlkpSUtSQ0ogFgELJRMRERQQGwkgBgoHLApWX2EpaUhiWVQeS1JDSGJZVEcnAAwFYENURyIdDhgtFxELNVIXACMNVAYzHRAbJwpUBy4HDQwjCw1HbXhDSGJZVEVjBgxKeFlWBi4fEwcsHBoRYQYLCTZZBw0uBw8MLF4ARSMXQwkhGhEWMhcHSCYQBgAiBg8RYFV+RWFSQ0hiWwAcMRdBUmJbHQgxHREcYgVUJBE7QwsjFRhFPVIHCTYYFgQyF0MJIRoRFjJSH0gkEBgAYRMACycKB0dteENIYllURWMXFQEmHBoGJFBZSGAfHQkkSA8BLBxUCjNSEwk2DREXL1BPYmJZVEVhUkEMJwoXFygCFwEtF1ZfYVAUADtZAA0oAUMBMVkVRTcbDAQjDR0KL1BpSGJZVBhLUkM1bnNURWMcAgUrFxMsLxEMBjEQBxEkHAABJwpWX2EpaUhiWVQeS1JDSGJZVEciExcNJRYGHGNIQ0okEBgAMlIfSDQYBgwgEA8NMVkIRQAiKhtiBVQBIAYCCiMKEUU9UgAHLB8dAmNeaUhiWVRFYVAGECMUBAkkAUFSYiJWFjEXAAEkEBdFKBwABywKHRY1Fw0LKxwHRScdFgYmWylJS1JDSGJZVEciHQ0eJxcADC4cQVJiWwMNIAZDHCocVAYuHBUNLA0dCi9SEAAtDBgBYRAGSkhZVEVhD2lIYiRYb2FSQQwnGBAmLhYGSnhZL29hUkNIOXNURWFSQ0hgDQ0VJFBZSGAMGhAyFwc3JwEECjMGQxRiDBoXJBMAACMbGAAeAAwdNhxUGWEdERgqGBo6JxsPDWIFVAEkEwc3JBwVETQABjckFRUCY15pSGJZVEVhUA8HIRgADC4cQVJiWxIMLRdDBzBZFwosAgwGJxcAR214Q0hiWVRFYxYGGyELHRU1GwwGYENURzYaAhxlClQBJBMHSCMXEEU2GhpKSFlURWEPaUhiJFhvYVJBGicaGwgsFw0MIw0dCi8BQVJiIlYVMxsMGisNHR8kFkMaJxgYDCYcDg0sDVQWNRcTG2AkfhhLeCoGMQ0GECIGCgcsCk5vcFxDOicYEEUgAAAAKw0RBjUHEQ1iHRsGNB8GBjYYAAwuHENAEDw1IQw3T0gDKzctCCYmKxYsJiBvHwdEYj0xNgg1LUYvHVhFADYxG25ZNykAJyctbBQQSWEzJC0MLSdLLBZKYnBXVDckEwdIIRYaAygVFhojDR0KL1IFAS4cB0U1GgIcYh0RAygcBkgxDQYQIgYWGidZXAQzEQsKOw0RSzgTDgRuWQQXLhgGCzZZFwovFAoPMVB+Vm9SIAcvCRUXJFIHByEMGQAvBgYMYhobCDEdDQ0sDQdFNhsXAGIYFxE0Ew9IJhAGACIGDBo7WQcRMwcAHDcLEW91XEMrKhwXDmEUDBpiFRUcJABDHisWGAQ1GwwGMVlcAG8VTURiHRURIFIPCTscBkUoHxMHMA0dCyZSBRotFFQVMxcQDSwNFREoHQ1ILhgNADNbaV1sWTgKLhlDDi0LVAYoAAAdLhgGRSUXEw0sHRELIhsGG2IbERE2FwYGYhQbATQeBhtIT1pFCBYGBjYQEhxhFgYJJlkXCiUXT0g3FwEWJBZDDToJGxc1AU9ILQsEDSAcBgxiHx0JJAFpX2xZNw0kEQhILBgZDC8VQwstFwIALwYKBywKVAMuAEMLLRcHDDIGBgYhAH5db1IgBy8JFRckUgcHIQwZAC8GBgxiOCQsYREMBjYLFQY1AUMfKw0cRSgfEwQnFBELNRMXAS0XB294XEMkLRYfRScdEUgkHBURNAAGSCQVFQIyUgwaYhobCycbBEgkFgZFJxcCHDcLERZhBgsJNlkaCmEeDAYlHAZFJAoKGzZzRVVvUjENNgwGC2E9LSQbWQANJFIpOw03VAojGAYLNlVUCy5SDBwqHAZFNRcbHA==");
+registerPrompt("premium/migration-planner", "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");
+registerPrompt("premium/performance-analyzer", "GB0WSCMLEUUgUhMNMB8bFywTDQsnWRULIB4aGysKVAQmFw0cbFktCjQAQwItG1QMMlIXB2IQEAAvBgoOO1kVFyIaChwnGgAQMxMPSCAWABEtFw0NIRIHSWEBAAkuEBoCYRsQGzccB0lhEw0MYgkRFycdEQUjFxcAYRMNHCtUBAQ1BgYaLApab0szDQkuAA4AYQYLDWIJBgorFwAcYhgaAWEABhw3CxpFIFIpOw03VAojGAYLNlkDDDUaQxwqEAdFMgYRHSENARckSGkTSFlURzIHDgUjCw1He1JBCjAQEQNhAgYaJBYGCCAcAA1iGAcWJAEQBScXAEdteENIYBYCADMTDwQQGAAMLxVBUmJbER0iFw8EJxcART1SBActHVQZYRQCATBZCEUxHQwaYgVUBjMbFwEhGBhHbXhDSGAbGxE1HgYGJxofFmNIQzNIWVRFYQlpSGJZVEVhUAoMYENURxE3MS5vSURUY15pSGJZVEVhUBANNBwGDDULQVJiWxcXKAYKCyMVVBlhGgoPKlkIRSwXBwE3FFQZYR4MH2BVfkVhUkNIYlsXCiwCDAYnFwBHe1JBCy0UBAovFw0cYhcVCCRQT2JiWVRFYVJBHDsJEUd7UkEMIw0VByABBkg+WRoANQUMGilZCEUiHQ4YNw0RRT1SDg0vFgYcYQ5DAS1ZCEUiHQ0LNwsGAC8RGkpuc1RFYVJDSGAdERYiAAoYNhAbC2NIQ0o1ERURYQYLDWIbGxE1HgYGJxofRSgBQURIWVRFYVJDSisUBAQiBkFSYlsDDSAGQwAjCQQALwFDHSwdERdhHgwJJltYb2FSQ0hiWVYXJBEMBS8cGgEgBgoHLFtORWMaDB9iDRtFJxsbSCsNVm9hUkNIP3NURRxeaUhiWwcGIB4KBiU4GgQtCxABMVtORTp4Q0hiWVYNLgAKEi0XAAQtIQAJLhgWDC0bFxFgQ1RHMxcCDDtZCEUxExEcKxgYRT1SAQQtGh8AJVBPYmJZVEVjBAYaNhAXBC0+CgUrDRURKB0NG2BDVD5jHgobNlkbA2EEBho2EBcELVIQCyMVHQsmUgAHLBoRFy8BQTVuc1RFYVJBGzYYAAAnBw8GJwoHR3tSOEouEAcRYR0FSDENFREkFBYEYhobCDEdDQ0sDQdFNRoCHGIbGAoiGUMALQsdHy4cFwkuWQcGIB4KBiVbKUlLUkNIYlsHDSAABgwQHAcKNAAADTFbTkUaUAcJNhgWBDIXEERiGhUGKRcQRGIWBkUuBgsNMFkHDSAABgxiGxsRNR4GBicaHxZjL2lIYgRYb2FSQQksDR01IAYXDTAXB0d7UjhiYllURTp4Q0hiWVRFYwICHDYcBgtjSENKDFJFRTAHBhorHAdFPVIQESwaHBcuHAwdMVkXDSAbDRtiBVQLLlIACSERHQsmUh9INxcWCjQcBw0mWQUQJAcGG2IFVAA1EU1KbnNURWFSQ0hgFRsGIAYKByxbTkVjFAoEJ1kbF2ERDAUyFhoALwZBREhZVEVhUkNKJhwHBjMbExwrFhpHe1JBDCcNFQwtAUFESFlURWFSQ0okEAxHe1JBGicaGwgsFw0MIw0dCi9QaUhiWVQYS1JDNW5zVEVjEQILKhAaAmNIQxNIWVRFYVAQHDAYAAAmC0FSYlsaCi8XQxRiFRsGIB5DFGIdHRY1AAoKNw0RAWEOQysGN1QZYR8WBDYQWQkgCwYaYFV+RWFSQ0ohGBcNJD4CEScLB0d7UjhKLhAHEWEdBUghGBcNKBwESC8cFw0gHAobLwpUAy4HDQxgJFhvYVJDSGAeFRUyUFlIGVsDDSQABkghGBcNKBwESDERGxAtFkMKJ1kVASUXB0ofc1RFPF5pSGJbEAQ1EwEJMRwkADMUDBovGBoGJFBZSDlzVEVhUkEBLB0RHSgcBEp4WVYEJRcSHSMNEUU9UgoGMQwSAygRCg0sDVQZYQcNAywWAwtjXmlIYllURzAHBho7KRURNRcRBjFbTkUaUA0HNhgWCSRSEh0nCw1FMRMXHCcLGhZjL09iYllURWMRDAYsHBcRKB0NOC0WGAwvFUFSYhsbCi0XAgZuc1RFYVJBGicYEDckAg8BIRgHR3tSAQctFREEL3hDSD9VfkVhUBENIRYZCCQcBwk2EBsLMlBZSBlbBBcoHREBNhAOACVSEw0wHxsXLBMNCydZHQgxAAweJxQRCzUBQTVIBH5vCBwQHDAMFxEoHQ0beHNFS2E+DAcpWRIKM1IHCTYYFgQyF0MZNxwGHGECAhw2HAYLMlJLJmlIWEUsGxAbKxcTRSgcBw06HAdJYRQWBC5ZAAQjHgZIMRoVCzJbaVpsWTcNJBEISCQWBkUiEwAAKxcTRTIGEQk2HBMMJAFDQBAcEAwyXkMlJxQXBCIaBgxuWR0LbB8GBS0LDUxLQU1ICx0RCzUbBRFiCg0LIhoRBywWARZhEAwcNhURCyQRCBtiURYJLhEIASweVCxuPU9IMRwFECQcFwEjFVQkETtDCyMVGBZoeFdGYjUbCipSBQcwWRcKLxwGCzYQGwthAgwHLhAaAmERDAYkEBMQMxMXAS0XflBvUiAAJxofRScdEUgjCg0LIl0SHScMEUgjExANJlkEFy4RBhsxEBoCYQICHDYcBgsyeFVGYisREygXFEgwHAcKNAAADWIVHQgoBhBIahobCzUTCgYnC1QXJAEMHTAaERZtUhEJNhxUCSgfChwrFxNMS0VNSA4WGw5hFAwaYgkVAigcAhwrFhpFKBxDBCsKAEUkHAcYLRAaETJ4W0ZiOhwAIhlDDi0LVAc0HghILQkRFyAGCgcsClQTMlxDASwdHRMoFhYJLlkXBC0eEGJ7V1QsJRcNHCsfDUUyBgIcJx8BCWERDAUyFhoALwYQSDYRFRFhEA8HIRJUDS4AChItFwAELVIQCyMVHQsmeFJYbFkmADUHEQZiNjopGFIXACdZPjYOPEMHIBMRBjVeQwYtWRsRKRcRSDYcDBE=");
+registerPrompt("premium/security-auditor", "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");
+registerPrompt("pipeline/component-identifier", "GB0WSCMLEUUgHEMNOgkRFzVSEAckDQMEMxdDCTAaHAw1FwAcbFktCjQAQwItG1QMMlIXB2IQEAAvBgoOO1kREyQAGkgjCxcNKAYGCzYMBgQtHhpIMRATCygUCgsjFwBFIh0OGC0XEQs1UgoGYhhUFi4UFx8jCxFFMQAMAicaAEtLeCJIYBobCDEdDQ0sDVZFKAFDCWIdHRY1Gw0LNlkQADEeDBEjGxgAYQcNATZVVBYkABUBIRxYRSACEwQrGhURKB0NRGIVHQczExERblkbF2EBCg8sEBIMIhMNHGIUGwE0HgZGYjAaBi0HBw14c1lFAxMAAycXEEUyFxEeKxoRFm1SIjgLClhFNh0RAycLB29sUiUaLRcAAC8WQwkyCRgMIhMXAS0XB0VpBQYKblkZCiMbDw1rc1lFDRsBGiMLHQAyXRMJIRIVAiQBQ0ArF1QILhwMGicJGxZoeE5IATU9RTUdDAQxc1lFBRMXCSAYBwAyUksBJFkRHTEeCgsrDRgcYREMBiQQExAzFwdEYhxaAm9SCgZiHRsGKhcRRSEWGRUuAQZBSFRUIDkGBhosGBhFMhcRHisaERZhWgZGJVdUNyQWChtuWSYEIxAKHA8oWEUEHgIbNhAXFiQTEQsqUH5vBx0RSCcYFw1hEQwFMhYaAC8GT0gyCxsTKBYGUkhUVAwlSEMDJxsVB2wRAhsnWQcJNBVDQCdXE0ttUkEJMhBZFiQAFQ0wW1hFYwUGCm8fBgovBgYGJltdb2xSDQkvHE5FKQcOCSxUBgAgFgIKLhxUCyAfBmJvWQAcMRdZSC0XEUUuFENKJAsbCzUXDQxgVVRHIAIKSm5ZVhYkABUBIRxWSWFQFAcwEhEXY15DSi4QFhcgABpKbllWBi0bQURiWxAENRMBCTEcVklhUAQJNhwDBDhQT0hgGhUGKRdBRGJbBRAkBwZKSFRUCSALBhp4WRsLJFIMDmJbBBckAQYGNhgADC4cQURiWxUVMR4KCyMNHQovUE9IYB0VESBQT0hgHAwRJAANCS5bfkhhAgIcKkNUFyQeAhwrDxFFJRsRDSENGxc4UhMJNhFUTSRcBEZuWVYWJAAVDTBbWEVjExMYMVYDACNQSmJvWRAAMhERATINHQovSENZb0tUFiQcFw0sGhFFJRcQCzAQBBEoHQ1ILR9UFTQAEwcxHH5IYQYGCyoXGwkuFQoNMUNUBDMAAhFiFhJFKhcaSDYcFw0vHQ8HJRARFmFaBkYlV1hFGlA3ETIcJwYzGxMcYFVURwQKExonCgdHbVJBOC0KAAIzFzA5DlspTEt4MQ0xCRsLJVIUATYRVCoPPjpII1k+Ng48QwcgExEGNUhDE2JbFwosAgwGJxcAFmNIQzNsV1o4YQ8=");
+registerPrompt("pipeline/connection-mapper", "GB0WSCMLEUUgHEMNOgkRFzVSEAckDQMEMxdDCTAaHAw1FwAcbFktCjQAQwItG1QMMlIXB2IUFRVhMy8kYhobCy8XABwrFhoWYRAGHDUcEQthEQwFMhYaAC8GEEgrF1QEYQEMDjYOFRckUhARMQ0RCG94aSstFxoAIgYKByxZABwxFxBSSFRURygfEwcwDVZfYRYKGicaAEUiHQcNYhAZFS4AF0cmHAQALxYGBiEAfkhhUAscNglWX2EgJjsWVhM3ETFMIBYtJEUiEw8EMXNZRWMWAhwjGxUWJFBZSCEWGRUuHAYGNlkGACAWEEc1Cx0RJAFDHC1ZFUUlExcJIBgHAEtfQ0onDxELNVBZSCMKDQsiUgYeJxcASiwXEBsjHhFFaQIWCm0KAQdtUhIdJwwRFmh4TkhgHgYVIlBZSCUrJCZhEQIELgp+SGFQFA0gChsGKhcXSnhZIwAjIQwLKRwARSIdDQYnGgAMLhwQYm9ZVgMoHgZKeFkHDSAABgxiHx0JJAEaGzYcGUUgEQANMQp+bwcdEUgnGBcNYREMBiwcFxEoHQ1SSFRUAzMdDlJiChsQMxEGSCEWGRUuHAYGNlk9IWFaDh0xDVQIIAYAAGIYGkUkCgobNhAaAmERDAUyFhoALwZDIQZZER0gERcEO1B+SGEGDFJiDRUXJhcXSCEWGRUuHAYGNlk9IWFaDh0xDVQIIAYAAGIYGkUkCgobNhAaAmERDAUyFhoALwZDIQZZER0gERcEO1B+SGEGGhgnQ1QKLxdDByRZAA0kUhcRMhwHRSAQDB4nc1lFJRcQCzAQBBEoHQ1SYhsGDCQUQwwnChcXKAIXAS0XVAonUhcAJ1kGAC0TFwEtFwcNKAJpRWIYBxwvEVlINgsBAGEbBUgjCg0LIhoRBywWARZhWgYeJxcAFm1SEh0nDBEWaHhpKS4KG0UoFgYGNhASHGFYSQ4uFgMWa1hDisLtVAAvFk4cLVQRCyVSEQ0zDBEWNVITCTYRB0U1GhEHNx4cRTUaBkgxAAcRJB9ZYm9ZGgQsF1lIJBUbEmEcAgUnWVwAbxVNRGJbIRYkAEM6Jx4dFjUAAhwrFhpHaHhOSCYcBwYzGxMcKxYaX2EFCwk2WRwEMQIGBjFzWUUyBgYYMUNUBDMAAhFiFhJFMgYRASweB0lhFwILKlkxPQAxNyQbWR0LYQYLDWIfGxcsExdIYBobCDEdDQ0sDT0BYZDl+mIaGwgxHQ0NLA09AWNSSw1sHlpJYVAUDSBUEhcuHBcNLB1Uh8fgQwkyEFkWJAAVDTBbWEVjExMBbwoRFzcXEUig/+ZFMR0QHCULERYwHkFBbFkxBCIaQxs2HARFLAcQHGIaGws1EwoGYhwMBCIGDxFiFhoAYZDl+mIYBhcuBUMfKw0cRSBSFQkuEBBFIh0OGC0XEQs1UiosYhYaRSQTAABiCh0BJFxDLC1ZOioVUhYbJ1kSFyQXThwnAQBFJRcQCzAQBBEoHQ0bYhgHRTIGBhgxV35vCD8zJxAtNSsVSEM9MRxUESkXQy0aODcxYREMBTIWGgAvBkMhBgpUAzMdDkg2ERFFIh0OGC0XEQs1AUMEKwoAS2E3FQ0wAFQDMx0ORzYWVAwvUgAHLBcRBjUbDAYxWTUrBVIGHicLDUUiHQ4YLRcRCzVSKixiEBpFJx4MH2IKAAAxAUMFNwoARTMXBQ0wHBoGJFICSDQYGAwlUgAHLwkbCyQcF0gLPVQDMx0OSDYREUUtGxAcYhgWCjcXTUgGFlQrDiZDASwPEQs1UgAHLwkbCyQcF0gLPQdFLgBDHTEcVAMzFwZFNhwMEWEWBhshCx0VNRsMBjFXfm8TFxAYLRcQRTYbFwBiNjopGFICSAgqOythHQECJxoAX0sJaUhiWxcKLxwGCzYQGwsyUFlIGVdaSxxeaUhiWxIJLgUQSnhZL0tvXD5iPw==");
+registerPrompt("pipeline/flow-detector", "GB0WSCMLEUUgHEMNOgkRFzVSEAckDQMEMxdDCTAaHAw1FwAcbFk1CyAeGhInWQANJFITGi0TEQY1UgAHLA0RHTVSAgYmWR0BJBwXASQATm9LQ01IaFMREyQcFystFxoAIgYKBywKXk97UiYeJxcASCUACh4nF1QGLh8OHSwQFwQ1GwwGYgkVETUXEQYxWVwIJAEQCSUcVBQ0FxYNMVVUFTQQTBs3G1hFNhcBAC0WHxZtUgYeJxcARSQfChw2HAYWaFxpSGJZMgozUgYJIRFORTpSEx0gFR0WKRcRRGIKAQcyEREBIBwGSWERCwksFxEJbVIXDSERGgotHQQRYgR+RWFSTkgyDBYJKAELDTBWBxAjAQAaKxsRF3tSAAcvCRsLJBwXSAs9B0VpGQYKIxtZBiABBkgxFQECMltpSGJZWUUiGgIGLBwYX2EXFQ0sDVsRLgIKC20IAQA0F0MGIxQRb2FSQ0ViDREGKRwMBC0eDV9hBgsNYgoEACIbBQEhWQAAIhoNBy4WExxhBxANJllcAG8VTURiWxETJBwXRScUHRE1FxFKbllWEiQQCwctElZMS3hRRmJTXgQxGzEHNw0RFmtYWUgDKT1FMx0WHCcKWwAvFhMHKxcAFmEWBhwnGgAAJVIFGi0UVAYuFgZIMhgAESQADRtsc1RFYTQMGmIcFQYpSEMTYgkVESleQwUnDRwKJV5DACMXEAkkACUBLhxUGEt4IDoLLT0mAD5ZSA0XGBxhAAYYLQsARSQEBgY2WRcKLxwGCzYQGwsyUgIGJlkGCjQGBhtiDRwENVILCTQcVCYOPCA6By0xRQQkKiwHNzcgYRsNSDYREUUxAAweKx0RAWERDAwnWQcELAIPDTFVVBY1ExcBIVkHBiAcDQ0wWQYAMgcPHDFVVAozUicHIRIRF2EBBho0EBcAMlxDISRZAA0kUhAcIw0dBmEBAAksFxEXYQECETFZVisuUgYeJxcASCUACh4nF1QVIAYXDTAXB0UlFxcNIQ0RAWNeQxonDQEXL1IGBTINDUUkBAYGNjobCy8XABwrFhoWb1InB2I3OzFhGw0eJxcARTETFxwnCxoWYQYLCTZZFRckUg0HNlkREygWBgYhHBBFKBxDHCocVAwvAhYcbHN+NyQBEwcsHVQSKAYLSA03ODxhE0MiETY6RS4QCQ0hDU5vOnhDSGAcAgAvBiAHLBcRBjUbDAYxW05FGlxNRh9VfkVhUAIYKysbEDUXEEp4WS9Lb1w+Yj9zfiwnUg0HYgkVETUXEQYxWRIKNBwHRGILERE0AA1IJxQEEThSAhowGA0Wbw==");
+registerPrompt("pipeline/service-describer", "GB0WSCMLEUUgHEMNOgkRFzVSEAckDQMEMxdDCTAaHAw1FwAcbFk1CyAeGhInWQANJFITGi0TEQY1UgAHLA0RHTVSAgYmWR0BJBwXASQATm9LQ01IaFMEFy4YBgs2PREWIgAKGDYQGwtrWFlIA1kXCSQTEUhwVEdFMhcNHCcXFwBhFgYbIQsdFTUbDAZiFhJFNhoCHGINHAwyUhMaLRMRBjVSBwcnClpvc1xDQmgJBgwsExERDhgaAjQTBA1oU05FFRoGSC8YHQthAhEHJQsVCCwbDQ9iFRULJgcCDydZXABvFU1EYlsgHDEXMAswEAQRY15DShIAAA0uHEFEYlszCmNeQ0oQDAcRY1tNYnFXVE9rFgIcIxsVFiQBSUJ4WTAENRMBCTEcB0U0AQYMYhAaRTUaChtiCQYKKxcAHGxzQEthWEkNOg0RFy8TDzsnCwIMIhcQQmhDVCA5BgYaLBgYRTIXER4rGhEWbjMzITFZFwovARYFJx1UBzhSFwArClQVMx0JDSENWm9LNAwaYh0VESAQAhsnClQELxZDDToNERcvEw87JwsCDCIXEERiCQYKNxsHDXhzWUUoFllIKRwWBCNfAAkxHFQWLQcEYm9ZGgQsF1lIKgwZBC9fEQ0jHRUHLRdDBiMUEW9sUhcRMhxORTUXAAAsFhgKJgtDHDsJEUVpF00PbFVURzEdEBwlCxEWMB5BRGJbBgAlGxBKbllWFjUAChgnW11vbFIHDTEaBgwxBgoHLENUEikTF0grDVMWYQcQDSZZEgozeE5INwoRAQMLWUgjCwYEOFIMDmIaGwgxHQ0NLA1ULAUBQxwqGABFNAEGSDYRHRZhWhYbJ1kfACMTAUUhGAcAYQEPHSUKVAggBgAAKxcTRTUaBkghFhkVLhwGBjZZGgQsFxBBSHM3NwgmKisDNU5FDhwPEWIQGgYtBwcNYh0VESAQAhsnClQELxZDDToNERcvEw9IMRwGEygRBhtiDRwENVILCTQcVCYOPCA6By0xRQQkKiwHNzcgYRsNSDYREUUiHQcNIBgHAHt4TkgSGBcOIBUGRyYcBAAvFgYGIQBUDCwCDBo2ClRNJFwERm5ZVhUmUE9IYAsRASgBQURiWwcRMxsTDWBVVEcBExQbbwoQDm4RDwEnFwBIMkFBQUhUVCAvBAoaLRcZAC8GQx4jCx0EIx4GG2ILEQMkAAYGIRAaAmEGCw0vWVwAbxVNRGI9NTEAMCI7ByYhNw1eQzoHPT02HicxJG5ZJzETOzMtHSoxJhM3NzcJPC1MS19DLC0aHwAzUiAHLwkbFiRSEA0wDx0GJAFDHysNHEUsExcLKhAaAmEbDgklHAdvbFIgBywfHQI0AAIcKxYaRScbDw0xWQYAJxcRDSwaHQsmUhcAJxR+SGE2ChonGgBFNAECDydZHQthEQwMJ1kHBCwCDw0xWQQXLgQKDCcdfm8FHUMmDS1UAjQXEBtiFgZFKBwFDTBZBwAzBAoLJwpUESkTF0gvEBMNNVIBDWIMBwAnBw9GYj0bRQ89N0grFxcJNBYGSDEcBhMoEQYbYhMBFjVSAQ0hGAEWJFIXACdZBBcuGAYLNllWBi4HDwxgWQEWJFIXACcUWkUIFEMcKhwGAGEbEEgsFlQGLhwAGicNEUUkBAoMJxcXAG1SBwdiFxsRYRsNCy4MEABhGxdGSHMmADICDAYmWQMMNRpDJww1LUUgUik7DTdUCiMYBgs2WRkENRELASweVBEpGxBIMRocACwTWWI5c1RFYwIRBygcFxEFFxALMBAEESgdDUp4WVZLb1xBREhZVEcxAAoFIwsNKSAcBB0jHhFHe1JBRmxXVklLUkNKJhgABCMTEA0xW05FGlxNRh9VfkVhUAYQNhwGCyAeMA0wDx0GJAFBUmIiWktvL2kV");
+registerPrompt("pipeline/validator", "GB0WSCMLEUUgUhAHJA0DBDMXQwkwGhwMNRcAHDcLEUUzFxUBJw4RF29SNQkuEBAENRdDHCocVAQvEw8RMRAHRTMXEB0uDQdFIBwHSDEMEwIkARdIIRYGFyQRFwEtFwdLS3ggACcaH0UnHRFSSEhaRWtYLBoyERULYREMBTIWGgAvBhBCaENUJi4fEwcsHBoRMlIUATYRVB8kAAxIIRYaCyQRFwEtFwdFNRoCHGIKHAo0HgdIIBxUBi4cDQ0hDREBS0BNSGhTIxcuHARIIRYZFS4cBgY2WQAcMRcQQmhDVABvFU1EYhhUNyQTABxiGAQVYQYaGCcdVAQyUkEbJwsCDCIXQUgxERsQLRZDCidZVgMzHQ0cJxcQR0tBTUhoUzkMMgEKBiVZFwovHAYLNhAbCzJYSVJiNhYTKB0WG2ILEQkgBgoHLAocDDEBQwYtDVQGIAIXHTAcEG91XENCaC4RBCpSBw0xGgYMMQYKBywKXk97UiAHLwkbCyQcFxtiDh0RKVIGBTINDUUuAEMdLBoYACAAQwwnChcXKAIXAS0XB0Wj8vdIMgsbEygWBkggHAARJABDBywcB290XENCaD0BFS0bAAk2HFsXJBYWBiYYGhFhEQwFMhYaAC8GEEJoQ1QmLh8TBywcGhEyUhcAIw1UFikdFgQmWRYAYR8GGiUcEG9LIAYbMhYaAWEFChwqWTsrDStDCWIzJyoPUgwKKBwXEXt4GGJiWVYGLh8TBywcGhEVCxMNARYGFyQRFwEtFwdHe1IYSGAaGwgxHQ0NLA1ZDCVQWUhgGhsXMxcAHG8NDRUkUEMVbnNURWMRDAUyFhoALwYnDTEaBgwxBgoHLApWX2EJQ0ohFhkVLhwGBjZUHQFjSENKIBwAESQAQwwnChcXKAIXAS0XVkU8XmlIYlsVASUXBystFxoAIgYKBywKVl9hKRhIYB8GCixQWUhgEBBHbVJBHC1bTkVjGwdKbllWETgCBkp4WVYROAIGSm5ZVgEkAQAaKwkADC4cQVJiWxAAMhFBRGJbFRY4HABKeFkSBC0BBkg/JFhvYVJBGicUGxMkFiAHLBcRBjUbDAYJHA0WY0hDM2AfBgosSFkcLUNOETgCBkofVX5FYVAABywfHQEkHAANYENUVW9KVkRIWVRHKAEQHScKVl9hKUEMJwoXFygCFwEtF1QKJ1ICBjtZBgAsEwoGKxcTRSgBEB0nClY4Sw9pYhcKEUUkHxMcO1kbBysXABwxVhUXMxMaG2IQEkUvHUMLLQsGACIGCgcsClQLJBcHDSZXVDEpF0MLLRcSDCUXDQsnWQcGLgAGSGpJWVRoUhENJBURBjUBQxEtDAZFLgQGGiMVGEUiHQ0OKx0RCyIXQwEsWQANJFICBiMVDRYoAUMZNxgYDDULTQ==");

package/dist/agents/prompts-encode.d.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env npx tsx
+/**
+ * Build-time utility: Encodes agent system prompts with XOR obfuscation.
+ * Run: npx tsx agents/prompts-encode.ts
+ *
+ * Reads plain-text prompt from stdin or argument and outputs the encoded base64 string.
+ * Usage: echo "Your prompt text" | npx tsx agents/prompts-encode.ts
+ */
+export declare function encode(text: string): string;

package/dist/agents/prompts-encode.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env npx tsx
+/**
+ * Build-time utility: Encodes agent system prompts with XOR obfuscation.
+ * Run: npx tsx agents/prompts-encode.ts
+ *
+ * Reads plain-text prompt from stdin or argument and outputs the encoded base64 string.
+ * Usage: echo "Your prompt text" | npx tsx agents/prompts-encode.ts
+ */
+const K = [0x41, 0x72, 0x63, 0x68, 0x42, 0x79, 0x74, 0x65]; // "ArchByte"
+export function encode(text) {
+    const buf = Buffer.from(text, "utf-8");
+    const out = Buffer.alloc(buf.length);
+    for (let i = 0; i < buf.length; i++) {
+        out[i] = buf[i] ^ K[i % K.length];
+    }
+    return out.toString("base64");
+}
+// If run directly, encode stdin
+if (process.argv[1]?.endsWith("prompts-encode.ts")) {
+    let input = "";
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (chunk) => { input += chunk; });
+    process.stdin.on("end", () => {
+        console.log(encode(input));
+    });
+}

package/dist/agents/prompts.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Agent Prompt Store — Obfuscated
+ *
+ * System prompts are XOR-encoded so they don't appear as plaintext strings
+ * in compiled JavaScript. This prevents casual extraction via grep, strings,
+ * or code browsing. Not cryptographically secure — a determined reverse
+ * engineer can still extract them — but raises the bar significantly.
+ *
+ * To add/update a prompt: run `npx tsx agents/prompts-encode.ts`
+ */
+export declare function getPrompt(id: string): string;
+export declare function registerPrompt(id: string, encoded: string): void;

package/dist/agents/prompts.js

@@ -0,0 +1,30 @@
+/**
+ * Agent Prompt Store — Obfuscated
+ *
+ * System prompts are XOR-encoded so they don't appear as plaintext strings
+ * in compiled JavaScript. This prevents casual extraction via grep, strings,
+ * or code browsing. Not cryptographically secure — a determined reverse
+ * engineer can still extract them — but raises the bar significantly.
+ *
+ * To add/update a prompt: run `npx tsx agents/prompts-encode.ts`
+ */
+const K = [0x41, 0x72, 0x63, 0x68, 0x42, 0x79, 0x74, 0x65]; // "ArchByte"
+function d(encoded) {
+    const buf = Buffer.from(encoded, "base64");
+    const out = Buffer.alloc(buf.length);
+    for (let i = 0; i < buf.length; i++) {
+        out[i] = buf[i] ^ K[i % K.length];
+    }
+    return out.toString("utf-8");
+}
+// Prompt registry — populated by prompts-encode.ts
+const store = new Map();
+export function getPrompt(id) {
+    const encoded = store.get(id);
+    if (!encoded)
+        throw new Error(`Unknown prompt: ${id}`);
+    return d(encoded);
+}
+export function registerPrompt(id, encoded) {
+    store.set(id, encoded);
+}

package/dist/agents/providers/anthropic.d.ts

@@ -0,0 +1,10 @@
+import type { LLMProvider, ChatParams, LLMResponse, LLMChunk } from "../runtime/types.js";
+export declare class AnthropicProvider implements LLMProvider {
+    name: "anthropic";
+    private client;
+    constructor(apiKey: string);
+    chat(params: ChatParams): Promise<LLMResponse>;
+    stream(params: ChatParams): AsyncIterable<LLMChunk>;
+    private toAnthropicBlock;
+    private fromAnthropicBlock;
+}