@devflow-tools/memory-engine 0.16.17 → 0.16.19

package/dist/memory-store.js

@@ -9,8 +9,10 @@ import { applyV4ToV5Migration } from './migrations/v4-to-v5.js';
 import { applyV6ToV7Migration } from './migrations/v6-to-v7.js';
 import { applyV7ToV8Migration } from './migrations/v7-to-v8.js';
 import { applyV8ToV9Migration } from './migrations/v8-to-v9.js';
+import { applyV9ToV10Migration } from './migrations/v9-to-v10.js';
 import { observationDedupKey, } from './observation-types.js';
 import { analysesConflict, analyzePreference, analyzePreferenceObservation, } from './preference-conflicts.js';
+import { mergeSemanticEntities, normalizeEntityKey, normalizeSemanticMemory, } from './semantic-memory.js';
 // ── Schema ─────────────────────────────────────────────
 const SCHEMA_V2 = `
 -- ============================================================
@@ -176,7 +178,17 @@ CREATE TABLE IF NOT EXISTS observations (
   timestamp        INTEGER NOT NULL,
   explicit_accepted_at INTEGER,
   evidence_status TEXT NOT NULL DEFAULT 'unverified',
-  evidence_details TEXT NOT NULL DEFAULT '[]'
+  evidence_details TEXT NOT NULL DEFAULT '[]',
+  semantic_subject TEXT NOT NULL DEFAULT '',
+  semantic_predicate TEXT NOT NULL DEFAULT '',
+  semantic_value TEXT NOT NULL DEFAULT '',
+  semantic_polarity TEXT NOT NULL DEFAULT 'neutral',
+  semantic_key TEXT,
+  facet_key TEXT,
+  entities TEXT NOT NULL DEFAULT '[]',
+  temporal TEXT,
+  reinforce_count INTEGER NOT NULL DEFAULT 0,
+  last_reinforced_at INTEGER
 );
 CREATE INDEX IF NOT EXISTS idx_observations_session ON observations(session_id);
 CREATE INDEX IF NOT EXISTS idx_observations_project ON observations(project);
@@ -411,6 +423,7 @@ export class MemoryStore {
         applyV6ToV7Migration(this.db);
         applyV7ToV8Migration(this.db);
         applyV8ToV9Migration(this.db);
+        applyV9ToV10Migration(this.db);
         this.repairOrphanSessions(rootPath);
         console.log('[MemoryStore] Schema initialized', {
             dbPath: this.dbPath,
@@ -1232,8 +1245,8 @@ export class MemoryStore {
         this.ensureSession(obs.sessionId, obs.project ?? this.defaultProjectRoot);
         const id = obs.id ?? `obs:${Date.now()}:${randomUUID().slice(0, 8)}`;
         const now = obs.timestamp ?? Date.now();
-        const dedupKey = observationDedupKey(obs.type, obs.title);
-        const duplicate = this.findObservationByDedupKey(dedupKey);
+        const dedupKey = obs.semantic?.semanticKey ?? observationDedupKey(obs.type, obs.title);
+        const duplicate = obs.semantic ? null : this.findObservationByDedupKey(dedupKey);
         if (duplicate) {
             this.linkObservationToEvents(duplicate.id, obs.sourceEventIds ?? []);
             this.incrementObservationAccess(duplicate.id, now);
@@ -1244,8 +1257,10 @@ export class MemoryStore {
         (id, session_id, project, type, title, narrative, facts, files, tools, concepts,
          importance, confidence, source, dedup_key, source_event_ids, timestamp, updated_at,
          quality_status, quarantine_reason, quality_details, quarantined_at,
-         failure_category, resolution_state, evidence_status, evidence_details)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+         failure_category, resolution_state, evidence_status, evidence_details,
+         semantic_subject, semantic_predicate, semantic_value, semantic_polarity,
+         semantic_key, facet_key, entities, temporal, reinforce_count, last_reinforced_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `).run(id, obs.sessionId, obs.project ?? this.defaultProjectRoot, obs.type, obs.title, obs.narrative ?? '', JSON.stringify(obs.facts ?? []), JSON.stringify(obs.files ?? []), JSON.stringify(obs.tools ?? []), JSON.stringify(obs.concepts ?? []), obs.importance ?? 5, obs.confidence ?? 0.5, obs.source ?? 'distill', dedupKey, JSON.stringify(obs.sourceEventIds ?? []), now, now, obs.qualityStatus ?? 'accepted', obs.quarantineReason ?? null, obs.qualityDetails ? JSON.stringify(obs.qualityDetails) : null, obs.qualityStatus === 'quarantined' ? now : null, obs.failureCategory ?? null, obs.resolutionState ?? 'current', obs.evidenceStatus
             ?? (obs.source === 'explicit_intent'
                 ? 'unverified'
@@ -1255,7 +1270,7 @@ export class MemoryStore {
             kind: 'source_event',
             source,
             summary: 'Observation was accepted from an evidence-bound session event.',
-        }))));
+        }))), obs.semantic?.subject ?? '', obs.semantic?.predicate ?? '', obs.semantic?.value ?? '', obs.semantic?.polarity ?? 'neutral', obs.semantic?.semanticKey ?? null, obs.semantic?.facetKey ?? null, JSON.stringify(obs.semantic?.entities ?? []), obs.semantic?.temporal ? JSON.stringify(obs.semantic.temporal) : null, 0, null);
         // Insert concept junction rows
         if (obs.concepts && obs.concepts.length > 0) {
             const insertConcept = this.db.prepare('INSERT OR IGNORE INTO observation_concepts (observation_id, concept) VALUES (?, ?)');
@@ -1263,11 +1278,184 @@ export class MemoryStore {
                 insertConcept.run(id, concept);
             }
         }
