@dinasor/mnemo-cli 0.0.1

package/scripts/memory/installer/templates/add-journal-entry.ps1

@@ -0,0 +1,122 @@
+<#
+add-journal-entry.ps1
+Adds a journal entry to the current month's journal file.
+Ensures only one heading per date (appends to existing date if present).
+Tags are canonicalized against tag-vocabulary.md.
+BOM-safe file reading.
+
+USAGE:
+  powershell -File .\scripts\memory\add-journal-entry.ps1 -Tags "UI,Fix" -Title "Fixed button alignment"
+  powershell -File .\scripts\memory\add-journal-entry.ps1 -Tags "Build" -Title "Updated dependencies" -Files "package.json"
+#>
+
+[CmdletBinding()]
+param(
+  [Parameter(Mandatory=$true)][string]$Tags,
+  [Parameter(Mandatory=$true)][string]$Title,
+  [string]$Files = "",
+  [string]$Why = "",
+  [string]$Date = (Get-Date -Format "yyyy-MM-dd")
+)
+
+Set-StrictMode -Version Latest
+$ErrorActionPreference = "Stop"
+
+if ($PSScriptRoot) {
+  $RepoRoot = (Resolve-Path (Join-Path $PSScriptRoot "..\..")).Path
+} else {
+  $RepoRoot = (Get-Location).Path
+}
+
+function Resolve-MnemoMemoryDir([string]$Root) {
+  $candidates = @(
+    (Join-Path $Root ".mnemo\memory"),
+    (Join-Path $Root ".cursor\memory")
+  )
+  foreach ($candidate in $candidates) {
+    if (Test-Path -LiteralPath $candidate) { return $candidate }
+  }
+  return $candidates[0]
+}
+
+$MemoryDir = Resolve-MnemoMemoryDir -Root $RepoRoot
+$JournalDir = Join-Path $MemoryDir "journal"
+$TagVocabPath = Join-Path $MemoryDir "tag-vocabulary.md"
+
+if (-not (Test-Path $JournalDir)) { New-Item -ItemType Directory -Force -Path $JournalDir | Out-Null }
+
+function ReadText([string]$p) {
+  $t = Get-Content -Raw -Encoding UTF8 -ErrorAction Stop $p
+  if ($t.Length -gt 0 -and [int]$t[0] -eq 0xFEFF) { $t = $t.Substring(1) }
+  return $t
+}
+
+$canonTags = @{}
+if (Test-Path $TagVocabPath) {
+  $tv = ReadText $TagVocabPath
+  foreach ($m in [regex]::Matches($tv, '(?m)^\-\s+\[([^\]]+)\]')) {
+    $canon = $m.Groups[1].Value.Trim()
+    $canonTags[$canon.ToLower()] = $canon
+  }
+}
+
+$month = $Date.Substring(0, 7)
+$journalFile = Join-Path $JournalDir "$month.md"
+
+$rawTags = $Tags -split ',' | ForEach-Object { $_.Trim() } | Where-Object { $_ -ne "" }
+$finalTags = @()
+foreach ($t in $rawTags) {
+  $k = $t.ToLower()
+  if ($canonTags.Count -gt 0) {
+    if ($canonTags.ContainsKey($k)) { $finalTags += $canonTags[$k] }
+    else { throw "Unknown tag '$t'. Add it to tag-vocabulary.md or fix the tag." }
+  } else {
+    $finalTags += $t
+  }
+}
+$finalTags = $finalTags | Select-Object -Unique
+$tagString = ($finalTags | ForEach-Object { "[$_]" }) -join ""
+
+$entryLines = @()
+$entryLines += "- $tagString $Title"
+if ($Why) { $entryLines += "  - Why: $Why" }
+if ($Files) {
+  $entryLines += "  - Key files:"
+  foreach ($f in ($Files -split ',')) { $entryLines += "    - ``$($f.Trim())``" }
+}
+$entry = $entryLines -join "`r`n"
+
+$enc = New-Object System.Text.UTF8Encoding($false)
+$dateHeading = "## $Date"
+$safeDate = [regex]::Escape($Date)
+
+if (Test-Path $journalFile) {
+  $content = ReadText $journalFile
+  if ($content -match "(?m)^##\s+$safeDate\s*$") {
+    $pattern = "(?ms)(^##\s+$safeDate\s*\r?\n)(.*?)(?=^##\s+\d{4}-\d{2}-\d{2}\s*$|\z)"
+    $rx = New-Object System.Text.RegularExpressions.Regex($pattern, [System.Text.RegularExpressions.RegexOptions]::Multiline)
+    $content = $rx.Replace($content, {
+      param($m)
+      $block = $m.Value.TrimEnd()
+      return $block + "`r`n`r`n" + $entry + "`r`n"
+    }, 1)
+  } else {
+    $content = $content.TrimEnd() + "`r`n`r`n$dateHeading`r`n`r`n$entry`r`n"
+  }
+  [System.IO.File]::WriteAllText($journalFile, ($content -replace "`r?`n", "`r`n"), $enc)
+} else {
+  $projectName = Split-Path -Leaf $RepoRoot
+  $header = @"
+# Development Journal - $projectName ($month)
+
+## $Date
+
+$entry
+"@
+  [System.IO.File]::WriteAllText($journalFile, ($header -replace "`r?`n", "`r`n"), $enc)
+}
+
+Write-Host "Added journal entry to: $journalFile" -ForegroundColor Green
+Write-Host "  Date: $Date" -ForegroundColor Gray
+Write-Host "  Tags: $tagString" -ForegroundColor Gray
+Write-Host "  Title: $Title" -ForegroundColor Gray

