@harness-engineering/graph 0.4.2 → 0.5.0

package/dist/index.d.mts

@@ -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"];
+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"];
+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 {
@@ -68,9 +68,18 @@ interface GraphMetadata {
     readonly edgeCount: number;
 }
 declare const CURRENT_SCHEMA_VERSION = 1;
+/** Stability classification for prompt caching -- mirrors StabilityTier from @harness-engineering/types. */
+type GraphStabilityTier = 'static' | 'session' | 'ephemeral';
+/**
+ * Maps graph node types to their caching stability tier.
+ * Used by provider cache adapters to determine cache directives.
+ *
+ * Node types not listed here default to 'ephemeral' at resolution time.
+ */
+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"]>;
+    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<{
@@ -99,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";
+    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;
@@ -116,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";
+    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;
@@ -135,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"]>;
+    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";
+    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";
+    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;
@@ -245,6 +254,45 @@ interface SerializedGraph {
 declare function saveGraph(dirPath: string, nodes: readonly GraphNode[], edges: readonly GraphEdge[]): Promise<void>;
 declare function loadGraph(dirPath: string): Promise<SerializedGraph | null>;
 
+/**
+ * Minimal PackedEnvelope shape -- avoids circular dep on @harness-engineering/core.
+ * Canonical type: packages/core/src/compaction/envelope.ts — keep in sync.
+ */
+interface PackedEnvelope {
+    meta: {
+        strategy: string[];
+        originalTokenEstimate: number;
+        compactedTokenEstimate: number;
+        reductionPct: number;
+        cached: boolean;
+    };
+    sections: Array<{
+        source: string;
+        content: string;
+    }>;
+}
+
+/** Normalize an intent string for deterministic cache keying. */
+declare function normalizeIntent(intent: string): string;
+/** Reads/writes PackedSummary nodes in the GraphStore. Validates via TTL + source freshness. */
+declare class PackedSummaryCache {
+    private readonly store;
+    private readonly ttlMs;
+    constructor(store: GraphStore, ttlMs?: number);
+    /** Returns cached envelope with `cached: true` if valid, or null if miss/stale. */
+    get(intent: string): PackedEnvelope | null;
+    /** Parse and validate createdAt. Returns epoch ms or null if missing/malformed (GC-002). */
+    private parseCreatedMs;
+    /** GC-001: Checks source nodes exist and are unmodified since cache creation. */
+    private areSourcesFresh;
+    /** Parse envelope JSON and set cached: true. Returns null on invalid JSON. */
+    private parseEnvelope;
+    /** Write a PackedSummary node with caches edges to source nodes. */
+    set(intent: string, envelope: PackedEnvelope, sourceNodeIds: string[]): void;
+    /** Explicitly invalidate a cached packed summary. */
+    invalidate(intent: string): void;
+}
+
 declare class ContextQL {
     private readonly store;
     constructor(store: GraphStore);
@@ -274,8 +322,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;
@@ -285,12 +333,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.
@@ -298,11 +356,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;
@@ -313,7 +381,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>;
@@ -369,6 +437,18 @@ 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;
+}
+
 declare class RequirementIngestor {
     private readonly store;
     constructor(store: GraphStore);
@@ -406,6 +486,279 @@ 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 DomainCoverage {
+    readonly domain: string;
+    readonly entryCount: number;
+}
+interface GapReport {
+    readonly domains: readonly DomainCoverage[];
+    readonly totalEntries: 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>;
+    generateGapReport(knowledgeDir: string): 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>;
+}
+
+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;
+}
+
+/**
+ * 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 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;
+}
+declare class KnowledgePipelineRunner {
+    private readonly store;
+    constructor(store: GraphStore);
+    run(options: KnowledgePipelineOptions): Promise<KnowledgePipelineResult>;
+    private extract;
+    private buildSnapshot;
+    private reconcile;
+    private detect;
+    private remediate;
+    private stageNewFindings;
+    private classifySource;
+    private computeVerdict;
+}
+
+/**
+ * Diagram-as-code parser types and format-specific implementations.
+ *
+ * Extracts entities and relationships from diagram files (Mermaid, D2, PlantUML)
+ * and maps them to the knowledge graph.
+ */
+
+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;
+}
+declare class MermaidParser implements DiagramFormatParser {
+    canParse(_content: string, ext: string): boolean;
+    parse(content: string, _filePath: string): DiagramParseResult;
+    private detectDiagramType;
+    private parseFlowchart;
+    private isDecisionNode;
+    private parseSequence;
+}
+declare class D2Parser implements DiagramFormatParser {
+    canParse(_content: string, ext: string): boolean;
+    parse(content: string, _filePath: string): DiagramParseResult;
+}
+declare class PlantUmlParser implements DiagramFormatParser {
+    canParse(_content: string, ext: string): boolean;
+    parse(content: string, _filePath: string): DiagramParseResult;
+    private detectDiagramType;
+}
+declare class DiagramParser {
+    private readonly store;
+    private readonly parsers;
+    constructor(store: GraphStore);
+    parse(content: string, filePath: string): DiagramParseResult;
+    ingest(projectDir: string): Promise<IngestResult>;
+    private findDiagramFiles;
+}
+
 type HttpClient = (url: string, options?: {
     headers?: Record<string, string>;
 }) => Promise<{
@@ -419,6 +772,7 @@ interface ConnectorConfig {
     schedule?: string;
     lookbackDays?: number;
     filters?: Record<string, unknown>;
+    maxContentLength?: number;
     [key: string]: unknown;
 }
 interface GraphConnector {
@@ -458,6 +812,7 @@ declare class JiraConnector implements GraphConnector {
     ingest(store: GraphStore, config: ConnectorConfig): Promise<IngestResult>;
     private fetchAllIssues;
     private processIssue;
+    private fetchComments;
 }
 
 declare class SlackConnector implements GraphConnector {
@@ -467,6 +822,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 {
@@ -489,6 +845,24 @@ 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;
+}
+
+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;
@@ -951,6 +1325,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);
@@ -1171,6 +1700,6 @@ declare class CascadeSimulator {
     private buildResult;
 }
 
-declare const VERSION = "0.4.1";
+declare const VERSION = "0.4.3";
 
-export { type AnomalyDetectionOptions, type AnomalyReport, type ArticulationPoint, type AskGraphResult, type AssembledContext, Assembler, CIConnector, CURRENT_SCHEMA_VERSION, 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, GraphStore, type HttpClient, INTENTS, type ImpactGroups, type IndependenceCheckParams, type IndependenceResult, type IngestResult, type Intent, IntentClassifier, JiraConnector, KnowledgeIngestor, type LinkResult, NODE_TYPES, type NodeCategory, type NodeQuery, type NodeType, OBSERVABILITY_TYPES, type OverlapDetail, 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, 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, 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 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, KnowledgeIngestor, type KnowledgePipelineOptions, type KnowledgePipelineResult, KnowledgePipelineRunner, type KnowledgeSnapshot, type KnowledgeSnapshotEntry, KnowledgeStagingAggregator, type Language, type LinkResult, 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, 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 };