+        this.replaceObservationEntities(id, obs.project ?? this.defaultProjectRoot, obs.semantic?.entities ?? []);
         console.log('[MemoryStore] Observation added', {
             id, sessionId: obs.sessionId, type: obs.type, conceptCount: obs.concepts?.length ?? 0,
         });
         return this.getObservation(id);
     }
+    acceptSemanticObservation(obs) {
+        return this.db.transaction(() => {
+            const project = obs.project ?? this.defaultProjectRoot;
+            const now = obs.timestamp ?? Date.now();
+            const exact = this.findCurrentObservationBySemanticKey(project, obs.semantic.semanticKey)
+                ?? this.findCurrentObservationByNarrative(project, obs.narrative ?? '');
+            if (exact) {
+                const sourceEventIds = uniqueStrings([
+                    ...parseStringArray(exact.source_event_ids),
+                    ...(obs.sourceEventIds ?? []),
+                ]);
+                const facts = uniqueStrings([...parseStringArray(exact.facts), ...(obs.facts ?? [])]);
+                const concepts = uniqueStrings([
+                    ...parseStringArray(exact.concepts),
+                    ...(obs.concepts ?? []),
+                    obs.semantic.subject,
+                    obs.semantic.predicate,
+                    obs.semantic.value,
+                    ...obs.semantic.entities.map(normalizeEntityKey),
+                ]);
+                const entities = mergeSemanticEntities(parseStringArray(exact.entities), obs.semantic.entities);
+                const narrative = semanticRichness(obs.narrative ?? '') > semanticRichness(exact.narrative)
+                    ? obs.narrative ?? ''
+                    : exact.narrative;
+                const title = semanticRichness(obs.title) > semanticRichness(exact.title) ? obs.title : exact.title;
+                const contentChanged = exact.title !== title
+                    || exact.narrative !== narrative;
+                this.db.prepare(`
+          UPDATE observations
+          SET type = ?, title = ?, narrative = ?, facts = ?, concepts = ?, importance = MAX(importance, ?),
+            confidence = MAX(confidence, ?), source_event_ids = ?, updated_at = ?,
+            access_count = access_count + 1, reinforce_count = reinforce_count + 1, last_reinforced_at = ?,
+            source = CASE WHEN ? = 'explicit_intent' THEN 'explicit_intent' ELSE source END,
+            quality_status = CASE WHEN quality_status = 'quarantined' AND ? = 'accepted' THEN 'accepted' ELSE quality_status END,
+            quarantine_reason = CASE WHEN ? = 'accepted' THEN NULL ELSE quarantine_reason END,
+            resolution_state = 'current', superseded_by_observation = NULL,
+            semantic_subject = ?, semantic_predicate = ?, semantic_value = ?, semantic_polarity = ?,
+            semantic_key = ?, facet_key = ?, dedup_key = ?, entities = ?,
+            temporal = COALESCE(?, temporal), evidence_status = ?, evidence_details = ?,
+            embedding = CASE WHEN ? = 1 THEN NULL ELSE embedding END
+          WHERE id = ?
+        `).run(obs.type, title, narrative, JSON.stringify(facts), JSON.stringify(concepts), obs.importance ?? 5, obs.confidence ?? 0.5, JSON.stringify(sourceEventIds), now, now, obs.source ?? 'distill', obs.qualityStatus ?? 'accepted', obs.qualityStatus ?? 'accepted', obs.semantic.subject, obs.semantic.predicate, obs.semantic.value, obs.semantic.polarity, obs.semantic.semanticKey, obs.semantic.facetKey, obs.semantic.semanticKey, JSON.stringify(entities), obs.semantic.temporal ? JSON.stringify(obs.semantic.temporal) : null, strongerEvidenceStatus(exact.evidence_status, obs.evidenceStatus), JSON.stringify(mergeEvidenceDetails(exact.evidence_details, obs.evidenceDetails ?? [])), contentChanged ? 1 : 0, exact.id);
+                if (contentChanged) {
+                    this.db.prepare("DELETE FROM embeddings WHERE source_type = 'observation' AND source_id = ?").run(exact.id);
+                }
+                this.replaceObservationConcepts(exact.id, concepts);
+                this.replaceObservationEntities(exact.id, project, entities);
+                for (const eventId of obs.sourceEventIds ?? [])
+                    this.linkObservationToEvents(exact.id, [eventId]);
+                const supersededIds = this.supersedeSemanticFacetConflicts(project, exact.id, obs.semantic, now);
+                return { row: this.getObservation(exact.id), action: 'REINFORCE', supersededIds, linkedIds: [] };
+            }
+            const row = this.addObservation(obs);
+            if ((obs.qualityStatus ?? 'accepted') === 'quarantined') {
+                return { row, action: 'HOLD', supersededIds: [], linkedIds: [] };
+            }
+            const supersededIds = this.supersedeSemanticFacetConflicts(project, row.id, obs.semantic, now);
+            const relatedIds = this.findCurrentObservationIdsByEntities(project, obs.semantic.entities, new Set([row.id, ...supersededIds])).slice(0, 12);
+            for (const relatedId of relatedIds) {
+                this.addObservationRelation(row.id, relatedId, 'related_to', now);
+            }
+            return {
+                row: this.getObservation(row.id),
+                action: supersededIds.length > 0 ? 'SUPERSEDE' : relatedIds.length > 0 ? 'LINK' : 'ADD',
+                supersededIds,
+                linkedIds: relatedIds,
+            };
+        })();
+    }
+    findCurrentObservationBySemanticKey(project, semanticKey) {
+        return this.db.prepare(`
+      SELECT * FROM observations
+      WHERE project = ? AND semantic_key = ?
+      ORDER BY CASE WHEN resolution_state = 'current' THEN 0 ELSE 1 END,
+        COALESCE(explicit_accepted_at, timestamp) DESC, id DESC
+      LIMIT 1
+    `).get(project, semanticKey) ?? null;
+    }
+    findCurrentObservationByNarrative(project, narrative) {
+        if (!narrative.trim())
+            return null;
+        return this.db.prepare(`
+      SELECT * FROM observations
+      WHERE project = ? AND narrative = ? AND resolution_state = 'current'
+        AND quality_status = 'accepted'
+      ORDER BY COALESCE(explicit_accepted_at, timestamp) DESC, id DESC
+      LIMIT 1
+    `).get(project, narrative) ?? null;
+    }
+    findCurrentObservationsByFacetKey(project, facetKey) {
+        return this.db.prepare(`
+      SELECT * FROM observations
+      WHERE project = ? AND facet_key = ? AND resolution_state = 'current'
+        AND quality_status = 'accepted'
+      ORDER BY COALESCE(explicit_accepted_at, timestamp) DESC, id DESC
+    `).all(project, facetKey);
+    }
+    searchObservationEntities(project, entities, limit = 30) {
+        const normalized = uniqueStrings(entities.map(normalizeEntityKey)).filter(Boolean);
+        if (normalized.length === 0)
+            return [];
+        const placeholders = normalized.map(() => '?').join(', ');
+        return this.db.prepare(`
+      SELECT o.*, COUNT(DISTINCT oe.normalized_entity) AS entity_match_count
+      FROM observation_entities oe
+      JOIN observations o ON o.id = oe.observation_id
+      WHERE oe.project = ? AND oe.normalized_entity IN (${placeholders})
+        AND o.quality_status = 'accepted' AND o.resolution_state = 'current'
+      GROUP BY o.id
+      ORDER BY entity_match_count DESC, COALESCE(o.explicit_accepted_at, o.timestamp) DESC
+      LIMIT ?
+    `).all(project, ...normalized, limit);
+    }
+    searchDefaultProjectObservationEntities(entities, limit = 30) {
+        return this.searchObservationEntities(this.defaultProjectRoot, entities, limit);
+    }
+    listObservationRelations(observationId) {
+        return this.db.prepare(`
+      SELECT * FROM observation_relations
+      WHERE source_observation_id = ? OR target_observation_id = ?
+      ORDER BY created_at ASC, source_observation_id ASC, target_observation_id ASC
+    `).all(observationId, observationId);
+    }
+    replaceObservationConcepts(observationId, concepts) {
+        this.db.prepare('DELETE FROM observation_concepts WHERE observation_id = ?').run(observationId);
+        const insert = this.db.prepare('INSERT OR IGNORE INTO observation_concepts (observation_id, concept) VALUES (?, ?)');
+        for (const concept of uniqueStrings(concepts))
+            insert.run(observationId, concept);
+    }
+    replaceObservationEntities(observationId, project, entities) {
+        this.db.prepare('DELETE FROM observation_entities WHERE observation_id = ?').run(observationId);
+        const insert = this.db.prepare(`
+      INSERT OR IGNORE INTO observation_entities
+        (observation_id, project, normalized_entity, display_entity)
+      VALUES (?, ?, ?, ?)
+    `);
+        for (const entity of mergeSemanticEntities(entities)) {
+            const normalized = normalizeEntityKey(entity);
+            if (normalized)
+                insert.run(observationId, project, normalized, entity);
+        }
+    }
+    findCurrentObservationIdsByEntities(project, entities, excludedIds) {
+        return this.searchObservationEntities(project, entities, 50)
+            .map(observation => observation.id)
+            .filter(id => !excludedIds.has(id));
+    }
+    addObservationRelation(sourceObservationId, targetObservationId, type, createdAt = Date.now()) {
+        if (sourceObservationId === targetObservationId)
+            return;
+        this.db.prepare(`
+      INSERT OR IGNORE INTO observation_relations
+        (source_observation_id, target_observation_id, type, created_at)
+      VALUES (?, ?, ?, ?)
+    `).run(sourceObservationId, targetObservationId, type, createdAt);
+    }
+    supersedeSemanticFacetConflicts(project, winnerId, semantic, now) {
+        const conflicts = this.findCurrentObservationsByFacetKey(project, semantic.facetKey)
+            .filter(candidate => candidate.id !== winnerId)
+            .filter(candidate => semanticObservationsConflict(candidate, semantic));
+        const supersededIds = [];
+        for (const conflict of conflicts) {
+            this.db.prepare(`
+        UPDATE observations
+        SET resolution_state = 'superseded', superseded_by_observation = ?, dedup_key = NULL, updated_at = ?
+        WHERE id = ? AND resolution_state = 'current'
+      `).run(winnerId, now, conflict.id);
+            this.addObservationRelation(winnerId, conflict.id, 'supersedes', now);
+            supersededIds.push(conflict.id);
+        }
+        return supersededIds;
+    }
     addObservationWithEmbedding(obs, embedding) {
         return this.db.transaction(() => {
             const row = this.addObservation(obs);
@@ -1276,6 +1464,67 @@ export class MemoryStore {
         })();
     }
     acceptExplicitPreference(input) {
+        if (input.enrichment) {
+            this.ensureSession(input.sessionId, input.project);
+            const preferenceAnalysis = analyzePreference(input.content);
+            const hold = preferenceAnalysis.status === 'ambiguous';
+            const baseSemantic = semanticFromExplicitEnrichment(input.enrichment);
+            const semantic = hold
+                ? normalizeSemanticMemory({
+                    project: input.project,
+                    type: input.enrichment.type,
+                    title: input.enrichment.title,
+                    narrative: input.enrichment.narrative,
+                    subject: baseSemantic.subject,
+                    predicate: baseSemantic.predicate,
+                    value: input.content,
+                    polarity: 'neutral',
+                    entities: baseSemantic.entities,
+                    temporal: baseSemantic.temporal ?? undefined,
+                })
+                : baseSemantic;
+            const result = this.acceptSemanticObservation({
+                sessionId: input.sessionId,
+                project: input.project,
+                type: input.enrichment.type,
+                title: input.enrichment.title,
+                narrative: input.enrichment.narrative,
+                facts: input.enrichment.facts,
+                files: input.enrichment.files,
+                tools: input.enrichment.tools,
+                concepts: input.enrichment.concepts,
+                importance: 10,
+                confidence: 0.95,
+                source: 'explicit_intent',
+                sourceEventIds: input.sourceEventId ? [input.sourceEventId] : [],
+                qualityStatus: hold ? 'quarantined' : 'accepted',
+                quarantineReason: hold ? 'ambiguous_explicit_preference' : undefined,
+                evidenceStatus: 'verified',
+                evidenceDetails: [
+                    ...input.enrichment.evidence.map(item => ({ ...item })),
+                    ...(input.enrichment.evidence.length === 0 ? [{
+                            kind: 'source_event',
+                            source: input.sourceEventId ?? `explicit:${input.sessionId}`,
+                            summary: 'Observation was accepted from a direct explicit-memory request.',
+                        }] : []),
+                ],
+                semantic,
+            });
+            const latest = this.db.prepare(`
+        SELECT MAX(COALESCE(explicit_accepted_at, timestamp)) AS latest
+        FROM observations
+        WHERE project = ? AND source = 'explicit_intent'
+      `).get(input.project);
+            const acceptedAt = Math.max(Date.now(), (latest.latest ?? 0) + 1);
+            this.db.prepare(`
+        UPDATE observations
+        SET explicit_accepted_at = MAX(COALESCE(explicit_accepted_at, 0), ?), updated_at = MAX(updated_at, ?)
+        WHERE id = ?
+      `).run(acceptedAt, acceptedAt, result.row.id);
+            if (input.sourceEventId)
+                this.markEventsProcessed([input.sourceEventId]);
+            return this.getObservation(result.row.id);
+        }
         return this.db.transaction(() => {
             this.ensureSession(input.sessionId, input.project);
             const latest = this.db.prepare(`
@@ -1341,7 +1590,7 @@ export class MemoryStore {
             if (current.source !== 'explicit_intent') {
                 throw new Error(`Observation ${observationId} is not an explicit memory`);
             }
-            const dedupKey = observationDedupKey(enrichment.type, enrichment.title);
+            const dedupKey = enrichment.semanticKey;
             const collisions = this.db.prepare(`
         SELECT id, timestamp, explicit_accepted_at FROM observations
         WHERE project = ? AND dedup_key = ? AND id <> ?
@@ -1390,9 +1639,11 @@ export class MemoryStore {
         UPDATE observations
         SET type = ?, title = ?, narrative = ?, facts = ?, files = ?, tools = ?, concepts = ?,
           dedup_key = ?, evidence_status = ?, evidence_details = ?, updated_at = ?,
-          embedding = CASE WHEN ? = 1 THEN NULL ELSE embedding END
+          embedding = CASE WHEN ? = 1 THEN NULL ELSE embedding END,
+          semantic_subject = ?, semantic_predicate = ?, semantic_value = ?, semantic_polarity = ?,
+          semantic_key = ?, facet_key = ?, entities = ?, temporal = ?
         WHERE id = ?
-      `).run(enrichment.type, enrichment.title, enrichment.narrative, nextFacts, nextFiles, nextTools, nextConcepts, dedupKeyForCurrent, enrichment.evidenceStatus, JSON.stringify(enrichment.evidence), now, semanticContentChanged ? 1 : 0, observationId);
+      `).run(enrichment.type, enrichment.title, enrichment.narrative, nextFacts, nextFiles, nextTools, nextConcepts, dedupKeyForCurrent, enrichment.evidenceStatus, JSON.stringify(enrichment.evidence), now, semanticContentChanged ? 1 : 0, enrichment.subject, enrichment.predicate, enrichment.value, enrichment.polarity, enrichment.semanticKey, enrichment.facetKey, JSON.stringify(enrichment.entities), enrichment.temporal ? JSON.stringify(enrichment.temporal) : null, observationId);
             if (semanticContentChanged) {
                 this.db.prepare("DELETE FROM embeddings WHERE source_type = 'observation' AND source_id = ?").run(observationId);
             }
@@ -1400,6 +1651,7 @@ export class MemoryStore {
             const insertConcept = this.db.prepare('INSERT OR IGNORE INTO observation_concepts (observation_id, concept) VALUES (?, ?)');
             for (const concept of enrichment.concepts)
                 insertConcept.run(observationId, concept);
+            this.replaceObservationEntities(observationId, current.project, enrichment.entities);
             this.reconcileExplicitPreferenceConflicts(current.project);
             return this.getObservation(observationId);
         })();
@@ -1971,6 +2223,74 @@ export class MemoryStore {
     }
 }
 // ── Helpers ────────────────────────────────────────────
+function uniqueStrings(values) {
+    const result = [];
+    const seen = new Set();
+    for (const value of values) {
+        const normalized = value.normalize('NFKC').trim();
+        const key = normalized.toLocaleLowerCase('en-US');
+        if (!normalized || seen.has(key))
+            continue;
+        seen.add(key);
+        result.push(normalized);
+    }
+    return result;
+}
+function semanticRichness(value) {
+    const exactIdentifiers = value.match(/@[a-z0-9._-]+\/[a-z0-9._-]+|--[a-z0-9-]+|[a-z0-9]+(?:[-./][a-z0-9]+)+/giu)?.length ?? 0;
+    return [...value.normalize('NFKC').trim()].length + exactIdentifiers * 40;
+}
+function semanticObservationsConflict(existing, incoming) {
+    if (existing.semantic_key === incoming.semanticKey)
+        return false;
+    if (existing.semantic_polarity === 'neutral' || incoming.polarity === 'neutral')
+        return false;
+    const existingValue = normalizeEntityKey(existing.semantic_value);
+    const incomingValue = normalizeEntityKey(incoming.value);
+    if (existingValue === incomingValue)
+        return existing.semantic_polarity !== incoming.polarity;
+    const subject = normalizeEntityKey(incoming.subject);
+    if (new Set(['package manager', 'test runner', 'build tool']).has(subject))
+        return true;
+    if (incoming.predicate === 'version')
+        return true;
+    return ['use', 'prefer', 'require'].includes(incoming.predicate);
+}
+function strongerEvidenceStatus(existing, incoming) {
+    return existing === 'verified' || incoming === 'verified' ? 'verified' : 'unverified';
+}
+function mergeEvidenceDetails(existing, incoming) {
+    let parsed = [];
+    try {
+        const value = JSON.parse(existing);
+        if (Array.isArray(value)) {
+            parsed = value.filter(item => item && typeof item === 'object' && !Array.isArray(item));
+        }
+    }
+    catch { /* malformed historical evidence is replaced by valid evidence */ }
+    const result = [];
+    const seen = new Set();
+    for (const item of [...parsed, ...incoming]) {
+        const key = JSON.stringify(item);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        result.push(item);
+    }
+    return result.slice(0, 64);
+}
+function semanticFromExplicitEnrichment(enrichment) {
+    return {
+        subject: enrichment.subject,
+        predicate: enrichment.predicate,
+        value: enrichment.value,
+        polarity: enrichment.polarity,
+        entities: enrichment.entities,
+        temporal: enrichment.temporal,
+        semanticKey: enrichment.semanticKey,
+        facetKey: enrichment.facetKey,
+    };
+}
 function camelToSnake(str) {
     return str.replace(/[A-Z]/g, letter => `_${letter.toLowerCase()}`);
 }