package/scripts/memory/installer/templates/add-lesson.ps1

@@ -0,0 +1,151 @@
+<#
+add-lesson.ps1
+Creates a new lesson file with proper ID and YAML frontmatter.
+Automatically assigns the next available lesson ID.
+Tags are canonicalized against tag-vocabulary.md.
+
+USAGE:
+  powershell -File .\scripts\memory\add-lesson.ps1 -Title "Always validate input" -Tags "Reliability,Data" -Rule "Validate all user input before processing"
+#>
+
+[CmdletBinding()]
+param(
+  [Parameter(Mandatory=$true)][string]$Title,
+  [Parameter(Mandatory=$true)][string]$Tags,
+  [Parameter(Mandatory=$true)][string]$Rule,
+  [string]$AppliesTo = "*",
+  [string]$Triggers = ""
+)
+
+Set-StrictMode -Version Latest
+$ErrorActionPreference = "Stop"
+
+if ($PSScriptRoot) {
+  $RepoRoot = (Resolve-Path (Join-Path $PSScriptRoot "..\..")).Path
+} else {
+  $RepoRoot = (Get-Location).Path
+}
+
+function Resolve-MnemoMemoryDir([string]$Root) {
+  $candidates = @(
+    (Join-Path $Root ".mnemo\memory"),
+    (Join-Path $Root ".cursor\memory")
+  )
+  foreach ($candidate in $candidates) {
+    if (Test-Path -LiteralPath $candidate) { return $candidate }
+  }
+  return $candidates[0]
+}
+
+$MemoryDir = Resolve-MnemoMemoryDir -Root $RepoRoot
+$LessonsDir = Join-Path $MemoryDir "lessons"
+$TagVocabPath = Join-Path $MemoryDir "tag-vocabulary.md"
+
+if (-not (Test-Path $LessonsDir)) { New-Item -ItemType Directory -Force -Path $LessonsDir | Out-Null }
+
+function ReadText([string]$p) {
+  $t = Get-Content -Raw -Encoding UTF8 -ErrorAction Stop $p
+  if ($t.Length -gt 0 -and [int]$t[0] -eq 0xFEFF) { $t = $t.Substring(1) }
+  return $t
+}
+
+$canonTags = @{}
+if (Test-Path $TagVocabPath) {
+  $tv = ReadText $TagVocabPath
+  foreach ($m in [regex]::Matches($tv, '(?m)^\-\s+\[([^\]]+)\]')) {
+    $canon = $m.Groups[1].Value.Trim()
+    $canonTags[$canon.ToLower()] = $canon
+  }
+}
+
+$existingLessons = Get-ChildItem -Path $LessonsDir -Filter "L-*.md" -ErrorAction SilentlyContinue
+$maxId = 0
+foreach ($lf in $existingLessons) {
+  if ($lf.Name -match '^L-(\d{3})') {
+    $id = [int]$Matches[1]
+    if ($id -gt $maxId) { $maxId = $id }
+  }
+}
+
+$lessonId = "L-{0:D3}" -f ($maxId + 1)
+
+$kebabTitle = ($Title.ToLower() -replace '[^a-z0-9]+', '-' -replace '^-|-$', '')
+if ([string]::IsNullOrWhiteSpace($kebabTitle)) { $kebabTitle = "lesson" }
+if ($kebabTitle.Length -gt 50) { $kebabTitle = $kebabTitle.Substring(0, 50) }
+$fileName = "$lessonId-$kebabTitle.md"
+$filePath = Join-Path $LessonsDir $fileName
+
+$rawTags = $Tags -split ',' | ForEach-Object { $_.Trim() } | Where-Object { $_ -ne "" }
+$finalTags = @()
+foreach ($t in $rawTags) {
+  $k = $t.ToLower()
+  if ($canonTags.Count -gt 0) {
+    if ($canonTags.ContainsKey($k)) { $finalTags += $canonTags[$k] }
+    else { throw "Unknown tag '$t'. Add it to tag-vocabulary.md or fix the tag." }
+  } else {
+    $finalTags += $t
+  }
+}
+$finalTags = $finalTags | Select-Object -Unique
+$tagsYaml = "[$($finalTags -join ', ')]"
+
+$appliesLines = @()
+foreach ($a in ($AppliesTo -split ',')) { $appliesLines += "  - $($a.Trim())" }
+$appliesYaml = $appliesLines -join "`r`n"
+
+if ($Triggers) {
+  $triggerLines = @()
+  foreach ($t in ($Triggers -split ',')) { $triggerLines += "  - $($t.Trim())" }
+  $triggersYaml = "triggers:`r`n" + ($triggerLines -join "`r`n")
+} else {
+  $triggersYaml = "triggers:`r`n  - TODO: add error messages or keywords"
+}
+
+$today = Get-Date -Format "yyyy-MM-dd"
+
+$content = @"
+---
+id: $lessonId
+title: $Title
+status: Active
+tags: $tagsYaml
+introduced: $today
+applies_to:
+$appliesYaml
+$triggersYaml
+rule: $Rule
+---
+
+# $lessonId - $Title
+
+## Symptom
+
+TODO: Describe what happened
+
+## Root Cause
+
+TODO: Describe why it happened
+
+## Wrong Approach (DO NOT REPEAT)
+
+- TODO: What not to do
+
+## Correct Approach
+
+- TODO: What to do instead
+
+## References
+
+- Files: ``TODO``
+- Journal: ``journal/$($today.Substring(0,7)).md#$today``
+"@
+
+$enc = New-Object System.Text.UTF8Encoding($false)
+[System.IO.File]::WriteAllText($filePath, ($content -replace "`r?`n", "`r`n"), $enc)
+
+Write-Host "Created lesson: $filePath" -ForegroundColor Green
+Write-Host "  ID: $lessonId" -ForegroundColor Gray
+Write-Host "  Title: $Title" -ForegroundColor Gray
+Write-Host "  Tags: $tagsYaml" -ForegroundColor Gray
+Write-Host ""
+Write-Host "Next: run scripts\memory\rebuild-memory-index.ps1" -ForegroundColor Cyan

