@harness-engineering/graph 0.4.3 → 0.6.0

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 import { z } from 'zod';
 
-declare const NODE_TYPES: readonly ["repository", "module", "file", "class", "interface", "function", "method", "variable", "adr", "decision", "learning", "failure", "issue", "document", "skill", "conversation", "commit", "build", "test_result", "span", "metric", "log", "layer", "pattern", "constraint", "violation", "design_token", "aesthetic_intent", "design_constraint", "requirement", "packed_summary"];
+declare const NODE_TYPES: readonly ["repository", "module", "file", "class", "interface", "function", "method", "variable", "adr", "decision", "learning", "failure", "issue", "document", "skill", "conversation", "commit", "build", "test_result", "execution_outcome", "span", "metric", "log", "layer", "pattern", "constraint", "violation", "design_token", "aesthetic_intent", "design_constraint", "image_annotation", "requirement", "business_rule", "business_process", "business_concept", "business_term", "business_metric", "business_fact", "packed_summary"];
 type NodeType = (typeof NODE_TYPES)[number];
-declare const EDGE_TYPES: readonly ["contains", "imports", "calls", "implements", "inherits", "references", "applies_to", "caused_by", "resolved_by", "documents", "violates", "specifies", "decided", "co_changes_with", "triggered_by", "failed_in", "executed_by", "measured_by", "uses_token", "declares_intent", "violates_design", "platform_binding", "requires", "verified_by", "tested_by", "caches"];
+declare const EDGE_TYPES: readonly ["contains", "imports", "calls", "implements", "inherits", "references", "applies_to", "caused_by", "resolved_by", "documents", "violates", "specifies", "decided", "co_changes_with", "triggered_by", "failed_in", "outcome_of", "executed_by", "measured_by", "uses_token", "declares_intent", "violates_design", "platform_binding", "requires", "verified_by", "tested_by", "governs", "measures", "annotates", "caches"];
 type EdgeType = (typeof EDGE_TYPES)[number];
 declare const OBSERVABILITY_TYPES: ReadonlySet<NodeType>;
 interface SourceLocation {
@@ -79,7 +79,7 @@ type GraphStabilityTier = 'static' | 'session' | 'ephemeral';
 declare const NODE_STABILITY: Record<string, GraphStabilityTier>;
 declare const GraphNodeSchema: z.ZodObject<{
     id: z.ZodString;
-    type: z.ZodEnum<["repository", "module", "file", "class", "interface", "function", "method", "variable", "adr", "decision", "learning", "failure", "issue", "document", "skill", "conversation", "commit", "build", "test_result", "span", "metric", "log", "layer", "pattern", "constraint", "violation", "design_token", "aesthetic_intent", "design_constraint", "requirement", "packed_summary"]>;
+    type: z.ZodEnum<["repository", "module", "file", "class", "interface", "function", "method", "variable", "adr", "decision", "learning", "failure", "issue", "document", "skill", "conversation", "commit", "build", "test_result", "execution_outcome", "span", "metric", "log", "layer", "pattern", "constraint", "violation", "design_token", "aesthetic_intent", "design_constraint", "image_annotation", "requirement", "business_rule", "business_process", "business_concept", "business_term", "business_metric", "business_fact", "packed_summary"]>;
     name: z.ZodString;
     path: z.ZodOptional<z.ZodString>;
     location: z.ZodOptional<z.ZodObject<{
@@ -108,7 +108,7 @@ declare const GraphNodeSchema: z.ZodObject<{
     lastModified: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     id: string;
-    type: "function" | "repository" | "module" | "file" | "class" | "interface" | "method" | "variable" | "adr" | "decision" | "learning" | "failure" | "issue" | "document" | "skill" | "conversation" | "commit" | "build" | "test_result" | "span" | "metric" | "log" | "layer" | "pattern" | "constraint" | "violation" | "design_token" | "aesthetic_intent" | "design_constraint" | "requirement" | "packed_summary";
+    type: "function" | "repository" | "module" | "file" | "class" | "interface" | "method" | "variable" | "adr" | "decision" | "learning" | "failure" | "issue" | "document" | "skill" | "conversation" | "commit" | "build" | "test_result" | "execution_outcome" | "span" | "metric" | "log" | "layer" | "pattern" | "constraint" | "violation" | "design_token" | "aesthetic_intent" | "design_constraint" | "image_annotation" | "requirement" | "business_rule" | "business_process" | "business_concept" | "business_term" | "business_metric" | "business_fact" | "packed_summary";
     name: string;
     metadata: Record<string, unknown>;
     path?: string | undefined;
@@ -125,7 +125,7 @@ declare const GraphNodeSchema: z.ZodObject<{
     lastModified?: string | undefined;
 }, {
     id: string;
-    type: "function" | "repository" | "module" | "file" | "class" | "interface" | "method" | "variable" | "adr" | "decision" | "learning" | "failure" | "issue" | "document" | "skill" | "conversation" | "commit" | "build" | "test_result" | "span" | "metric" | "log" | "layer" | "pattern" | "constraint" | "violation" | "design_token" | "aesthetic_intent" | "design_constraint" | "requirement" | "packed_summary";
+    type: "function" | "repository" | "module" | "file" | "class" | "interface" | "method" | "variable" | "adr" | "decision" | "learning" | "failure" | "issue" | "document" | "skill" | "conversation" | "commit" | "build" | "test_result" | "execution_outcome" | "span" | "metric" | "log" | "layer" | "pattern" | "constraint" | "violation" | "design_token" | "aesthetic_intent" | "design_constraint" | "image_annotation" | "requirement" | "business_rule" | "business_process" | "business_concept" | "business_term" | "business_metric" | "business_fact" | "packed_summary";
     name: string;
     metadata: Record<string, unknown>;
     path?: string | undefined;
@@ -144,17 +144,17 @@ declare const GraphNodeSchema: z.ZodObject<{
 declare const GraphEdgeSchema: z.ZodObject<{
     from: z.ZodString;
     to: z.ZodString;
-    type: z.ZodEnum<["contains", "imports", "calls", "implements", "inherits", "references", "applies_to", "caused_by", "resolved_by", "documents", "violates", "specifies", "decided", "co_changes_with", "triggered_by", "failed_in", "executed_by", "measured_by", "uses_token", "declares_intent", "violates_design", "platform_binding", "requires", "verified_by", "tested_by", "caches"]>;
+    type: z.ZodEnum<["contains", "imports", "calls", "implements", "inherits", "references", "applies_to", "caused_by", "resolved_by", "documents", "violates", "specifies", "decided", "co_changes_with", "triggered_by", "failed_in", "outcome_of", "executed_by", "measured_by", "uses_token", "declares_intent", "violates_design", "platform_binding", "requires", "verified_by", "tested_by", "governs", "measures", "annotates", "caches"]>;
     confidence: z.ZodOptional<z.ZodNumber>;
     metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, "strip", z.ZodTypeAny, {
-    type: "contains" | "imports" | "calls" | "implements" | "inherits" | "references" | "applies_to" | "caused_by" | "resolved_by" | "documents" | "violates" | "specifies" | "decided" | "co_changes_with" | "triggered_by" | "failed_in" | "executed_by" | "measured_by" | "uses_token" | "declares_intent" | "violates_design" | "platform_binding" | "requires" | "verified_by" | "tested_by" | "caches";
+    type: "contains" | "imports" | "calls" | "implements" | "inherits" | "references" | "applies_to" | "caused_by" | "resolved_by" | "documents" | "violates" | "specifies" | "decided" | "co_changes_with" | "triggered_by" | "failed_in" | "outcome_of" | "executed_by" | "measured_by" | "uses_token" | "declares_intent" | "violates_design" | "platform_binding" | "requires" | "verified_by" | "tested_by" | "governs" | "measures" | "annotates" | "caches";
     from: string;
     to: string;
     metadata?: Record<string, unknown> | undefined;
     confidence?: number | undefined;
 }, {
-    type: "contains" | "imports" | "calls" | "implements" | "inherits" | "references" | "applies_to" | "caused_by" | "resolved_by" | "documents" | "violates" | "specifies" | "decided" | "co_changes_with" | "triggered_by" | "failed_in" | "executed_by" | "measured_by" | "uses_token" | "declares_intent" | "violates_design" | "platform_binding" | "requires" | "verified_by" | "tested_by" | "caches";
+    type: "contains" | "imports" | "calls" | "implements" | "inherits" | "references" | "applies_to" | "caused_by" | "resolved_by" | "documents" | "violates" | "specifies" | "decided" | "co_changes_with" | "triggered_by" | "failed_in" | "outcome_of" | "executed_by" | "measured_by" | "uses_token" | "declares_intent" | "violates_design" | "platform_binding" | "requires" | "verified_by" | "tested_by" | "governs" | "measures" | "annotates" | "caches";
     from: string;
     to: string;
     metadata?: Record<string, unknown> | undefined;
@@ -252,7 +252,17 @@ interface SerializedGraph {
     readonly edges: readonly GraphEdge[];
 }
 declare function saveGraph(dirPath: string, nodes: readonly GraphNode[], edges: readonly GraphEdge[]): Promise<void>;
-declare function loadGraph(dirPath: string): Promise<SerializedGraph | null>;
+type LoadGraphResult = {
+    status: 'loaded';
+    graph: SerializedGraph;
+} | {
+    status: 'not_found';
+} | {
+    status: 'schema_mismatch';
+    found: number;
+    expected: number;
+};
+declare function loadGraph(dirPath: string): Promise<LoadGraphResult>;
 
 /**
  * Minimal PackedEnvelope shape -- avoids circular dep on @harness-engineering/core.
@@ -322,8 +332,8 @@ interface ImpactGroups {
 declare function groupNodesByImpact(nodes: readonly GraphNode[], excludeId?: string): ImpactGroups;
 
 /**
- * Ingests TypeScript/JavaScript files into the graph via regex-based parsing.
- * Future: upgrade to tree-sitter for full AST parsing.
+ * Ingests source files into the graph via regex-based parsing.
+ * Supports TypeScript, JavaScript, Python, Go, Rust, and Java.
  */
 declare class CodeIngestor {
     private readonly store;
@@ -333,12 +343,22 @@ declare class CodeIngestor {
     private trackCallable;
     private findSourceFiles;
     private extractSymbols;
+    private processSymbolLine;
+    private matchFunction;
     private tryExtractFunction;
+    private matchClass;
     private tryExtractClass;
+    private matchInterface;
     private tryExtractInterface;
+    /**
+     * Enter an impl block (Rust) or Java class body — sets class context without creating a node.
+     */
+    private tryEnterImplBlock;
     /** Update brace tracking; returns true when line is consumed (class ended or tracked). */
     private updateClassContext;
+    private matchMethod;
     private tryExtractMethod;
+    private matchVariable;
     private tryExtractVariable;
     /**
      * Find the closing brace for a construct starting at the given line.
@@ -346,11 +366,21 @@ declare class CodeIngestor {
      */
     private findClosingBrace;
     /**
-     * Second pass: scan each file for identifiers matching known callable names,
+     * Find the end of an indentation-based block (Python).
+     * The block ends when a subsequent non-empty line has indentation <= the starting line.
+     */
+    private findEndOfIndentBlock;
+    /**
+     * Update class context for Python using indentation tracking.
+     */
+    private updatePythonClassContext;
+    /**
+     * Scan a file for identifiers matching known callable names,
      * then create file-to-file "calls" edges. Uses regex heuristic (not AST).
      */
-    private extractCallsEdges;
+    private extractCallsEdgesForFile;
     private extractImports;
+    private extractImportPaths;
     private resolveImportPath;
     private computeCyclomaticComplexity;
     private computeMaxNesting;
@@ -361,7 +391,7 @@ declare class CodeIngestor {
      * linking requirement nodes to the annotated files.
      * Format: // @req <feature-name>#<index>
      */
-    private extractReqAnnotations;
+    private extractReqAnnotationsForFile;
 }
 
 type GitRunner = (rootDir: string, args: string[]) => Promise<string>;
@@ -417,6 +447,34 @@ declare class KnowledgeIngestor {
     private findMarkdownFiles;
 }
 
+declare class BusinessKnowledgeIngestor {
+    private readonly store;
+    constructor(store: GraphStore);
+    ingest(knowledgeDir: string): Promise<IngestResult>;
+    private createNodes;
+    private parseAndAddNode;
+    private createEdges;
+    private linkToNodes;
+    private linkToBusinessNodes;
+    private findMarkdownFiles;
+}
+
+/**
+ * Ingests ADR files from docs/knowledge/decisions/ into the knowledge graph.
+ *
+ * Parses YAML frontmatter with fields: number, title, date, status, tier,
+ * source, supersedes. Creates `decision` type graph nodes with `decided`
+ * edges to code nodes mentioned in the body.
+ */
+declare class DecisionIngestor {
+    private readonly store;
+    constructor(store: GraphStore);
+    ingest(decisionsDir: string): Promise<IngestResult>;
+    private parseFrontmatter;
+    private linkToCode;
+    private findDecisionFiles;
+}
+
 declare class RequirementIngestor {
     private readonly store;
     constructor(store: GraphStore);
@@ -454,6 +512,372 @@ declare class RequirementIngestor {
     private linkByKeywordOverlap;
 }
 
+type DriftClassification = 'new' | 'drifted' | 'stale' | 'contradicting';
+interface KnowledgeSnapshotEntry {
+    readonly id: string;
+    readonly type: NodeType;
+    readonly contentHash: string;
+    readonly source: string;
+    readonly name: string;
+}
+interface KnowledgeSnapshot {
+    readonly entries: readonly KnowledgeSnapshotEntry[];
+    readonly timestamp: string;
+}
+interface DriftFinding {
+    readonly entryId: string;
+    readonly classification: DriftClassification;
+    readonly current?: KnowledgeSnapshotEntry;
+    readonly fresh?: KnowledgeSnapshotEntry;
+    readonly severity: 'critical' | 'high' | 'medium' | 'low';
+}
+interface DriftResult {
+    readonly findings: readonly DriftFinding[];
+    readonly driftScore: number;
+    readonly summary: {
+        readonly new: number;
+        readonly drifted: number;
+        readonly stale: number;
+        readonly contradicting: number;
+    };
+}
+interface DriftDetector {
+    detect(current: KnowledgeSnapshot, fresh: KnowledgeSnapshot): DriftResult;
+}
+declare class StructuralDriftDetector implements DriftDetector {
+    detect(current: KnowledgeSnapshot, fresh: KnowledgeSnapshot): DriftResult;
+}
+
+/**
+ * Knowledge Staging Aggregator
+ *
+ * Merges extraction results from multiple sources (code extractors, linkers, diagrams),
+ * deduplicates by contentHash, writes staged JSONL, and generates gap reports.
+ */
+
+interface StagedEntry {
+    readonly id: string;
+    readonly source: 'extractor' | 'linker' | 'diagram';
+    readonly extractorName?: string;
+    readonly nodeType: NodeType;
+    readonly name: string;
+    readonly confidence: number;
+    readonly contentHash: string;
+    readonly timestamp: string;
+}
+interface GapEntry {
+    readonly nodeId: string;
+    readonly name: string;
+    readonly nodeType: NodeType;
+    readonly source: string;
+    readonly hasContent: boolean;
+}
+interface DomainCoverage {
+    readonly domain: string;
+    readonly entryCount: number;
+    readonly extractedCount: number;
+    readonly gapCount: number;
+    readonly gapEntries: readonly GapEntry[];
+}
+interface GapReport {
+    readonly domains: readonly DomainCoverage[];
+    readonly totalEntries: number;
+    readonly totalExtracted: number;
+    readonly totalGaps: number;
+    readonly generatedAt: string;
+}
+interface AggregateResult {
+    readonly staged: number;
+}
+declare class KnowledgeStagingAggregator {
+    private readonly projectDir;
+    constructor(projectDir: string);
+    aggregate(extractorResults: readonly StagedEntry[], linkerResults: readonly StagedEntry[], diagramResults: readonly StagedEntry[]): Promise<AggregateResult>;
+    private extractDocName;
+    generateGapReport(knowledgeDir: string, store?: GraphStore): Promise<GapReport>;
+    writeGapReport(report: GapReport): Promise<void>;
+}
+
+interface AnalysisRequest {
+    prompt: string;
+    systemPrompt?: string;
+    responseSchema: unknown;
+    model?: string;
+    maxTokens?: number;
+}
+interface AnalysisResponse<T> {
+    result: T;
+    tokenUsage: {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+    };
+    model: string;
+    latencyMs: number;
+}
+interface AnalysisProvider {
+    analyze<T>(request: AnalysisRequest): Promise<AnalysisResponse<T>>;
+}
+interface DetectedElement {
+    readonly type: string;
+    readonly label: string;
+    readonly confidence: number;
+}
+interface ImageAnalysisResult {
+    readonly description: string;
+    readonly detectedElements: readonly DetectedElement[];
+    readonly extractedText: readonly string[];
+    readonly designPatterns: readonly string[];
+    readonly accessibilityNotes: readonly string[];
+}
+interface ImageAnalysisExtractorOptions {
+    readonly analysisProvider: AnalysisProvider;
+    readonly maxFileSizeMB?: number;
+}
+declare class ImageAnalysisExtractor {
+    private readonly provider;
+    /** Maximum file size in bytes. Reserved for future file-size filtering. */
+    readonly maxFileSizeBytes: number;
+    constructor(options: ImageAnalysisExtractorOptions);
+    analyze(store: GraphStore, imagePaths: readonly string[]): Promise<IngestResult>;
+    /** Analyze a single image and add annotation + concept nodes to the store. */
+    private processImage;
+    /** Link annotation to its source file node if it exists. Returns 1 if linked, 0 otherwise. */
+    private linkToFileNode;
+    /** Create a business_concept node for a design pattern and link it. Returns edges added. */
+    private addDesignPatternConcept;
+}
+
+type ConflictType = 'value_mismatch' | 'definition_conflict' | 'status_divergence' | 'temporal_conflict';
+interface ContradictionEntry {
+    readonly nodeId: string;
+    readonly source: string;
+    readonly name: string;
+    readonly content: string;
+    readonly lastModified?: string | undefined;
+}
+interface Contradiction {
+    readonly id: string;
+    readonly entityA: ContradictionEntry;
+    readonly entityB: ContradictionEntry;
+    readonly similarity: number;
+    readonly conflictType: ConflictType;
+    readonly severity: 'critical' | 'high' | 'medium';
+    readonly description: string;
+}
+interface ContradictionResult {
+    readonly contradictions: readonly Contradiction[];
+    readonly sourcePairCounts: Record<string, number>;
+    readonly totalChecked: number;
+}
+declare class ContradictionDetector {
+    detect(store: GraphStore): ContradictionResult;
+}
+
+interface DomainCoverageScore {
+    readonly domain: string;
+    readonly score: number;
+    readonly knowledgeEntries: number;
+    readonly codeEntities: number;
+    readonly linkedEntities: number;
+    readonly unlinkedEntities: number;
+    readonly sourceBreakdown: Record<string, number>;
+    readonly grade: 'A' | 'B' | 'C' | 'D' | 'F';
+}
+interface CoverageReport {
+    readonly domains: readonly DomainCoverageScore[];
+    readonly overallScore: number;
+    readonly overallGrade: 'A' | 'B' | 'C' | 'D' | 'F';
+    readonly generatedAt: string;
+}
+declare class CoverageScorer {
+    score(store: GraphStore): CoverageReport;
+    private domainFromPath;
+}
+
+/**
+ * Knowledge Document Materializer
+ *
+ * Takes GapEntry[] from the differential gap report and creates
+ * docs/knowledge/{domain}/*.md files from graph nodes.
+ * Frontmatter is compatible with BusinessKnowledgeIngestor's parseFrontmatter().
+ */
+
+interface MaterializeOptions {
+    readonly projectDir: string;
+    readonly dryRun: boolean;
+    readonly maxDocs?: number;
+}
+interface MaterializeResult {
+    readonly created: readonly MaterializedDoc[];
+    readonly skipped: readonly SkippedEntry[];
+}
+interface MaterializedDoc {
+    readonly filePath: string;
+    readonly nodeId: string;
+    readonly domain: string;
+    readonly name: string;
+}
+interface SkippedEntry {
+    readonly nodeId: string;
+    readonly name: string;
+    readonly reason: 'no_content' | 'no_domain' | 'already_documented' | 'dry_run' | 'cap_reached';
+}
+declare class KnowledgeDocMaterializer {
+    private readonly store;
+    constructor(store: GraphStore);
+    materialize(gapEntries: readonly GapEntry[], options: MaterializeOptions): Promise<MaterializeResult>;
+    private resolveEntry;
+    inferDomain(node: GraphNode): string | null;
+    generateFilename(name: string): string;
+    resolveCollision(dir: string, basename: string): Promise<string>;
+    formatDoc(node: GraphNode, domain: string): string;
+    /** Check if a doc with a matching title already exists in the domain directory. */
+    private hasExistingDoc;
+    mapNodeType(node: GraphNode): NodeType;
+}
+
+/**
+ * KnowledgePipelineRunner — 4-phase convergence loop for knowledge extraction,
+ * reconciliation, drift detection, and remediation.
+ *
+ * Phases:
+ * 1. EXTRACT — Run code signal extractors, diagram parsers, image analysis, business knowledge ingestor, linker
+ * 2. RECONCILE — Compare pre-extraction graph snapshot against post-extraction snapshot + cross-source contradiction detection
+ * 3. DETECT — Classify findings by severity, generate gap report + coverage scoring
+ * 4. REMEDIATE — Apply safe fixes, converge (only with `fix: true`)
+ */
+
+interface KnowledgePipelineOptions {
+    readonly projectDir: string;
+    readonly fix: boolean;
+    readonly ci: boolean;
+    readonly domain?: string;
+    readonly graphDir?: string;
+    readonly maxIterations?: number;
+    readonly analyzeImages?: boolean;
+    readonly analysisProvider?: AnalysisProvider;
+    readonly imagePaths?: readonly string[];
+}
+interface ExtractionCounts {
+    readonly codeSignals: number;
+    readonly diagrams: number;
+    readonly linkerFacts: number;
+    readonly businessKnowledge: number;
+    readonly decisions: number;
+    readonly images: number;
+}
+interface KnowledgePipelineResult {
+    readonly verdict: 'pass' | 'warn' | 'fail';
+    readonly driftScore: number;
+    readonly iterations: number;
+    readonly findings: DriftResult['summary'];
+    readonly extraction: ExtractionCounts;
+    readonly gaps: GapReport;
+    readonly remediations: readonly string[];
+    readonly contradictions: ContradictionResult;
+    readonly coverage: CoverageReport;
+    readonly materialization?: MaterializeResult;
+}
+declare class KnowledgePipelineRunner {
+    private readonly store;
+    constructor(store: GraphStore);
+    run(options: KnowledgePipelineOptions): Promise<KnowledgePipelineResult>;
+    /** Run the remediation convergence loop; returns iteration count and accumulated materialization. */
+    private runRemediationLoop;
+    /** Assemble the final pipeline result. */
+    private buildResult;
+    private extract;
+    private buildSnapshot;
+    private reconcile;
+    private detect;
+    private remediate;
+    private stageNewFindings;
+    private classifySource;
+    private computeVerdict;
+}
+
+/**
+ * Shared types for diagram format parsers.
+ */
+interface DiagramEntity {
+    readonly id: string;
+    readonly label: string;
+    readonly type?: string;
+}
+interface DiagramRelationship {
+    readonly from: string;
+    readonly to: string;
+    readonly label?: string;
+}
+interface DiagramParseResult {
+    readonly entities: readonly DiagramEntity[];
+    readonly relationships: readonly DiagramRelationship[];
+    readonly metadata: {
+        readonly format: 'mermaid' | 'd2' | 'plantuml';
+        readonly diagramType: string;
+    };
+}
+interface DiagramFormatParser {
+    canParse(content: string, ext: string): boolean;
+    parse(content: string, filePath: string): DiagramParseResult;
+}
+
+/**
+ * Mermaid diagram format parser.
+ *
+ * Handles .mmd and .mermaid files, supporting flowchart and sequence diagram types.
+ */
+
+declare class MermaidParser implements DiagramFormatParser {
+    canParse(_content: string, ext: string): boolean;
+    parse(content: string, _filePath: string): DiagramParseResult;
+}
+
+/**
+ * D2 diagram format parser.
+ *
+ * Handles .d2 files, extracting entities and connections from D2 architecture diagrams.
+ */
+
+declare class D2Parser implements DiagramFormatParser {
+    canParse(_content: string, ext: string): boolean;
+    parse(content: string, _filePath: string): DiagramParseResult;
+}
+
+/**
+ * PlantUML diagram format parser.
+ *
+ * Handles .puml and .plantuml files, supporting class and component diagram types.
+ */
+
+declare class PlantUmlParser implements DiagramFormatParser {
+    canParse(_content: string, ext: string): boolean;
+    parse(content: string, _filePath: string): DiagramParseResult;
+}
+
+/**
+ * Diagram-as-code parser orchestrator.
+ *
+ * Delegates to format-specific parsers (Mermaid, D2, PlantUML) and maps
+ * extracted entities/relationships to the knowledge graph.
+ *
+ * Format-specific implementations live in ./parsers/.
+ */
+
+declare class DiagramParser {
+    private readonly store;
+    private readonly parsers;
+    constructor(store: GraphStore);
+    parse(content: string, filePath: string): DiagramParseResult;
+    ingest(projectDir: string): Promise<IngestResult>;
+    /** Map diagram entities to business_concept graph nodes. */
+    private addEntityNodes;
+    /** Map diagram relationships to references graph edges. */
+    private addRelationshipEdges;
+    private findDiagramFiles;
+}
+
 type HttpClient = (url: string, options?: {
     headers?: Record<string, string>;
 }) => Promise<{
@@ -467,6 +891,7 @@ interface ConnectorConfig {
     schedule?: string;
     lookbackDays?: number;
     filters?: Record<string, unknown>;
+    maxContentLength?: number;
     [key: string]: unknown;
 }
 interface GraphConnector {
@@ -506,6 +931,7 @@ declare class JiraConnector implements GraphConnector {
     ingest(store: GraphStore, config: ConnectorConfig): Promise<IngestResult>;
     private fetchAllIssues;
     private processIssue;
+    private fetchComments;
 }
 
 declare class SlackConnector implements GraphConnector {
@@ -515,6 +941,7 @@ declare class SlackConnector implements GraphConnector {
     constructor(httpClient?: HttpClient);
     ingest(store: GraphStore, config: ConnectorConfig): Promise<IngestResult>;
     private processChannel;
+    private fetchThreadReplies;
 }
 
 declare class ConfluenceConnector implements GraphConnector {
@@ -537,6 +964,30 @@ declare class CIConnector implements GraphConnector {
     private fetchAndIngestRuns;
 }
 
+declare class FigmaConnector implements GraphConnector {
+    readonly name = "figma";
+    readonly source = "figma";
+    private readonly httpClient;
+    constructor(httpClient?: HttpClient);
+    ingest(store: GraphStore, config: ConnectorConfig): Promise<IngestResult>;
+    private processFile;
+    private ingestStyles;
+    private processStyle;
+    private ingestComponents;
+    private processComponent;
+    private addComponentIntent;
+    private addComponentConstraint;
+}
+
+declare class MiroConnector implements GraphConnector {
+    readonly name = "miro";
+    readonly source = "miro";
+    private readonly httpClient;
+    constructor(httpClient?: HttpClient);
+    ingest(store: GraphStore, config: ConnectorConfig): Promise<IngestResult>;
+    private processBoard;
+}
+
 interface FusionResult {
     readonly nodeId: string;
     readonly node: GraphNode;
@@ -999,6 +1450,161 @@ declare class GraphConstraintAdapter {
     private resolveLayer;
 }
 
+/** Languages supported by the code signal extractors. */
+type Language = 'typescript' | 'javascript' | 'python' | 'go' | 'rust' | 'java';
+/**
+ * A single business-signal extraction record.
+ * Written to JSONL and used to create provisional graph nodes.
+ */
+interface ExtractionRecord {
+    /** Deterministic ID: `extracted:<extractor>:<hash(filePath+':'+patternKey)>` */
+    readonly id: string;
+    /** Which extractor produced this record. */
+    readonly extractor: string;
+    /** Source language of the file. */
+    readonly language: Language;
+    /** File path relative to project root. */
+    readonly filePath: string;
+    /** Start line of the extracted pattern (1-based). */
+    readonly line: number;
+    /** Graph node type this maps to. */
+    readonly nodeType: NodeType;
+    /** Human-readable label for the extracted fact. */
+    readonly name: string;
+    /** Raw extracted text. */
+    readonly content: string;
+    /** Extraction confidence (0.0-1.0). */
+    readonly confidence: number;
+    /** Extractor-specific metadata. */
+    readonly metadata: Record<string, unknown>;
+}
+/**
+ * Interface for pluggable code signal extractors.
+ * Each extractor scans file content and returns extraction records.
+ */
+interface SignalExtractor {
+    /** Unique extractor identifier (e.g. 'test-descriptions'). */
+    readonly name: string;
+    /** File extensions this extractor can process. */
+    readonly supportedExtensions: readonly string[];
+    /** Extract signals from a single file's content. */
+    extract(content: string, filePath: string, language: Language): ExtractionRecord[];
+}
+
+/** Detect language from a file path. Returns undefined if unsupported. */
+declare function detectLanguage(filePath: string): Language | undefined;
+/**
+ * Orchestrates code signal extraction across a project.
+ * Walks files, dispatches to registered extractors, writes JSONL,
+ * persists to graph, and handles stale detection.
+ */
+declare class ExtractionRunner {
+    private readonly extractors;
+    constructor(extractors: readonly SignalExtractor[]);
+    /**
+     * Run all extractors against a project directory.
+     * @param projectDir - Project root directory
+     * @param store - GraphStore for node/edge persistence
+     * @param outputDir - Directory for JSONL output (e.g. .harness/knowledge/extracted/)
+     */
+    run(projectDir: string, store: GraphStore, outputDir: string): Promise<IngestResult>;
+    /** Write extraction records to JSONL file. */
+    writeJsonl(records: readonly ExtractionRecord[], outputDir: string, extractorName: string): Promise<void>;
+    /** Create or update a graph node from an extraction record. */
+    private persistRecord;
+    /**
+     * Mark nodes from previous extractions that are no longer present as stale.
+     * Returns the number of nodes marked stale.
+     */
+    markStale(store: GraphStore, currentIds: Set<string>): number;
+    /** Recursively find source files, skipping common non-source directories. */
+    findSourceFiles(dir: string): Promise<string[]>;
+}
+
+/**
+ * Extracts business rules from test descriptions.
+ * Finds describe/it/test blocks (TS/JS), test_ functions (Python),
+ * Test* functions + t.Run subtests (Go), #[test] fns (Rust),
+ * @Test + @DisplayName (Java).
+ */
+declare class TestDescriptionExtractor implements SignalExtractor {
+    readonly name = "test-descriptions";
+    readonly supportedExtensions: string[];
+    extract(content: string, filePath: string, language: Language): ExtractionRecord[];
+    private extractJsTs;
+    private extractPython;
+    private extractGo;
+    private extractRust;
+    private extractJava;
+}
+
+/**
+ * Extracts domain vocabulary from enum and constant definitions.
+ * Finds enum declarations (all langs), as const objects (TS),
+ * Object.freeze (JS), StrEnum/IntEnum (Python), iota (Go).
+ */
+declare class EnumConstantExtractor implements SignalExtractor {
+    readonly name = "enum-constants";
+    readonly supportedExtensions: string[];
+    extract(content: string, filePath: string, language: Language): ExtractionRecord[];
+    private extractTypeScript;
+    private extractJavaScript;
+    private extractPython;
+    private extractGo;
+    private extractRust;
+    private extractJava;
+    private collectEnumMembers;
+    private collectObjectKeys;
+    private findClosingBrace;
+    private collectPythonEnumMembers;
+    private collectRustEnumVariants;
+    private collectJavaEnumConstants;
+}
+
+/**
+ * Extracts business constraints from validation schemas and decorators.
+ * Finds Zod schemas (TS/JS), Pydantic models (Python), struct validate
+ * tags (Go), #[validate] macros (Rust), Bean Validation (Java).
+ */
+declare class ValidationRuleExtractor implements SignalExtractor {
+    readonly name = "validation-rules";
+    readonly supportedExtensions: string[];
+    extract(content: string, filePath: string, language: Language): ExtractionRecord[];
+    private extractZod;
+    private collectZodConstraints;
+    private extractPydantic;
+    private collectPydanticConstraints;
+    private extractGoValidate;
+    private collectGoValidateTags;
+    private extractRustValidate;
+    private collectRustValidateAttrs;
+    private extractBeanValidation;
+    private findJavaClasses;
+    private findClosingBrace;
+    private collectBeanConstraints;
+}
+
+/**
+ * Extracts API route definitions revealing the domain model.
+ * Finds Express/Hono routes (TS/JS), FastAPI/Flask decorators (Python),
+ * Gin/Echo/http handlers (Go), Actix macros (Rust), Spring annotations (Java).
+ */
+declare class ApiPathExtractor implements SignalExtractor {
+    readonly name = "api-paths";
+    readonly supportedExtensions: string[];
+    extract(content: string, filePath: string, language: Language): ExtractionRecord[];
+    private extractJsTs;
+    private extractPython;
+    private extractGo;
+    private extractRust;
+    private extractJava;
+}
+
+/** All built-in code signal extractors. */
+declare const ALL_EXTRACTORS: readonly SignalExtractor[];
+/** Create an ExtractionRunner with all built-in extractors. */
+declare function createExtractionRunner(): ExtractionRunner;
+
 declare class DesignIngestor {
     private readonly store;
     constructor(store: GraphStore);
@@ -1219,6 +1825,6 @@ declare class CascadeSimulator {
     private buildResult;
 }
 
-declare const VERSION = "0.4.3";
+declare const VERSION = "0.6.0";
 
-export { type AnomalyDetectionOptions, type AnomalyReport, type ArticulationPoint, type AskGraphResult, type AssembledContext, Assembler, CIConnector, CURRENT_SCHEMA_VERSION, type PackedEnvelope as CacheableEnvelope, type CascadeLayer, type CascadeNode, type CascadeResult, type CascadeSimulationOptions, CascadeSimulator, type ClassificationResult, CodeIngestor, CompositeProbabilityStrategy, type ConflictDetail, type ConflictPrediction, ConflictPredictor, type ConflictSeverity, ConfluenceConnector, type ConnectorConfig, ContextQL, type ContextQLParams, type ContextQLResult, DesignConstraintAdapter, DesignIngestor, type DesignStrictness, type DesignViolation, EDGE_TYPES, type EdgeQuery, type EdgeType, EntityExtractor, EntityResolver, FusionLayer, type FusionResult, GitIngestor, type GitRunner, GraphAnomalyAdapter, type GraphBudget, GraphComplexityAdapter, type GraphComplexityHotspot, type GraphComplexityResult, type GraphConnector, GraphConstraintAdapter, GraphCouplingAdapter, type GraphCouplingFileData, type GraphCouplingResult, type GraphCoverageReport, type GraphDeadCodeData, type GraphDependencyData, type GraphDriftData, type GraphEdge, GraphEdgeSchema, GraphEntropyAdapter, GraphFeedbackAdapter, type GraphFilterResult, type GraphHarnessCheckData, type GraphImpactData, type GraphLayerViolation, type GraphMetadata, type GraphNode, GraphNodeSchema, type GraphSnapshotSummary, type GraphStabilityTier, GraphStore, type HttpClient, INTENTS, type ImpactGroups, type IndependenceCheckParams, type IndependenceResult, type IngestResult, type Intent, IntentClassifier, JiraConnector, KnowledgeIngestor, type LinkResult, NODE_STABILITY, NODE_TYPES, type NodeCategory, type NodeQuery, type NodeType, OBSERVABILITY_TYPES, type OverlapDetail, PackedSummaryCache, type PairResult, type ProbabilityStrategy, type ProjectionSpec, type RequirementCoverage, RequirementIngestor, type ResolvedEntity, ResponseFormatter, SlackConnector, type SourceLocation, type StatisticalOutlier, SyncManager, type SyncMetadata, type TaskDefinition, TaskIndependenceAnalyzer, TopologicalLinker, type TraceabilityOptions, type TraceabilityResult, type TracedFile, VERSION, type VectorSearchResult, VectorStore, askGraph, classifyNodeCategory, groupNodesByImpact, linkToCode, loadGraph, normalizeIntent, project, queryTraceability, saveGraph };
+export { ALL_EXTRACTORS, type AggregateResult, type AnomalyDetectionOptions, type AnomalyReport, ApiPathExtractor, type ArticulationPoint, type AskGraphResult, type AssembledContext, Assembler, BusinessKnowledgeIngestor, CIConnector, CURRENT_SCHEMA_VERSION, type PackedEnvelope as CacheableEnvelope, type CascadeLayer, type CascadeNode, type CascadeResult, type CascadeSimulationOptions, CascadeSimulator, type ClassificationResult, CodeIngestor, CompositeProbabilityStrategy, type ConflictDetail, type ConflictPrediction, ConflictPredictor, type ConflictSeverity, type ConflictType, ConfluenceConnector, type ConnectorConfig, ContextQL, type ContextQLParams, type ContextQLResult, type Contradiction, ContradictionDetector, type ContradictionEntry, type ContradictionResult, type CoverageReport, CoverageScorer, D2Parser, DecisionIngestor, DesignConstraintAdapter, DesignIngestor, type DesignStrictness, type DesignViolation, type DetectedElement, type DiagramEntity, type DiagramFormatParser, type DiagramParseResult, DiagramParser, type DiagramRelationship, type DomainCoverage, type DomainCoverageScore, type DriftClassification, type DriftDetector, type DriftFinding, type DriftResult, EDGE_TYPES, type EdgeQuery, type EdgeType, EntityExtractor, EntityResolver, EnumConstantExtractor, type ExtractionCounts, type ExtractionRecord, ExtractionRunner, FigmaConnector, FusionLayer, type FusionResult, type GapEntry, type GapReport, GitIngestor, type GitRunner, GraphAnomalyAdapter, type GraphBudget, GraphComplexityAdapter, type GraphComplexityHotspot, type GraphComplexityResult, type GraphConnector, GraphConstraintAdapter, GraphCouplingAdapter, type GraphCouplingFileData, type GraphCouplingResult, type GraphCoverageReport, type GraphDeadCodeData, type GraphDependencyData, type GraphDriftData, type GraphEdge, GraphEdgeSchema, GraphEntropyAdapter, GraphFeedbackAdapter, type GraphFilterResult, type GraphHarnessCheckData, type GraphImpactData, type GraphLayerViolation, type GraphMetadata, type GraphNode, GraphNodeSchema, type GraphSnapshotSummary, type GraphStabilityTier, GraphStore, type HttpClient, INTENTS, ImageAnalysisExtractor, type ImageAnalysisExtractorOptions, type AnalysisProvider as ImageAnalysisProvider, type ImageAnalysisResult, type ImpactGroups, type IndependenceCheckParams, type IndependenceResult, type IngestResult, type Intent, IntentClassifier, JiraConnector, KnowledgeDocMaterializer, KnowledgeIngestor, type KnowledgePipelineOptions, type KnowledgePipelineResult, KnowledgePipelineRunner, type KnowledgeSnapshot, type KnowledgeSnapshotEntry, KnowledgeStagingAggregator, type Language, type LinkResult, type LoadGraphResult, type MaterializeOptions, type MaterializeResult, type MaterializedDoc, MermaidParser, MiroConnector, NODE_STABILITY, NODE_TYPES, type NodeCategory, type NodeQuery, type NodeType, OBSERVABILITY_TYPES, type OverlapDetail, PackedSummaryCache, type PairResult, PlantUmlParser, type ProbabilityStrategy, type ProjectionSpec, type RequirementCoverage, RequirementIngestor, type ResolvedEntity, ResponseFormatter, type SignalExtractor, type SkippedEntry, SlackConnector, type SourceLocation, type StagedEntry, type StatisticalOutlier, StructuralDriftDetector, SyncManager, type SyncMetadata, type TaskDefinition, TaskIndependenceAnalyzer, TestDescriptionExtractor, TopologicalLinker, type TraceabilityOptions, type TraceabilityResult, type TracedFile, VERSION, ValidationRuleExtractor, type VectorSearchResult, VectorStore, askGraph, classifyNodeCategory, createExtractionRunner, detectLanguage, groupNodesByImpact, linkToCode, loadGraph, normalizeIntent, project, queryTraceability, saveGraph };