mindgraph-core 0.1.1 → 0.1.2

package/dist/ingestion/chunk-id.js

@@ -42,4 +42,45 @@ export function generateThoughtId(statementHash) {
 export function generateNoteId(notePath) {
     return `note:${hashContent(notePath)}`;
 }
+/**
+ * Generate a stable node ID for a location.
+ */
+export function generateLocationId(name) {
+    const normalized = name.toLowerCase().replace(/\s+/g, '_');
+    return `location:${normalized}`;
+}
+/**
+ * Generate a stable node ID for an event.
+ */
+export function generateEventId(name) {
+    const normalized = name.toLowerCase().replace(/\s+/g, '_');
+    return `event:${normalized}`;
+}
+/**
+ * Generate a stable node ID for an emotion.
+ */
+export function generateEmotionId(name) {
+    const normalized = name.toLowerCase().replace(/\s+/g, '_');
+    return `emotion:${normalized}`;
+}
+/**
+ * Generate a stable node ID for an emotional event.
+ */
+export function generateEmotionalEventId(emotion, trigger) {
+    const hash = hashContent(`${emotion}::${trigger}`);
+    return `emoevt:${hash}`;
+}
+/**
+ * Generate a stable node ID for a reasoning chain.
+ */
+export function generateReasoningChainId(topic, conclusion) {
+    const hash = hashContent(`${topic}::${conclusion}`);
+    return `rchain:${hash}`;
+}
+/**
+ * Generate a stable node ID for a reasoning step.
+ */
+export function generateReasoningStepId(chainId, stepIndex) {
+    return `rstep:${chainId}:${stepIndex}`;
+}
 //# sourceMappingURL=chunk-id.js.map

package/dist/ingestion/chunk-id.js.map

@@ -1 +1 @@
-{"version":3,"file":"chunk-id.js","sourceRoot":"","sources":["../../src/ingestion/chunk-id.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE1C;;;;GAIG;AACH,MAAM,UAAU,eAAe,CAAC,QAAgB,EAAE,KAAa,EAAE,IAAY;IAC3E,qEAAqE;IACrE,MAAM,IAAI,GAAG,GAAG,QAAQ,KAAK,KAAK,EAAE,CAAC;IACrC,MAAM,IAAI,GAAG,WAAW,CAAC,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC;IACpD,OAAO,SAAS,WAAW,CAAC,QAAQ,CAAC,IAAI,KAAK,IAAI,IAAI,EAAE,CAAC;AAC3D,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAY;IAC3C,MAAM,UAAU,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC3D,OAAO,UAAU,UAAU,EAAE,CAAC;AAChC,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,iBAAiB,CAAC,IAAY;IAC5C,MAAM,UAAU,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC3D,OAAO,WAAW,UAAU,EAAE,CAAC;AACjC,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,qBAAqB,CAAC,aAAqB;IACzD,OAAO,QAAQ,aAAa,EAAE,CAAC;AACjC,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,iBAAiB,CAAC,aAAqB;IACrD,OAAO,WAAW,aAAa,EAAE,CAAC;AACpC,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,cAAc,CAAC,QAAgB;IAC7C,OAAO,QAAQ,WAAW,CAAC,QAAQ,CAAC,EAAE,CAAC;AACzC,CAAC"}
+{"version":3,"file":"chunk-id.js","sourceRoot":"","sources":["../../src/ingestion/chunk-id.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE1C;;;;GAIG;AACH,MAAM,UAAU,eAAe,CAAC,QAAgB,EAAE,KAAa,EAAE,IAAY;IAC3E,qEAAqE;IACrE,MAAM,IAAI,GAAG,GAAG,QAAQ,KAAK,KAAK,EAAE,CAAC;IACrC,MAAM,IAAI,GAAG,WAAW,CAAC,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC;IACpD,OAAO,SAAS,WAAW,CAAC,QAAQ,CAAC,IAAI,KAAK,IAAI,IAAI,EAAE,CAAC;AAC3D,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAY;IAC3C,MAAM,UAAU,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC3D,OAAO,UAAU,UAAU,EAAE,CAAC;AAChC,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,iBAAiB,CAAC,IAAY;IAC5C,MAAM,UAAU,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC3D,OAAO,WAAW,UAAU,EAAE,CAAC;AACjC,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,qBAAqB,CAAC,aAAqB;IACzD,OAAO,QAAQ,aAAa,EAAE,CAAC;AACjC,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,iBAAiB,CAAC,aAAqB;IACrD,OAAO,WAAW,aAAa,EAAE,CAAC;AACpC,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,cAAc,CAAC,QAAgB;IAC7C,OAAO,QAAQ,WAAW,CAAC,QAAQ,CAAC,EAAE,CAAC;AACzC,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,kBAAkB,CAAC,IAAY;IAC7C,MAAM,UAAU,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC3D,OAAO,YAAY,UAAU,EAAE,CAAC;AAClC,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,eAAe,CAAC,IAAY;IAC1C,MAAM,UAAU,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC3D,OAAO,SAAS,UAAU,EAAE,CAAC;AAC/B,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,iBAAiB,CAAC,IAAY;IAC5C,MAAM,UAAU,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC3D,OAAO,WAAW,UAAU,EAAE,CAAC;AACjC,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,wBAAwB,CAAC,OAAe,EAAE,OAAe;IACvE,MAAM,IAAI,GAAG,WAAW,CAAC,GAAG,OAAO,KAAK,OAAO,EAAE,CAAC,CAAC;IACnD,OAAO,UAAU,IAAI,EAAE,CAAC;AAC1B,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,wBAAwB,CAAC,KAAa,EAAE,UAAkB;IACxE,MAAM,IAAI,GAAG,WAAW,CAAC,GAAG,KAAK,KAAK,UAAU,EAAE,CAAC,CAAC;IACpD,OAAO,UAAU,IAAI,EAAE,CAAC;AAC1B,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,uBAAuB,CAAC,OAAe,EAAE,SAAiB;IACxE,OAAO,SAAS,OAAO,IAAI,SAAS,EAAE,CAAC;AACzC,CAAC"}

package/dist/ingestion/pipeline.d.ts

@@ -14,6 +14,12 @@ export interface PipelineStats {
     conceptsExtracted: number;
     propositionsExtracted: number;
     thoughtsExtracted: number;
+    locationsExtracted: number;
+    eventsExtracted: number;
+    emotionsExtracted: number;
+    emotionalEventsExtracted: number;
+    reasoningChainsExtracted: number;
+    relationshipsCreated: number;
     embeddingsCreated: number;
     contradictionsDetected: number;
     skipped: boolean;
@@ -30,6 +36,11 @@ export declare class IngestionPipeline {
     private entityResolver;
     private contradictionDetector;
     private entityIndex;
+    private pendingRelationships;
+    private pendingPropRelationships;
+    private pendingEmotions;
+    private pendingEmotionalEvents;
+    private pendingReasoningChains;
     constructor(storage: StorageAdapter, embedder: EmbeddingProvider | null, extractor: ExtractionProvider, options?: PipelineOptions);
     private getEntityIndex;
     /**
@@ -47,6 +58,14 @@ export declare class IngestionPipeline {
     private processChunk;
     private storeProposition;
     private storeThought;
+    private storeLocation;
+    private storeEvent;
+    private storeEmotion;
+    private storeEmotionalEvent;
+    private storeReasoningChain;
+    private storeAuthoredBy;
+    private storeExtractedRelationships;
+    private storePropositionRelationships;
     private createAboutEdgesFromChunkMentions;
     private createAboutEdgesForThought;
     private storeResolvedEntities;

package/dist/ingestion/pipeline.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pipeline.d.ts","sourceRoot":"","sources":["../../src/ingestion/pipeline.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AACtE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qCAAqC,CAAC;AAC7E,OAAO,KAAK,EAAE,kBAAkB,EAAoB,MAAM,sCAAsC,CAAC;AAKjG,OAAO,EAA+C,KAAK,cAAc,EAAE,MAAM,cAAc,CAAC;AAKhG,MAAM,WAAW,eAAe;IAC9B,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,4BAA4B,CAAC,EAAE,OAAO,CAAC;CACxC;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,qBAAqB,EAAE,MAAM,CAAC;IAC9B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,sBAAsB,EAAE,MAAM,CAAC;IAC/B,OAAO,EAAE,OAAO,CAAC;CAClB;AAID;;;GAGG;AACH,qBAAa,iBAAiB;IAM1B,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,OAAO;IARjB,OAAO,CAAC,cAAc,CAAwB;IAC9C,OAAO,CAAC,qBAAqB,CAAwB;IACrD,OAAO,CAAC,WAAW,CAA4B;gBAGrC,OAAO,EAAE,cAAc,EACvB,QAAQ,EAAE,iBAAiB,GAAG,IAAI,EAClC,SAAS,EAAE,kBAAkB,EAC7B,OAAO,GAAE,eAAoB;YAKzB,cAAc;IAQ5B;;OAEG;IACG,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAgG1E;;OAEG;IACG,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAQjD;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;YAShB,YAAY;YAmEZ,gBAAgB;YAgFhB,YAAY;YAmEZ,iCAAiC;YA+BjC,0BAA0B;YAyC1B,qBAAqB;IAgN7B,cAAc,IAAI,OAAO,CAAC,MAAM,CAAC;YAqBzB,iBAAiB;YAuBjB,oBAAoB;YAkBpB,kBAAkB;CAgBjC"}
+{"version":3,"file":"pipeline.d.ts","sourceRoot":"","sources":["../../src/ingestion/pipeline.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AACtE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qCAAqC,CAAC;AAC7E,OAAO,KAAK,EACV,kBAAkB,EAOnB,MAAM,sCAAsC,CAAC;AAK9C,OAAO,EAA+C,KAAK,cAAc,EAAE,MAAM,cAAc,CAAC;AAiBhG,MAAM,WAAW,eAAe;IAC9B,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,4BAA4B,CAAC,EAAE,OAAO,CAAC;CACxC;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,qBAAqB,EAAE,MAAM,CAAC;IAC9B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,kBAAkB,EAAE,MAAM,CAAC;IAC3B,eAAe,EAAE,MAAM,CAAC;IACxB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,wBAAwB,EAAE,MAAM,CAAC;IACjC,wBAAwB,EAAE,MAAM,CAAC;IACjC,oBAAoB,EAAE,MAAM,CAAC;IAC7B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,sBAAsB,EAAE,MAAM,CAAC;IAC/B,OAAO,EAAE,OAAO,CAAC;CAClB;AAID;;;GAGG;AACH,qBAAa,iBAAiB;IAa1B,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,OAAO;IAfjB,OAAO,CAAC,cAAc,CAAwB;IAC9C,OAAO,CAAC,qBAAqB,CAAwB;IACrD,OAAO,CAAC,WAAW,CAA4B;IAG/C,OAAO,CAAC,oBAAoB,CAA+B;IAC3D,OAAO,CAAC,wBAAwB,CAA0C;IAC1E,OAAO,CAAC,eAAe,CAA0B;IACjD,OAAO,CAAC,sBAAsB,CAA4D;IAC1F,OAAO,CAAC,sBAAsB,CAA4D;gBAGhF,OAAO,EAAE,cAAc,EACvB,QAAQ,EAAE,iBAAiB,GAAG,IAAI,EAClC,SAAS,EAAE,kBAAkB,EAC7B,OAAO,GAAE,eAAoB;YAKzB,cAAc;IAQ5B;;OAEG;IACG,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAqI1E;;OAEG;IACG,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAQjD;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;YAShB,YAAY;YAsFZ,gBAAgB;YAgFhB,YAAY;YAmEZ,aAAa;YAqFb,UAAU;YA2GV,YAAY;YAuBZ,mBAAmB;YAmEnB,mBAAmB;YA+EnB,eAAe;YA8Bf,2BAA2B;YAoC3B,6BAA6B;YAmC7B,iCAAiC;YAgCjC,0BAA0B;YAyC1B,qBAAqB;IA4N7B,cAAc,IAAI,OAAO,CAAC,MAAM,CAAC;YAqBzB,iBAAiB;YAuBjB,oBAAoB;YAuBpB,kBAAkB;CAgBjC"}

package/dist/ingestion/pipeline.js

@@ -3,7 +3,7 @@ import { EntityIndex } from '../extraction/entity-index.js';
 import { applyConfidenceGate } from '../extraction/confidence-gate.js';
 import { ContradictionDetector } from '../extraction/contradiction-detector.js';
 import { chunkMarkdown, stripFrontmatter } from './chunker.js';
-import { generateNoteId, generateEntityId, generateConceptId, generatePropositionId, generateThoughtId } from './chunk-id.js';
+import { generateNoteId, generateEntityId, generateConceptId, generatePropositionId, generateThoughtId, generateLocationId, generateEventId, generateEmotionId, generateEmotionalEventId, generateReasoningChainId, generateReasoningStepId, } from './chunk-id.js';
 import { hashContent, hashStatement } from './hasher.js';
 import { NodeType, RelType } from '../schema/types.js';
 const DEFAULT_AGENT_ID = 'agent:self';
@@ -19,6 +19,12 @@ export class IngestionPipeline {
         this.options = options;
         this.entityResolver = new EntityResolver();
         this.entityIndex = null;
+        // Accumulated per-note extraction results for post-chunk processing
+        this.pendingRelationships = [];
+        this.pendingPropRelationships = [];
+        this.pendingEmotions = [];
+        this.pendingEmotionalEvents = [];
+        this.pendingReasoningChains = [];
         this.contradictionDetector = new ContradictionDetector(storage, embedder);
     }
     async getEntityIndex() {
@@ -39,6 +45,12 @@ export class IngestionPipeline {
             conceptsExtracted: 0,
             propositionsExtracted: 0,
             thoughtsExtracted: 0,
+            locationsExtracted: 0,
+            eventsExtracted: 0,
+            emotionsExtracted: 0,
+            emotionalEventsExtracted: 0,
+            reasoningChainsExtracted: 0,
+            relationshipsCreated: 0,
             embeddingsCreated: 0,
             contradictionsDetected: 0,
             skipped: false,
@@ -76,6 +88,10 @@ export class IngestionPipeline {
             updatedAt: now,
         };
         await this.storage.upsertNode(noteNode);
+        // AUTHORED_BY from frontmatter
+        if (frontmatter.author) {
+            await this.storeAuthoredBy(noteId, String(frontmatter.author), now);
+        }
         // Clean up old chunks for this note, then remove orphaned entities
         const affectedIds = await this.cleanupNoteChunks(noteId, notePath);
         await this.cleanupOrphanedNodes(affectedIds);
@@ -86,6 +102,11 @@ export class IngestionPipeline {
         await this.ensureDefaultAgent();
         // Process each chunk
         this.entityResolver.clear();
+        this.pendingRelationships = [];
+        this.pendingPropRelationships = [];
+        this.pendingEmotions = [];
+        this.pendingEmotionalEvents = [];
+        this.pendingReasoningChains = [];
         for (const chunk of chunks) {
             await this.processChunk(chunk, noteId, notePath, body, stats);
         }
@@ -109,8 +130,24 @@ export class IngestionPipeline {
                 // Embedding failure is non-fatal
             }
         }
-        // Store resolved entities and concepts (merged across all chunks)
+        // Store resolved entities, concepts, locations, events (merged across all chunks)
         await this.storeResolvedEntities(noteId, notePath, stats);
+        // Store emotions (global singletons)
+        for (const emotion of this.pendingEmotions) {
+            await this.storeEmotion(emotion, stats);
+        }
+        // Store emotional events
+        for (const emoEvent of this.pendingEmotionalEvents) {
+            await this.storeEmotionalEvent(emoEvent, emoEvent.chunkId, stats);
+        }
+        // Store reasoning chains
+        for (const chain of this.pendingReasoningChains) {
+            await this.storeReasoningChain(chain, chain.chunkId, stats);
+        }
+        // Store extracted relationships (after entities/locations/events are resolved)
+        await this.storeExtractedRelationships(stats);
+        // Store proposition relationships
+        await this.storePropositionRelationships(stats);
         return stats;
     }
     /**
@@ -165,13 +202,30 @@ export class IngestionPipeline {
         });
         // FTS entry
         await this.storage.upsertFTSEntry(chunk.id, chunk.text);
-        // Extract entities, concepts, propositions, thoughts
+        // Extract entities, concepts, propositions, thoughts, locations, events, emotions, reasoning
         try {
             let extraction = await this.extractor.extract(chunk, noteContent);
             extraction = applyConfidenceGate(extraction, this.options.confidenceThreshold ?? 0.5);
             // Collect for resolution
             this.entityResolver.addEntities(extraction.entities);
             this.entityResolver.addConcepts(extraction.concepts);
+            this.entityResolver.addLocations(extraction.locations);
+            this.entityResolver.addEvents(extraction.events);
+            // Accumulate relationships for post-chunk processing
+            this.pendingRelationships.push(...extraction.relationships);
+            this.pendingPropRelationships.push(...extraction.propositionRelationships);
+            // Deduplicate emotions across chunks, accumulate emotional events and reasoning chains
+            for (const emotion of extraction.emotions) {
+                if (!this.pendingEmotions.find((e) => e.name.toLowerCase() === emotion.name.toLowerCase())) {
+                    this.pendingEmotions.push(emotion);
+                }
+            }
+            for (const emoEvent of extraction.emotionalEvents) {
+                this.pendingEmotionalEvents.push({ ...emoEvent, chunkId: chunk.id });
+            }
+            for (const chain of extraction.reasoningChains) {
+                this.pendingReasoningChains.push({ ...chain, chunkId: chunk.id });
+            }
             // Store propositions immediately (they're per-chunk)
             for (const prop of extraction.propositions) {
                 await this.storeProposition(prop, chunk, notePath, stats);
@@ -308,6 +362,413 @@ export class IngestionPipeline {
         await this.createAboutEdgesForThought(thoughtId, thought.subject, now);
         stats.thoughtsExtracted++;
     }
+    async storeLocation(location, noteId, entityIndex, stats) {
+        const now = new Date().toISOString();
+        const existingId = entityIndex.findMatch(location.name, []);
+        let locationId;
+        if (existingId) {
+            locationId = existingId;
+            const existingNode = await this.storage.getNode(existingId);
+            if (existingNode) {
+                const existingData = existingNode.data;
+                await this.storage.upsertNode({
+                    id: existingId,
+                    nodeType: NodeType.Location,
+                    data: {
+                        name: existingData.name,
+                        locationType: existingData.locationType || location.locationType,
+                        ...(location.coordinates ? { coordinates: location.coordinates } : {}),
+                        ...(existingData.coordinates ? { coordinates: existingData.coordinates } : {}),
+                        confidence: Math.max(existingData.confidence, location.confidence),
+                    },
+                    createdAt: existingNode.createdAt,
+                    updatedAt: now,
+                });
+            }
+            else {
+                locationId = generateLocationId(location.name);
+                await this.storage.upsertNode({
+                    id: locationId,
+                    nodeType: NodeType.Location,
+                    data: {
+                        name: location.name,
+                        locationType: location.locationType,
+                        ...(location.coordinates ? { coordinates: location.coordinates } : {}),
+                        confidence: location.confidence,
+                    },
+                    createdAt: now,
+                    updatedAt: now,
+                });
+            }
+        }
+        else {
+            locationId = generateLocationId(location.name);
+            await this.storage.upsertNode({
+                id: locationId,
+                nodeType: NodeType.Location,
+                data: {
+                    name: location.name,
+                    locationType: location.locationType,
+                    ...(location.coordinates ? { coordinates: location.coordinates } : {}),
+                    confidence: location.confidence,
+                },
+                createdAt: now,
+                updatedAt: now,
+            });
+        }
+        entityIndex.register(locationId, location.name, []);
+        // MENTIONS edges from chunks that mention this location
+        const noteChunks = await this.storage.queryEdges({
+            sourceId: noteId,
+            relType: RelType.HAS_CHUNK,
+        });
+        for (const chunkEdge of noteChunks) {
+            const chunkNode = await this.storage.getNode(chunkEdge.targetId);
+            if (!chunkNode)
+                continue;
+            const chunkText = chunkNode.data.text ?? '';
+            if (chunkText.toLowerCase().includes(location.name.toLowerCase())) {
+                await this.storage.upsertEdge({
+                    id: `edge:mentions:${chunkEdge.targetId}:${locationId}`,
+                    sourceId: chunkEdge.targetId,
+                    targetId: locationId,
+                    relType: RelType.MENTIONS,
+                    data: { count: 1, spans: [] },
+                    createdAt: now,
+                });
+            }
+        }
+        stats.locationsExtracted++;
+    }
+    async storeEvent(event, noteId, entityIndex, stats) {
+        const now = new Date().toISOString();
+        const existingId = entityIndex.findMatch(event.name, []);
+        let eventId;
+        if (existingId) {
+            eventId = existingId;
+            const existingNode = await this.storage.getNode(existingId);
+            if (existingNode) {
+                const existingData = existingNode.data;
+                const existingParticipants = existingData.participants ?? [];
+                const allParticipants = new Set([...existingParticipants, ...event.participants]);
+                await this.storage.upsertNode({
+                    id: existingId,
+                    nodeType: NodeType.Event,
+                    data: {
+                        name: existingData.name,
+                        description: existingData.description || event.description,
+                        ...(event.date ? { date: event.date } : existingData.date ? { date: existingData.date } : {}),
+                        ...(event.dateGranularity ? { dateGranularity: event.dateGranularity } : existingData.dateGranularity ? { dateGranularity: existingData.dateGranularity } : {}),
+                        participants: Array.from(allParticipants),
+                        confidence: Math.max(existingData.confidence, event.confidence),
+                    },
+                    createdAt: existingNode.createdAt,
+                    updatedAt: now,
+                });
+            }
+            else {
+                eventId = generateEventId(event.name);
+                await this.storage.upsertNode({
+                    id: eventId,
+                    nodeType: NodeType.Event,
+                    data: {
+                        name: event.name,
+                        description: event.description,
+                        ...(event.date ? { date: event.date } : {}),
+                        ...(event.dateGranularity ? { dateGranularity: event.dateGranularity } : {}),
+                        participants: event.participants,
+                        confidence: event.confidence,
+                    },
+                    createdAt: now,
+                    updatedAt: now,
+                });
+            }
+        }
+        else {
+            eventId = generateEventId(event.name);
+            await this.storage.upsertNode({
+                id: eventId,
+                nodeType: NodeType.Event,
+                data: {
+                    name: event.name,
+                    description: event.description,
+                    ...(event.date ? { date: event.date } : {}),
+                    ...(event.dateGranularity ? { dateGranularity: event.dateGranularity } : {}),
+                    participants: event.participants,
+                    confidence: event.confidence,
+                },
+                createdAt: now,
+                updatedAt: now,
+            });
+        }
+        entityIndex.register(eventId, event.name, []);
+        // MENTIONS edges from chunks
+        const noteChunks = await this.storage.queryEdges({
+            sourceId: noteId,
+            relType: RelType.HAS_CHUNK,
+        });
+        for (const chunkEdge of noteChunks) {
+            const chunkNode = await this.storage.getNode(chunkEdge.targetId);
+            if (!chunkNode)
+                continue;
+            const chunkText = chunkNode.data.text ?? '';
+            if (chunkText.toLowerCase().includes(event.name.toLowerCase())) {
+                await this.storage.upsertEdge({
+                    id: `edge:mentions:${chunkEdge.targetId}:${eventId}`,
+                    sourceId: chunkEdge.targetId,
+                    targetId: eventId,
+                    relType: RelType.MENTIONS,
+                    data: { count: 1, spans: [] },
+                    createdAt: now,
+                });
+            }
+        }
+        // PARTICIPATED_IN edges for participants
+        for (const participantName of event.participants) {
+            const participantId = entityIndex.findMatch(participantName, []);
+            if (participantId) {
+                await this.storage.upsertEdge({
+                    id: `edge:participated:${participantId}:${eventId}`,
+                    sourceId: participantId,
+                    targetId: eventId,
+                    relType: RelType.PARTICIPATED_IN,
+                    data: { role: 'participant' },
+                    createdAt: now,
+                });
+            }
+        }
+        stats.eventsExtracted++;
+    }
+    async storeEmotion(emotion, stats) {
+        const now = new Date().toISOString();
+        const emotionId = generateEmotionId(emotion.name);
+        const existingNode = await this.storage.getNode(emotionId);
+        await this.storage.upsertNode({
+            id: emotionId,
+            nodeType: NodeType.Emotion,
+            data: {
+                name: emotion.name,
+                valence: emotion.valence,
+                arousal: emotion.arousal,
+            },
+            createdAt: existingNode?.createdAt ?? now,
+            updatedAt: now,
+        });
+        stats.emotionsExtracted++;
+    }
+    async storeEmotionalEvent(emoEvent, chunkId, stats) {
+        const now = new Date().toISOString();
+        const emoEventId = generateEmotionalEventId(emoEvent.emotion, emoEvent.trigger);
+        await this.storage.upsertNode({
+            id: emoEventId,
+            nodeType: NodeType.EmotionalEvent,
+            data: {
+                emotion: emoEvent.emotion,
+                intensity: emoEvent.intensity,
+                trigger: emoEvent.trigger,
+                context: emoEvent.context,
+                ...(emoEvent.date ? { date: emoEvent.date } : {}),
+            },
+            createdAt: now,
+            updatedAt: now,
+        });
+        // DERIVED_FROM edge to chunk
+        await this.storage.upsertEdge({
+            id: `edge:derived:${emoEventId}:${chunkId}`,
+            sourceId: emoEventId,
+            targetId: chunkId,
+            relType: RelType.DERIVED_FROM,
+            data: {
+                provenance: { notePath: '', chunkId, startOffset: 0, endOffset: 0, quoteText: '', quoteHash: '' },
+                extractionMethod: this.extractor.name,
+                extractedAt: now,
+            },
+            createdAt: now,
+        });
+        // FEELS edge from default agent to the emotion
+        const emotionId = generateEmotionId(emoEvent.emotion);
+        const emotionNode = await this.storage.getNode(emotionId);
+        if (emotionNode) {
+            await this.storage.upsertEdge({
+                id: `edge:feels:${DEFAULT_AGENT_ID}:${emotionId}:${emoEventId}`,
+                sourceId: DEFAULT_AGENT_ID,
+                targetId: emotionId,
+                relType: RelType.FEELS,
+                data: { intensity: emoEvent.intensity, date: emoEvent.date ?? now },
+                createdAt: now,
+            });
+        }
+        // TRIGGERED_BY edge to matching entity/event
+        const entityIndex = await this.getEntityIndex();
+        const triggerId = entityIndex.findMatch(emoEvent.trigger, []);
+        if (triggerId) {
+            await this.storage.upsertEdge({
+                id: `edge:triggered:${emoEventId}:${triggerId}`,
+                sourceId: emoEventId,
+                targetId: triggerId,
+                relType: RelType.TRIGGERED_BY,
+                data: { mechanism: 'extracted' },
+                createdAt: now,
+            });
+        }
+        stats.emotionalEventsExtracted++;
+    }
+    async storeReasoningChain(chain, chunkId, stats) {
+        const now = new Date().toISOString();
+        const chainId = generateReasoningChainId(chain.topic, chain.conclusion);
+        await this.storage.upsertNode({
+            id: chainId,
+            nodeType: NodeType.ReasoningChain,
+            data: {
+                topic: chain.topic,
+                conclusion: chain.conclusion,
+                strength: chain.strength,
+            },
+            createdAt: now,
+            updatedAt: now,
+        });
+        // DERIVED_FROM edge to chunk
+        await this.storage.upsertEdge({
+            id: `edge:derived:${chainId}:${chunkId}`,
+            sourceId: chainId,
+            targetId: chunkId,
+            relType: RelType.DERIVED_FROM,
+            data: {
+                provenance: { notePath: '', chunkId, startOffset: 0, endOffset: 0, quoteText: '', quoteHash: '' },
+                extractionMethod: this.extractor.name,
+                extractedAt: now,
+            },
+            createdAt: now,
+        });
+        // Store each step
+        let prevStepId = null;
+        for (const step of chain.steps) {
+            const stepId = generateReasoningStepId(chainId, step.stepIndex);
+            await this.storage.upsertNode({
+                id: stepId,
+                nodeType: NodeType.ReasoningStep,
+                data: {
+                    stepIndex: step.stepIndex,
+                    claim: step.claim,
+                    evidence: step.evidence,
+                    stepType: step.stepType,
+                },
+                createdAt: now,
+                updatedAt: now,
+            });
+            // HAS_STEP edge from chain to step
+            await this.storage.upsertEdge({
+                id: `edge:has_step:${chainId}:${stepId}`,
+                sourceId: chainId,
+                targetId: stepId,
+                relType: RelType.HAS_STEP,
+                data: { stepIndex: step.stepIndex },
+                createdAt: now,
+            });
+            // NEXT_STEP edge from previous step
+            if (prevStepId) {
+                await this.storage.upsertEdge({
+                    id: `edge:next_step:${prevStepId}:${stepId}`,
+                    sourceId: prevStepId,
+                    targetId: stepId,
+                    relType: RelType.NEXT_STEP,
+                    data: { transition: '' },
+                    createdAt: now,
+                });
+            }
+            prevStepId = stepId;
+        }
+        stats.reasoningChainsExtracted++;
+    }
+    async storeAuthoredBy(noteId, authorName, now) {
+        const authorId = `agent:${authorName.toLowerCase().replace(/\s+/g, '_')}`;
+        // Upsert Agent node for author
+        const existingAgent = await this.storage.getNode(authorId);
+        if (!existingAgent) {
+            await this.storage.upsertNode({
+                id: authorId,
+                nodeType: NodeType.Agent,
+                data: {
+                    name: authorName,
+                    agentType: 'person',
+                    description: `Author: ${authorName}`,
+                },
+                createdAt: now,
+                updatedAt: now,
+            });
+        }
+        // AUTHORED_BY edge from Note to Agent
+        await this.storage.upsertEdge({
+            id: `edge:authored:${noteId}:${authorId}`,
+            sourceId: noteId,
+            targetId: authorId,
+            relType: RelType.AUTHORED_BY,
+            data: { role: 'author' },
+            createdAt: now,
+        });
+    }
+    async storeExtractedRelationships(stats) {
+        const now = new Date().toISOString();
+        const entityIndex = await this.getEntityIndex();
+        const relTypeMap = {
+            IS_A: RelType.IS_A,
+            PART_OF: RelType.PART_OF,
+            RELATED_TO: RelType.RELATED_TO,
+            LOCATED_IN: RelType.LOCATED_IN,
+            OCCURRED_AT: RelType.OCCURRED_AT,
+            PRECEDES: RelType.PRECEDES,
+            CAUSES: RelType.CAUSES,
+            PARTICIPATED_IN: RelType.PARTICIPATED_IN,
+        };
+        for (const rel of this.pendingRelationships) {
+            const sourceId = entityIndex.findMatch(rel.sourceRef, []);
+            const targetId = entityIndex.findMatch(rel.targetRef, []);
+            if (!sourceId || !targetId)
+                continue;
+            const edgeRelType = relTypeMap[rel.relType];
+            if (!edgeRelType)
+                continue;
+            await this.storage.upsertEdge({
+                id: `edge:rel:${edgeRelType}:${sourceId}:${targetId}`,
+                sourceId,
+                targetId,
+                relType: edgeRelType,
+                data: { ...rel.data, confidence: rel.confidence },
+                createdAt: now,
+            });
+            stats.relationshipsCreated++;
+        }
+    }
+    async storePropositionRelationships(stats) {
+        const now = new Date().toISOString();
+        const relTypeMap = {
+            SUPPORTS: RelType.SUPPORTS,
+            QUALIFIES: RelType.QUALIFIES,
+        };
+        for (const rel of this.pendingPropRelationships) {
+            const sourceHash = hashStatement(rel.sourceStatement);
+            const targetHash = hashStatement(rel.targetStatement);
+            const sourceId = generatePropositionId(sourceHash);
+            const targetId = generatePropositionId(targetHash);
+            // Verify both propositions exist
+            const sourceNode = await this.storage.getNode(sourceId);
+            const targetNode = await this.storage.getNode(targetId);
+            if (!sourceNode || !targetNode)
+                continue;
+            const edgeRelType = relTypeMap[rel.relType];
+            if (!edgeRelType)
+                continue;
+            await this.storage.upsertEdge({
+                id: `edge:proprel:${edgeRelType}:${sourceId}:${targetId}`,
+                sourceId,
+                targetId,
+                relType: edgeRelType,
+                data: { ...rel.data, strength: rel.confidence, explanation: '' },
+                createdAt: now,
+            });
+            stats.relationshipsCreated++;
+        }
+    }
     async createAboutEdgesFromChunkMentions(propId, chunkId, now) {
         // Find entities/concepts mentioned in the source chunk
         const mentionEdges = await this.storage.queryEdges({
@@ -319,7 +780,8 @@ export class IngestionPipeline {
             if (targetNode &&
                 (targetNode.nodeType === NodeType.Entity ||
                     targetNode.nodeType === NodeType.Concept ||
-                    targetNode.nodeType === NodeType.Event)) {
+                    targetNode.nodeType === NodeType.Event ||
+                    targetNode.nodeType === NodeType.Location)) {
                 await this.storage.upsertEdge({
                     id: `edge:about:${propId}:${targetNode.id}`,
                     sourceId: propId,
@@ -370,6 +832,8 @@ export class IngestionPipeline {
         const now = new Date().toISOString();
         const entities = this.entityResolver.getResolvedEntities();
         const concepts = this.entityResolver.getResolvedConcepts();
+        const locations = this.entityResolver.getResolvedLocations();
+        const events = this.entityResolver.getResolvedEvents();
         const entityIndex = await this.getEntityIndex();
         for (const entity of entities) {
             const existingId = entityIndex.findMatch(entity.name, entity.aliases);
@@ -556,11 +1020,19 @@ export class IngestionPipeline {
             entityIndex.register(conceptId, cData.name, cData.aliases ?? []);
             stats.conceptsExtracted++;
         }
+        // Store locations
+        for (const location of locations) {
+            await this.storeLocation(location, noteId, entityIndex, stats);
+        }
+        // Store events
+        for (const event of events) {
+            await this.storeEvent(event, noteId, entityIndex, stats);
+        }
     }
     async cleanupOrphans() {
         const entityIndex = await this.getEntityIndex();
         let cleaned = 0;
-        for (const nodeType of [NodeType.Entity, NodeType.Concept]) {
+        for (const nodeType of [NodeType.Entity, NodeType.Concept, NodeType.Location, NodeType.Event]) {
             const nodes = await this.storage.queryNodes({ nodeType });
             for (const node of nodes) {
                 const mentionEdges = await this.storage.queryEdges({
@@ -605,7 +1077,10 @@ export class IngestionPipeline {
             const node = await this.storage.getNode(nodeId);
             if (!node)
                 continue;
-            if (node.nodeType !== NodeType.Entity && node.nodeType !== NodeType.Concept)
+            if (node.nodeType !== NodeType.Entity &&
+                node.nodeType !== NodeType.Concept &&
+                node.nodeType !== NodeType.Location &&
+                node.nodeType !== NodeType.Event)
                 continue;
             const mentions = await this.storage.queryEdges({ targetId: nodeId, relType: RelType.MENTIONS });
             if (mentions.length === 0) {