package/scripts/memory/installer/templates/autonomy/__init__.py

@@ -0,0 +1,6 @@
+"""
+Mnemo Autonomous Memory Runtime.
+Provides no-human-in-the-loop memory ingestion, lifecycle governance,
+retrieval routing, safety filtering, and quality monitoring.
+"""
+__version__ = "1.0.0"

package/scripts/memory/installer/templates/autonomy/context_safety.py

@@ -0,0 +1,181 @@
+#!/usr/bin/env python3
+"""
+context_safety.py - Context safety guard for Mnemo retrieval packs.
+
+Runs automatically on every retrieval/context-pack build.
+Checks:
+  1. Duplicate snippet detection (prevents redundant context)
+  2. Contradiction detection (alerts on conflicting facts)
+  3. Low-signal suppression (filters empty/trivial content)
+  4. Token budget enforcement (hard cap on total context chars)
+  5. Sensitivity redaction (vault/secret entries stripped before delivery)
+
+No human required: all checks are policy-driven.
+"""
+import re
+import sqlite3
+from dataclasses import dataclass, field
+from typing import Optional
+
+from autonomy.schema import get_db
+from autonomy.reranker import RankedResult
+
+DEFAULT_TOKEN_BUDGET = 6000  # chars (~1500 tokens)
+MIN_CONTENT_CHARS = 20       # snippets shorter than this are suppressed
+DUPLICATE_JACCARD_THRESHOLD = 0.85  # above = duplicate
+CONTRADICTION_KEYWORD_PAIRS = [
+    ("do not", "always"),
+    ("never", "must"),
+    ("disabled", "enabled"),
+    ("false", "true"),
+    ("forbidden", "required"),
+]
+
+
+@dataclass
+class SafetyCheckResult:
+    passed: bool
+    issues: list[str] = field(default_factory=list)
+    filtered_results: list[RankedResult] = field(default_factory=list)
+    token_budget_used: int = 0
+    token_budget_max: int = DEFAULT_TOKEN_BUDGET
+
+    def summary(self) -> str:
+        s = f"safety={'PASS' if self.passed else 'ISSUES'} used={self.token_budget_used}/{self.token_budget_max}"
+        if self.issues:
+            s += f" issues={len(self.issues)}"
+        return s
+
+
+def _jaccard(a: str, b: str) -> float:
+    ta = set(re.findall(r"\w+", a.lower()))
+    tb = set(re.findall(r"\w+", b.lower()))
+    if not ta or not tb:
+        return 0.0
+    return len(ta & tb) / len(ta | tb)
+
+
+def _detect_duplicates(results: list[RankedResult]) -> list[tuple[int, int]]:
+    """Return (i, j) pairs where results[i] and results[j] are near-duplicates."""
+    pairs: list[tuple[int, int]] = []
+    for i in range(len(results)):
+        for j in range(i + 1, len(results)):
+            if _jaccard(results[i].content, results[j].content) >= DUPLICATE_JACCARD_THRESHOLD:
+                pairs.append((i, j))
+    return pairs
+
+
+def _detect_contradictions(results: list[RankedResult]) -> list[tuple[int, int, str]]:
+    """Return (i, j, reason) triples indicating contradicting result pairs."""
+    contradictions: list[tuple[int, int, str]] = []
+    for i in range(len(results)):
+        for j in range(i + 1, len(results)):
+            a = results[i].content.lower()
+            b = results[j].content.lower()
+            for neg, pos in CONTRADICTION_KEYWORD_PAIRS:
+                if neg in a and pos in b:
+                    contradictions.append((i, j, f"'{neg}' vs '{pos}'"))
+                    break
+                if pos in a and neg in b:
+                    contradictions.append((i, j, f"'{pos}' vs '{neg}'"))
+                    break
+    return contradictions
+
+
+class ContextSafetyGuard:
+    def __init__(
+        self,
+        token_budget: int = DEFAULT_TOKEN_BUDGET,
+        db: Optional[sqlite3.Connection] = None,
+    ):
+        self.token_budget = token_budget
+        self.db = db or get_db()
+
+    def check(self, results: list[RankedResult]) -> SafetyCheckResult:
+        """
+        Run all safety checks on results, return SafetyCheckResult.
+        Modifies results list by removing failing entries.
+        """
+        issues: list[str] = []
+        filtered: list[RankedResult] = []
+
+        # 1. Sensitivity redaction (vault/secret always stripped first)
+        for r in results:
+            if r.memory_type == "vault":
+                issues.append(f"REDACTED vault entry: {r.ref_path}")
+                continue
+            # Check DB sensitivity flag
+            row = self.db.execute(
+                "SELECT sensitivity FROM memory_units WHERE source_ref = ?",
+                (r.source_file,),
+            ).fetchone()
+            if row and row["sensitivity"] == "secret":
+                issues.append(f"REDACTED secret entry: {r.ref_path}")
+                continue
+            filtered.append(r)
+
+        # 2. Low-signal suppression
+        filtered = [r for r in filtered if len(r.content.strip()) >= MIN_CONTENT_CHARS]
+        suppressed = len(results) - len(filtered)
+        if suppressed > 0:
+            issues.append(f"Suppressed {suppressed} low-signal entries (<{MIN_CONTENT_CHARS} chars)")
+
+        # 3. Duplicate detection (remove lower-scored duplicate)
+        dup_pairs = _detect_duplicates(filtered)
+        to_remove: set[int] = set()
+        for i, j in dup_pairs:
+            # Keep higher-scored result
+            remove_idx = j if filtered[i].final_score >= filtered[j].final_score else i
+            to_remove.add(remove_idx)
+            issues.append(f"Duplicate pair removed: {filtered[remove_idx].ref_path}")
+        filtered = [r for idx, r in enumerate(filtered) if idx not in to_remove]
+
+        # 4. Contradiction detection (warn but keep both, lower confidence)
+        contradictions = _detect_contradictions(filtered)
+        for i, j, reason in contradictions:
+            issues.append(
+                f"Contradiction detected ({reason}): {filtered[i].ref_path} vs {filtered[j].ref_path}"
+            )
+            # Reduce score of both to signal uncertainty
+            object.__setattr__(filtered[i], "final_score", filtered[i].final_score * 0.9)
+            object.__setattr__(filtered[j], "final_score", filtered[j].final_score * 0.9)
+
+        # 5. Token budget enforcement
+        budget_used = 0
+        final: list[RankedResult] = []
+        for r in sorted(filtered, key=lambda x: x.final_score, reverse=True):
+            chars = len(r.content)
+            if budget_used + chars > self.token_budget:
+                issues.append(f"Token budget exceeded; truncated at {budget_used} chars")
+                break
+            final.append(r)
+            budget_used += chars
+
+        passed = not any("REDACTED secret" in i or "REDACTED vault" in i for i in issues)
+        return SafetyCheckResult(
+            passed=passed,
+            issues=issues,
+            filtered_results=final,
+            token_budget_used=budget_used,
+            token_budget_max=self.token_budget,
+        )
+
+    def build_context_pack(self, results: list[RankedResult]) -> str:
+        """
+        Build a formatted context pack string from safety-checked results.
+        Safe to pass directly to LLM context.
+        """
+        check = self.check(results)
+        lines: list[str] = []
+
+        if not check.passed:
+            sensitive_warnings = [i for i in check.issues if "REDACTED" in i]
+            if sensitive_warnings:
+                lines.append(f"[Safety] {'; '.join(sensitive_warnings)}")
+
+        for r in check.filtered_results:
+            lines.append(f"<!-- {r.ref_path} | score={r.final_score:.3f} type={r.memory_type} -->")
+            lines.append(r.content.strip())
+            lines.append("")
+
+        return "\n".join(lines).strip()

