archbyte 0.4.0 → 0.4.2

package/bin/archbyte.js

@@ -151,7 +151,6 @@ program
   .option('-d, --diagram <path>', 'Path to architecture JSON (default: .archbyte/architecture.json)')
   .option('-c, --config <path>', 'Path to archbyte.yaml config')
   .option('--ci', 'Machine-readable JSON output for CI pipelines')
-  .option('-w, --watch', 'Watch for changes and re-validate')
   .action(async (options) => {
     await requireLicense('analyze');
     await handleValidate(options);
@@ -186,7 +185,8 @@ 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('--once', 'Run a single patrol cycle then exit')
+  .option('-w, --watch', 'Watch source files for changes instead of polling on interval')
   .option('--history', 'Show patrol history dashboard')
   .action(async (options) => {
     await requireLicense('analyze');
@@ -256,24 +256,6 @@ program
     await handleUpdate();
   });
 
-// — MCP server —
-
-const mcpCmd = program
-  .command('mcp')
-  .description('Start MCP server for AI coding tools (Claude Code, Codex)')
-  .action(async () => {
-    const { startMcpServer } = await import('../dist/cli/mcp-server.js');
-    await startMcpServer();
-  });
-
-mcpCmd
-  .command('install')
-  .description('Auto-configure Claude Code and/or Codex CLI')
-  .action(async () => {
-    const { handleMcpInstall } = await import('../dist/cli/mcp.js');
-    await handleMcpInstall();
-  });
-
 // Default: show help
 program
   .action(() => {

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, IncrementalContext } from "./types.js";
+import type { ComponentIdentifierOutput, ServiceDescriberOutput, FlowDetectorOutput, ConnectionMapperOutput, ValidatorOutput, IncrementalContext, ArchitectureEnricherOutput } 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, incrementalContext?: IncrementalContext): StaticAnalysisResult;
+export declare function mergeAgentOutputs(ctx: StaticContext, componentId: ComponentIdentifierOutput | null, serviceDesc: ServiceDescriberOutput | null, flowDet: FlowDetectorOutput | null, connMap: ConnectionMapperOutput | null, validatorOut: ValidatorOutput | null, incrementalContext?: IncrementalContext, enricherOut?: ArchitectureEnricherOutput | null): StaticAnalysisResult;

package/dist/agents/pipeline/merger.js

@@ -5,11 +5,97 @@ function sanitize(s) {
         return s;
     return s.replace(/\u2014/g, "-").replace(/\u2013/g, "-").replace(/\u2018|\u2019/g, "'").replace(/\u201C|\u201D/g, '"');
 }
+/**
+ * Build a set of "evidence tokens" from the static context — things that concretely
+ * exist in the codebase (dependencies, env vars, docker images/services).
+ * Used to gate LLM-generated databases/external services against hallucination.
+ */
+function buildEvidenceTokens(ctx) {
+    const tokens = new Set();
+    // Package dependencies from import map (codeSamples.importMap: file → imported modules)
+    for (const imports of Object.values(ctx.codeSamples.importMap)) {
+        for (const imp of imports) {
+            tokens.add(imp.toLowerCase());
+            // Also add short name for scoped packages: @aws-sdk/client-s3 → client-s3, aws-sdk
+            if (imp.startsWith("@")) {
+                const parts = imp.split("/");
+                if (parts[1])
+                    tokens.add(parts[1].toLowerCase());
+                tokens.add(parts[0].slice(1).toLowerCase());
+            }
+        }
+    }
+    // Config files may contain dependency info (package.json deps etc.)
+    for (const cfg of ctx.codeSamples.configFiles) {
+        if (cfg.path.endsWith("package.json")) {
+            try {
+                const pkg = JSON.parse(cfg.content);
+                for (const dep of Object.keys({ ...pkg.dependencies, ...pkg.devDependencies })) {
+                    tokens.add(dep.toLowerCase());
+                    if (dep.startsWith("@")) {
+                        const parts = dep.split("/");
+                        if (parts[1])
+                            tokens.add(parts[1].toLowerCase());
+                        tokens.add(parts[0].slice(1).toLowerCase());
+                    }
+                }
+            }
+            catch { /* ignore parse errors */ }
+        }
+    }
+    // Environment variable names
+    for (const env of ctx.envs.environments) {
+        for (const v of env.variables) {
+            tokens.add(v.toLowerCase());
+        }
+    }
+    // Docker compose service names and images
+    for (const svc of ctx.infra.docker.services) {
+        tokens.add(svc.name.toLowerCase());
+        if (svc.image)
+            tokens.add(svc.image.toLowerCase().split(":")[0]);
+    }
+    // Cloud services detected by infra scanner
+    for (const s of ctx.infra.cloud.services) {
+        tokens.add(s.toLowerCase());
+    }
+    // External dependencies mentioned in docs
+    for (const dep of ctx.docs.externalDependencies) {
+        tokens.add(dep.toLowerCase());
+    }
+    return tokens;
+}
+/**
+ * Check if a service/database ID and type have concrete evidence in the static context.
+ * Uses fuzzy matching: checks if any evidence token contains or is contained by the service keywords.
+ */
+function hasEvidence(id, name, type, evidenceTokens) {
+    // Build candidate keywords from the service
+    const candidates = [
+        id.toLowerCase(),
+        name.toLowerCase(),
+        type.toLowerCase(),
+        // Split hyphenated IDs: "aws-sqs" → ["aws", "sqs"]
+        ...id.toLowerCase().split("-"),
+    ].filter(Boolean);
+    for (const candidate of candidates) {
+        for (const token of evidenceTokens) {
+            // Direct match or substring match (in both directions)
+            if (token === candidate)
+                return true;
+            if (token.includes(candidate) && candidate.length >= 3)
+                return true;
+            if (candidate.includes(token) && token.length >= 3)
+                return true;
+        }
+    }
+    return false;
+}
 /**
  * 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, incrementalContext) {
+export function mergeAgentOutputs(ctx, componentId, serviceDesc, flowDet, connMap, validatorOut, incrementalContext, enricherOut) {
     // Start with components from component-identifier
     const components = [];
     if (componentId?.components) {
@@ -41,38 +127,44 @@ export function mergeAgentOutputs(ctx, componentId, serviceDesc, flowDet, connMa
         }
     }
     const componentIds = new Set(components.map((c) => c.id));
-    // Add databases from service-describer as components
+    // Build evidence tokens for hallucination gating
+    const evidenceTokens = buildEvidenceTokens(ctx);
+    // Add databases from service-describer as components (evidence-gated)
     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: sanitize(db.description),
-                    technologies: [db.type],
-                });
-                componentIds.add(db.id);
-            }
+            if (componentIds.has(db.id))
+                continue;
+            if (!hasEvidence(db.id, db.name, db.type, evidenceTokens))
+                continue;
+            components.push({
+                id: db.id,
+                name: db.name,
+                type: "database",
+                layer: "data",
+                path: "",
+                description: sanitize(db.description),
+                technologies: [db.type],
+            });
+            componentIds.add(db.id);
         }
     }
-    // Add external services from service-describer as components
+    // Add external services from service-describer as components (evidence-gated)
     if (serviceDesc?.externalServices) {
         for (const svc of serviceDesc.externalServices) {
-            if (!componentIds.has(svc.id)) {
-                components.push({
-                    id: svc.id,
-                    name: sanitize(svc.name) ?? svc.name,
-                    type: "service",
-                    layer: "external",
-                    path: "",
-                    description: sanitize(svc.description),
-                    technologies: [svc.type],
-                });
-                componentIds.add(svc.id);
-            }
+            if (componentIds.has(svc.id))
+                continue;
+            if (!hasEvidence(svc.id, svc.name, svc.type, evidenceTokens))
+                continue;
+            components.push({
+                id: svc.id,
+                name: sanitize(svc.name) ?? svc.name,
+                type: "service",
+                layer: "external",
+                path: "",
+                description: sanitize(svc.description),
+                technologies: [svc.type],
+            });
+            componentIds.add(svc.id);
         }
     }
     // Incremental fallback: if service-describer returned nothing, restore from spec
@@ -254,6 +346,37 @@ export function mergeAgentOutputs(ctx, componentId, serviceDesc, flowDet, connMa
     if (serviceDesc?.projectDescription && serviceDesc.projectDescription.length > (docs.projectDescription?.length ?? 0)) {
         docs.projectDescription = sanitize(serviceDesc.projectDescription);
     }
+    // Apply enricher overlays (non-destructive)
+    if (enricherOut) {
+        // Overlay coupling weight on connections
+        if (enricherOut.connectionEnrichments?.length) {
+            for (const ce of enricherOut.connectionEnrichments) {
+                const conn = filteredConnections.find((c) => c.from === ce.from && c.to === ce.to && c.type === ce.type);
+                if (conn) {
+                    if (ce.weight != null)
+                        conn.weight = ce.weight;
+                    if (ce.verifiedByTool)
+                        conn.confidence = Math.min(100, (conn.confidence ?? 80) + 10);
+                }
+            }
+        }
+        // Overlay component enrichments
+        if (enricherOut.componentEnrichments?.length) {
+            for (const ce of enricherOut.componentEnrichments) {
+                const comp = components.find((c) => c.id === ce.id);
+                if (comp) {
+                    if (ce.interfaceSurface != null)
+                        comp.interfaceSurface = ce.interfaceSurface;
+                    if (ce.hasBoundary != null)
+                        comp.hasBoundary = ce.hasBoundary;
+                    if (ce.boundaryType)
+                        comp.boundaryType = ce.boundaryType;
+                    if (ce.publicExports?.length)
+                        comp.publicExports = ce.publicExports;
+                }
+            }
+        }
+    }
     return {
         structure,
         docs,
@@ -272,5 +395,7 @@ export function mergeAgentOutputs(ctx, componentId, serviceDesc, flowDet, connMa
         },
         validation: { valid: true, repairs: [], errors: [] },
         gaps: [],
+        enrichmentInsights: enricherOut?.insights,
+        flowVerifications: enricherOut?.flowVerifications,
     };
 }

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

@@ -5,7 +5,11 @@ export interface PipelineAgent {
     name: string;
     modelTier: ModelTier;
     phase: "parallel" | "sequential";
-    buildPrompt(ctx: StaticContext, priorResults?: Record<string, unknown>): {
+    /** Tool names this agent can use: ["read_file", "grep", "glob"] */
+    tools?: string[];
+    /** Max tool loop iterations (default 1 = no tools) */
+    maxTurns?: number;
+    buildPrompt(ctx: StaticContext, priorResults?: Record<string, unknown>, toolsAvailable?: boolean): {
         system: string;
         user: string;
     };
@@ -135,6 +139,30 @@ export interface IncrementalContext {
     neighborComponents: string[];
     hasUnmappedFiles: boolean;
 }
+export interface ArchitectureEnricherOutput {
+    connectionEnrichments: Array<{
+        from: string;
+        to: string;
+        type: string;
+        weight?: number;
+        verifiedByTool?: boolean;
+    }>;
+    componentEnrichments: Array<{
+        id: string;
+        interfaceSurface?: number;
+        hasBoundary?: boolean;
+        boundaryType?: string;
+        publicExports?: string[];
+    }>;
+    flowVerifications: Array<{
+        flowName: string;
+        verified: boolean;
+        stepsVerified: number;
+        stepsTotal: number;
+        issues?: string[];
+    }>;
+    insights: string[];
+}
 export interface PipelineAgentResult {
     agentId: string;
     data: unknown;

package/dist/agents/pipeline/types.js

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

package/dist/agents/providers/claude-sdk.js

@@ -3,32 +3,56 @@ export class ClaudeSdkProvider {
     async chat(params) {
         const { query } = await import("@anthropic-ai/claude-agent-sdk");
         const prompt = this.extractPrompt(params.messages);
+        // Dynamic tool config: empty = text-only, populated = tool-enabled
+        const sdkTools = params.sdkTools?.length ? params.sdkTools : [];
+        const maxTurns = params.sdkMaxTurns ?? 1;
         const result = query({
             prompt,
             options: {
                 systemPrompt: params.system,
-                allowedTools: [],
-                maxTurns: 1,
+                tools: sdkTools,
+                maxTurns,
                 ...(params.model ? { model: params.model } : {}),
                 permissionMode: "bypassPermissions",
                 allowDangerouslySkipPermissions: true,
             },
         });
         let resultText = "";
+        let assistantText = "";
         let usage = { inputTokens: 0, outputTokens: 0 };
         for await (const message of result) {
-            if (message.type === "result") {
+            if (message.type === "assistant") {
+                // Capture text from assistant content blocks as fallback
+                const msg = message.message;
+                if (msg && "content" in msg && Array.isArray(msg.content)) {
+                    for (const block of msg.content) {
+                        if (block.type === "text" && typeof block.text === "string") {
+                            assistantText += block.text;
+                        }
+                    }
+                }
+            }
+            else if (message.type === "result") {
                 if (message.subtype === "success") {
                     resultText = message.result;
                 }
-                usage = {
-                    inputTokens: message.usage.input_tokens ?? 0,
-                    outputTokens: message.usage.output_tokens ?? 0,
-                };
+                else {
+                    // Error result — log the errors for debugging
+                    const errors = "errors" in message ? message.errors : [];
+                    console.error(`[claude-sdk] Result subtype="${message.subtype}" errors=${JSON.stringify(errors)}`);
+                }
+                if (message.usage) {
+                    usage = {
+                        inputTokens: message.usage.input_tokens ?? 0,
+                        outputTokens: message.usage.output_tokens ?? 0,
+                    };
+                }
             }
         }
+        // Use result text if available, otherwise fall back to assistant message text
+        const text = resultText || assistantText;
         return {
-            content: [{ type: "text", text: resultText }],
+            content: [{ type: "text", text }],
             stopReason: "end_turn",
             usage,
         };

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

@@ -23,6 +23,10 @@ export interface ChatParams {
     messages: Message[];
     tools?: ToolDefinition[];
     maxTokens?: number;
+    /** Claude SDK tool names: ["Read", "Grep", "Glob"] */
+    sdkTools?: string[];
+    /** Claude SDK max agentic turns (default 1) */
+    sdkMaxTurns?: number;
 }
 export interface LLMResponse {
     content: ContentBlock[];

package/dist/agents/runtime/types.js

@@ -2,12 +2,12 @@
 // === Model Routing ===
 export const MODEL_MAP = {
     anthropic: {
-        fast: "claude-haiku-4-5-20251001",
+        fast: "claude-sonnet-4-5-20250929",
         standard: "claude-sonnet-4-5-20250929",
         advanced: "claude-opus-4-6",
     },
     "claude-sdk": {
-        fast: "haiku",
+        fast: "sonnet",
         standard: "sonnet",
         advanced: "opus",
     },

package/dist/agents/static/component-detector.js

@@ -74,15 +74,21 @@ export async function detectComponents(tk, structure) {
     // Strategy 1: Monorepo workspaces
     if (structure.isMonorepo) {
         const components = await detectFromWorkspaces(tk, structure);
-        if (components.length > 0)
+        if (components.length > 0) {
+            await enrichWithFileMetrics(tk, components);
             return { components };
+        }
     }
     // Strategy 2: Scan ALL top-level directories for build configs + conventional names
     const components = await detectAllComponents(tk, structure);
-    if (components.length > 0)
+    if (components.length > 0) {
+        await enrichWithFileMetrics(tk, components);
         return { components };
+    }
     // Strategy 3: Single app fallback
-    return { components: [buildSingleAppComponent(structure)] };
+    const fallback = [buildSingleAppComponent(structure)];
+    await enrichWithFileMetrics(tk, fallback);
+    return { components: fallback };
 }
 async function detectFromWorkspaces(tk, structure) {
     // Collect workspace patterns from package.json OR pnpm-workspace.yaml
@@ -383,6 +389,32 @@ function extractTechStack(pkg) {
 function capitalize(s) {
     return s.charAt(0).toUpperCase() + s.slice(1);
 }
+const CODE_EXTENSIONS = /\.(ts|tsx|js|jsx|py|go|rs|java|kt|rb|cs|php|swift|dart)$/i;
+async function enrichWithFileMetrics(tk, components) {
+    await Promise.all(components.map(async (comp) => {
+        if (comp.path === ".")
+            return;
+        try {
+            const allFiles = await tk.globFiles(`**/*`, comp.path);
+            const codeFiles = allFiles.filter((f) => CODE_EXTENSIONS.test(f));
+            let totalLines = 0;
+            const filesToCount = codeFiles.slice(0, 150);
+            await Promise.all(filesToCount.map(async (file) => {
+                const content = await tk.readFileSafe(file);
+                if (content)
+                    totalLines += content.split("\n").length;
+            }));
+            comp.fileMetrics = {
+                fileCount: allFiles.length,
+                totalLines,
+                codeFileCount: codeFiles.length,
+            };
+        }
+        catch {
+            // skip
+        }
+    }));
+}
 function extractFirstParagraph(readme) {
     const lines = readme.split("\n");
     let capturing = false;

package/dist/agents/static/connection-mapper.d.ts

@@ -1,3 +1,3 @@
 import type { ConnectionResult, StaticComponent, InfraResult, EventResult } from "./types.js";
 import type { StaticToolkit } from "./utils.js";
-export declare function mapConnections(tk: StaticToolkit, components: StaticComponent[], infra: InfraResult, events: EventResult): Promise<ConnectionResult>;
+export declare function mapConnections(tk: StaticToolkit, components: StaticComponent[], infra: InfraResult, events: EventResult, importMap?: Record<string, string[]>): Promise<ConnectionResult>;

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

@@ -2,7 +2,7 @@
 // Maps connections between components via imports, Docker, K8s, env vars, known SDKs
 // Only deterministic matches — ambiguous mappings are left as gaps for the LLM
 import { slugify } from "./utils.js";
-export async function mapConnections(tk, components, infra, events) {
+export async function mapConnections(tk, components, infra, events, importMap) {
     const connections = [];
     const componentIds = new Set(components.map((c) => c.id));
     // Run all detection methods in parallel
@@ -10,6 +10,7 @@ export async function mapConnections(tk, components, infra, events) {
         detectDockerDependencies(infra, components, connections),
         detectK8sIngress(infra, components, connections),
         detectImportConnections(tk, components, connections),
+        detectImportMapConnections(components, connections, importMap ?? {}),
         detectDatabaseConnections(tk, components, connections),
         detectServerServesUI(tk, components, connections),
         detectKnownSDKConnections(components, connections),
@@ -225,6 +226,78 @@ async function detectKnownSDKConnections(components, connections) {
         }
     }
 }
+/**
+ * Detect cross-component connections from the code-sampler import map.
+ * Resolves relative imports and workspace package names to component boundaries.
+ */
+async function detectImportMapConnections(components, connections, importMap) {
+    if (Object.keys(importMap).length === 0)
+        return;
+    // Build component path → id lookup, sorted longest-first for greedy matching
+    const compPathEntries = components
+        .filter((c) => c.path !== ".")
+        .map((c) => ({ path: c.path.endsWith("/") ? c.path : c.path + "/", id: c.id }))
+        .sort((a, b) => b.path.length - a.path.length);
+    // Build package name → component id lookup (for monorepo imports)
+    const pkgNameToComp = new Map();
+    for (const comp of components) {
+        pkgNameToComp.set(comp.id, comp.id);
+        pkgNameToComp.set(comp.name, comp.id);
+        // Handle scoped package names: @org/name → name
+        const unscoped = comp.name.replace(/^@[^/]+\//, "");
+        if (unscoped !== comp.name)
+            pkgNameToComp.set(unscoped, comp.id);
+    }
+    const findCompForFile = (filePath) => {
+        for (const entry of compPathEntries) {
+            if (filePath.startsWith(entry.path) || filePath === entry.path.slice(0, -1)) {
+                return entry.id;
+            }
+        }
+        return null;
+    };
+    // Track seen connections to avoid duplicates within this strategy
+    const seen = new Set();
+    for (const [filePath, imports] of Object.entries(importMap)) {
+        const sourceComp = findCompForFile(filePath);
+        if (!sourceComp)
+            continue;
+        for (const imp of imports) {
+            let targetComp = null;
+            if (imp.startsWith(".") || imp.startsWith("/")) {
+                // Relative import — resolve path
+                const fromDir = filePath.substring(0, filePath.lastIndexOf("/"));
+                const parts = fromDir.split("/");
+                for (const seg of imp.split("/")) {
+                    if (seg === "..")
+                        parts.pop();
+                    else if (seg !== ".")
+                        parts.push(seg);
+                }
+                targetComp = findCompForFile(parts.join("/") + "/");
+            }
+            else {
+                // Package/bare import — check if it maps to a workspace component
+                const name = imp.split("/").slice(0, imp.startsWith("@") ? 2 : 1).join("/");
+                targetComp = pkgNameToComp.get(name) ?? pkgNameToComp.get(name.replace(/^@[^/]+\//, "")) ?? null;
+            }
+            if (targetComp && targetComp !== sourceComp) {
+                const key = `${sourceComp}::${targetComp}`;
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                connections.push({
+                    from: sourceComp,
+                    to: targetComp,
+                    type: "import",
+                    description: `Import: ${sourceComp} → ${targetComp}`,
+                    confidence: 85,
+                    async: false,
+                });
+            }
+        }
+    }
+}
 /**
  * Exact match only: id, slug, path, or name must match exactly.
  * No fuzzy matching, synonyms, or partial matches — those are for the LLM.

package/dist/agents/static/index.js

@@ -37,9 +37,12 @@ export async function runStaticAnalysis(projectRoot, onProgress) {
     onProgress?.("Detecting components...");
     const components = await detectComponents(tk, structure);
     onProgress?.(`Found ${components.components.length} component(s)`);
-    // Phase 3: connection mapping (needs components + infra + events)
+    // Phase 2.5: collect import map for enriched connection detection
+    onProgress?.("Building import map...");
+    const codeSamples = await collectCodeSamples(tk);
+    // Phase 3: connection mapping (needs components + infra + events + import map)
     onProgress?.("Mapping connections...");
-    const connections = await mapConnections(tk, components.components, infra, events);
+    const connections = await mapConnections(tk, components.components, infra, events, codeSamples.importMap);
     onProgress?.(`Found ${connections.connections.length} connection(s)`);
     // Assemble result
     const analysis = {

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

@@ -32,6 +32,20 @@ export interface StaticComponent {
     path: string;
     description: string;
     technologies: string[];
+    /** Coupling: count of public exports (from enricher) */
+    interfaceSurface?: number;
+    /** Security: has auth/permission boundary (from enricher) */
+    hasBoundary?: boolean;
+    /** Security: type of boundary e.g. "auth-middleware", "rbac" */
+    boundaryType?: string;
+    /** Key public export names (from enricher) */
+    publicExports?: string[];
+    /** File metrics from static analysis */
+    fileMetrics?: {
+        fileCount: number;
+        totalLines: number;
+        codeFileCount: number;
+    };
 }
 export interface InfraResult {
     docker: {
@@ -90,6 +104,8 @@ export interface StaticConnection {
     description: string;
     confidence: number;
     async: boolean;
+    /** Coupling weight 1-10 (from enricher) */
+    weight?: number;
 }
 export interface ConnectionResult {
     connections: StaticConnection[];
@@ -130,6 +146,16 @@ export interface StaticAnalysisResult {
     validation: ValidationResult;
     /** Gaps the static analysis couldn't resolve — passed to LLM for resolution */
     gaps: AnalysisGap[];
+    /** Free-form architectural observations from enricher */
+    enrichmentInsights?: string[];
+    /** Flow verification results from enricher */
+    flowVerifications?: Array<{
+        flowName: string;
+        verified: boolean;
+        stepsVerified: number;
+        stepsTotal: number;
+        issues?: string[];
+    }>;
 }
 export interface TreeEntry {
     path: string;