package/scripts/memory/installer/templates/autonomy/entity_resolver.py

@@ -0,0 +1,215 @@
+#!/usr/bin/env python3
+"""
+entity_resolver.py - Stable entity IDs and alias resolution.
+
+Extracts named entities from memory units (paths, modules, concepts),
+assigns stable UUIDs, maintains alias mappings with confidence scores,
+and propagates entity_tags back to memory_units.
+
+No human required: alias merging is automatic with confidence thresholds.
+"""
+import json
+import re
+import sqlite3
+import uuid
+from dataclasses import dataclass
+from typing import Optional
+
+from autonomy.schema import get_db
+from autonomy.ingest_pipeline import MemoryUnit
+
+ALIAS_MERGE_THRESHOLD = 0.85  # confidence required to merge aliases
+ENTITY_CONFIDENCE_DECAY = 0.02  # decay per cycle without reinforcement
+
+
+@dataclass
+class Entity:
+    entity_id: str
+    entity_name: str
+    entity_type: str
+    confidence: float
+
+
+def _extract_entities_from_text(content: str, source_ref: str) -> list[tuple[str, str]]:
+    """
+    Heuristic entity extraction from markdown content.
+    Returns list of (entity_name, entity_type) tuples.
+    """
+    entities: list[tuple[str, str]] = []
+
+    # File/path references (e.g., `path/to/file.py`)
+    for m in re.finditer(r"`([^`]+\.[a-z]{1,10})`", content):
+        p = m.group(1)
+        if "/" in p or "\\" in p:
+            entities.append((p, "file"))
+
+    # Module/class names (CamelCase words used multiple times)
+    camel_matches = re.findall(r"\b([A-Z][a-zA-Z]{3,}(?:[A-Z][a-z]+)+)\b", content)
+    freq: dict[str, int] = {}
+    for name in camel_matches:
+        freq[name] = freq.get(name, 0) + 1
+    for name, count in freq.items():
+        if count >= 2:
+            entities.append((name, "class"))
+
+    # Lesson references (L-XXX)
+    for m in re.finditer(r"\bL-(\d{3})\b", content):
+        entities.append((f"L-{m.group(1)}", "lesson"))
+
+    # Function/method references (snake_case in backticks)
+    for m in re.finditer(r"`([a-z][a-z0-9_]{3,})\(\)`", content):
+        entities.append((m.group(1), "function"))
+
+    return list(set(entities))[:30]  # deduplicate + cap
+
+
+class EntityResolver:
+    def __init__(self, db: Optional[sqlite3.Connection] = None):
+        self.db = db or get_db()
+
+    def resolve(self, unit: MemoryUnit) -> list[str]:
+        """
+        Extract entities from unit content, resolve/create IDs, update unit.
+        Returns list of entity_ids assigned to this unit.
+        """
+        raw_entities = _extract_entities_from_text(unit.content, unit.source_ref)
+        entity_ids: list[str] = []
+
+        for entity_name, entity_type in raw_entities:
+            eid = self._get_or_create(entity_name, entity_type)
+            if eid:
+                entity_ids.append(eid)
+
+        if entity_ids:
+            self.db.execute(
+                "UPDATE memory_units SET entity_tags=?, updated_at=unixepoch('now') WHERE unit_id=?",
+                (json.dumps(entity_ids), unit.unit_id),
+            )
+            self.db.commit()
+            unit.entity_tags = entity_ids
+
+        return entity_ids
+
+    def _get_or_create(self, entity_name: str, entity_type: str) -> Optional[str]:
+        """Resolve entity by exact match or alias, or create new."""
+        # Check exact entity name
+        row = self.db.execute(
+            "SELECT entity_id FROM entities WHERE entity_name = ?", (entity_name,)
+        ).fetchone()
+        if row:
+            self._reinforce(row["entity_id"])
+            return row["entity_id"]
+
+        # Check aliases
+        alias_row = self.db.execute(
+            "SELECT entity_id FROM entity_aliases WHERE alias_text = ?", (entity_name,)
+        ).fetchone()
+        if alias_row:
+            self._reinforce(alias_row["entity_id"])
+            return alias_row["entity_id"]
+
+        # Try fuzzy alias match
+        similar_id = self._find_similar_entity(entity_name)
+        if similar_id:
+            # Add as alias
+            try:
+                self.db.execute(
+                    "INSERT INTO entity_aliases(alias_id, entity_id, alias_text, confidence) VALUES (?,?,?,?)",
+                    (str(uuid.uuid4()), similar_id, entity_name, ALIAS_MERGE_THRESHOLD),
+                )
+                self.db.commit()
+                self._reinforce(similar_id)
+                return similar_id
+            except sqlite3.IntegrityError:
+                return similar_id
+
+        # Create new entity
+        entity_id = str(uuid.uuid4())
+        try:
+            self.db.execute(
+                "INSERT INTO entities(entity_id, entity_name, entity_type, confidence) VALUES (?,?,?,1.0)",
+                (entity_id, entity_name, entity_type),
+            )
+            self.db.commit()
+        except sqlite3.IntegrityError:
+            # Race condition: entity was created concurrently
+            row = self.db.execute(
+                "SELECT entity_id FROM entities WHERE entity_name = ?", (entity_name,)
+            ).fetchone()
+            return row["entity_id"] if row else None
+        return entity_id
+
+    def _find_similar_entity(self, name: str) -> Optional[str]:
+        """
+        Find an entity whose name is highly similar (token Jaccard).
+        Returns entity_id if confidence >= threshold, else None.
+        """
+        candidates = self.db.execute(
+            "SELECT entity_id, entity_name FROM entities"
+        ).fetchall()
+
+        name_tokens = set(re.findall(r"\w+", name.lower()))
+        best_id = None
+        best_score = 0.0
+
+        for row in candidates:
+            cand_tokens = set(re.findall(r"\w+", row["entity_name"].lower()))
+            if not name_tokens or not cand_tokens:
+                continue
+            score = len(name_tokens & cand_tokens) / len(name_tokens | cand_tokens)
+            if score > best_score:
+                best_score = score
+                best_id = row["entity_id"]
+
+        return best_id if best_score >= ALIAS_MERGE_THRESHOLD else None
+
+    def _reinforce(self, entity_id: str) -> None:
+        """Increase confidence for an entity (re-observed)."""
+        self.db.execute(
+            "UPDATE entities SET confidence=MIN(confidence+0.01, 1.0) WHERE entity_id=?",
+            (entity_id,),
+        )
+
+    def decay_stale_entities(self, min_confidence: float = 0.2) -> int:
+        """
+        Decay confidence of entities not reinforced recently.
+        Quarantine entities below min_confidence.
+        Returns number of quarantined entities.
+        """
+        self.db.execute(
+            """
+            UPDATE entities SET confidence = MAX(confidence - ?, 0.0)
+            WHERE entity_id NOT IN (
+                SELECT DISTINCT json_each.value
+                FROM memory_units, json_each(memory_units.entity_tags)
+            )
+            """,
+            (ENTITY_CONFIDENCE_DECAY,),
+        )
+        quarantined = self.db.execute(
+            "SELECT COUNT(*) FROM entities WHERE confidence < ?", (min_confidence,)
+        ).fetchone()[0]
+        self.db.commit()
+        return quarantined
+
+    def get_entity_by_alias(self, alias: str) -> Optional[Entity]:
+        """Resolve any alias or name to canonical Entity."""
+        # Direct name match
+        row = self.db.execute(
+            "SELECT entity_id, entity_name, entity_type, confidence FROM entities WHERE entity_name = ?",
+            (alias,),
+        ).fetchone()
+        if row:
+            return Entity(**dict(row))
+        # Alias lookup
+        alias_row = self.db.execute(
+            """
+            SELECT e.entity_id, e.entity_name, e.entity_type, e.confidence
+            FROM entity_aliases ea JOIN entities e ON ea.entity_id = e.entity_id
+            WHERE ea.alias_text = ?
+            """,
+            (alias,),
+        ).fetchone()
+        if alias_row:
+            return Entity(**dict(alias_row))
+        return None