memtide 0.1.0__py3-none-any.whl

memtide/__init__.py

@@ -0,0 +1,29 @@
+"""Memtide — a stdlib-core agent memory engine.
+
+Atomic, auditable, forgetting-aware memory for LLM agents:
+- Mem0-style atomic-fact extraction & write-time consolidation
+- Letta-style core memory block you inject into the system prompt
+- Zep-style temporal audit (nothing is silently lost; updates/invalidations tracked)
+- Hybrid retrieval: vector + BM25 full-text + entity + Ebbinghaus retention, RRF-fused
+
+Production-ready agent memory with PostgreSQL, Qdrant, and any
+OpenAI-compatible LLM/embedding endpoints.
+"""
+
+from .config import MemoryConfig
+from .engine import MemoryEngine
+from .types import AddResult, Event, ExtractedFact, Memory, MemoryType, SearchResult
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "MemoryEngine",
+    "MemoryConfig",
+    "Memory",
+    "MemoryType",
+    "Event",
+    "AddResult",
+    "ExtractedFact",
+    "SearchResult",
+    "__version__",
+]

memtide/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

memtide/cli.py

@@ -0,0 +1,96 @@
+"""memtide CLI — manage the memory store from the shell (env-configured).
+
+    python -m memtide add "我叫李雷，住在杭州"           # write memories
+    python -m memtide search "用户住哪"                  # hybrid retrieval
+    python -m memtide list                               # dump all memories
+    python -m memtide context "用户喜欢什么咖啡"          # render core block
+    python -m memtide history                            # audit log
+    python -m memtide stats
+    python -m memtide delete <memory_id>                 # soft-delete one memory
+    python -m memtide serve --port 8300                  # start the REST API server
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+
+from .config import MemoryConfig
+from .engine import MemoryEngine
+
+
+def _engine(args) -> MemoryEngine:
+    from .config import config_from_env
+
+    return MemoryEngine(config_from_env())
+
+
+def main(argv=None) -> int:
+    p = argparse.ArgumentParser(prog="memtide", description=__doc__,
+                                formatter_class=argparse.RawDescriptionHelpFormatter)
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    sp = sub.add_parser("add", help="store memories from a conversation string")
+    sp.add_argument("text")
+    sp.add_argument("--user", default="default")
+
+    sp = sub.add_parser("search", help="hybrid retrieval")
+    sp.add_argument("query")
+    sp.add_argument("--user", default="default")
+    sp.add_argument("-k", type=int, default=5)
+
+    sp = sub.add_parser("list", help="dump valid memories")
+    sp.add_argument("--user", default="default")
+
+    sp = sub.add_parser("context", help="render core memory block")
+    sp.add_argument("query", nargs="?", default=None)
+    sp.add_argument("--user", default="default")
+
+    sub.add_parser("history", help="audit log")
+    sub.add_parser("stats")
+
+    sp = sub.add_parser("delete", help="soft-delete one memory")
+    sp.add_argument("memory_id")
+
+    sp = sub.add_parser("serve", help="start the REST API server")
+    sp.add_argument("--host", default="127.0.0.1")
+    sp.add_argument("--port", type=int, default=8300)
+
+    args = p.parse_args(argv)
+    engine = _engine(args)
+
+    try:
+        if args.cmd == "serve":
+            engine.close()
+            from .server import serve_forever
+
+            serve_forever(host=args.host, port=args.port)
+            return 0
+        if args.cmd == "add":
+            res = engine.add(args.text, user_id=args.user)
+            print(json.dumps(res.to_dict(), ensure_ascii=False, indent=2))
+        elif args.cmd == "search":
+            hits = engine.search(args.query, user_id=args.user, limit=args.k)
+            for h in hits:
+                print(json.dumps(h.to_dict(), ensure_ascii=False))
+        elif args.cmd == "list":
+            for m in engine.get_all(args.user):
+                print(json.dumps(m.to_dict(), ensure_ascii=False))
+        elif args.cmd == "context":
+            print(engine.render_context(user_id=args.user, query=args.query))
+        elif args.cmd == "history":
+            for h in engine.get_history(limit=50):
+                print(json.dumps(h, ensure_ascii=False))
+        elif args.cmd == "stats":
+            print(json.dumps(engine.stats(), ensure_ascii=False, indent=2))
+        elif args.cmd == "delete":
+            ok = engine.delete(args.memory_id)
+            print("deleted" if ok else "not found")
+    finally:
+        engine.close()
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

memtide/config.py

@@ -0,0 +1,192 @@
+"""Configuration for a MemoryEngine instance."""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass
+class MemoryConfig:
+    # --- storage (PostgreSQL only) ----------------------------------------
+    storage_backend: str = "postgres"
+    pg_dsn: str = ""                     # e.g. postgresql://memtide:pw@localhost:5432/memtide
+    embedding_dim: int = 256             # probe hint only; the live dim comes from embedder.dim, never written back
+
+    # --- vector store (Qdrant only) -----------------------------------------
+    vector_backend: str = "qdrant"
+    qdrant_url: str = "http://localhost:6333"
+    qdrant_collection: str = "memtide"
+
+    # --- predictive-coding gate (gating.py) ---------------------------------
+    # The memory corpus is the prior; only prediction error is encoded.
+    gate_enabled: bool = True
+    gate_redundant_bits: float = 0.5    # surprise <= this -> REJECT (fully predicted)
+    gate_novel_bits: float = 2.5        # surprise >= this -> NOVEL (importance boost)
+    gate_importance_boost: float = 0.10
+    gate_slot_floor: float = 0.40       # min cosine to treat same-slot memory as predictor
+    # slot-scoped prior: for slotted facts (location/role/...), surprise is
+    # computed against SAME-slot memories only — "user lives in X" is not
+    # predicted by "user works at Y" just because the phrasing matches
+    gate_slot_scoped: bool = True
+
+    # --- write path -------------------------------------------------------
+    max_facts_per_turn: int = 12         # cap extraction output
+    dedup_threshold: float = 0.94        # cosine >= this => duplicate (NOOP/UPDATE)
+    conflict_threshold: float = 0.55     # cosine >= this + conflict signals => UPDATE
+    similarity_candidates: int = 5       # existing memories compared per new fact
+
+    # --- retrieval (hybrid fusion) ----------------------------------------
+    semantic_topk: int = 40              # Qdrant vector candidates
+    bm25_topk: int = 40                  # PostgreSQL pg_search BM25 candidates
+    rrf_k: int = 60                      # reciprocal-rank-fusion constant
+    # per-channel RRF weights: the loose entity channel counts less than the
+    # two main channels; expanded query variants count less than the original
+    entity_channel_weight: float = 0.5
+    expansion_variant_weight: float = 0.5
+    weights: dict = field(default_factory=lambda: {
+        "rrf": 1.0,
+        "semantic": 0.15,   # raw cosine bonus on top of RRF
+        "bm25": 0.05,       # exact keyword-hit bonus (hit = 1.0 else 0.0)
+        "entity": 0.03,     # entity-hit bonus (hit = 1.0 else 0.0)
+        "recency": 0.10,    # retention (Ebbinghaus) bonus
+        "importance": 0.05,
+    })
+    final_topk: int = 10
+    # post-fusion filters (search(memory_type=, slot=))
+    # MMR diversity: 0 = off; e.g. 0.7 blends score and dissimilarity
+    mmr_lambda: float = 0.0
+    # optional cross-encoder re-ranking of the fused top-N ("none" | "http";
+    # http = Jina/Cohere-style POST {rerank_base_url}/rerank)
+    rerank_backend: str = "none"
+    rerank_base_url: str = ""
+    rerank_model: str = ""
+    rerank_api_key: Optional[str] = None
+    rerank_topk: int = 20
+    # LLM query expansion (real-LLM deployments only): retrieve for the query
+    # plus an English translation + a paraphrase, fuse all rankings
+    query_expansion: bool = False
+
+    # --- forgetting / reinforcement ----------------------------------------
+    half_life_days: float = 45.0         # base Ebbinghaus half-life
+    reinforcement_gain: float = 0.4      # each access slows decay: hl *= 1+g*ln(1+n)
+    retention_floor: float = 0.02        # below this a memory is "forgotten" (hidden)
+    max_half_life_mult: float = 4.0      # cap on the reinforcement stretch
+    # episodic memories fade faster and are forgotten sooner than facts
+    episodic_half_life_mult: float = 0.5
+    episodic_floor: float = 0.05
+
+    # --- background consolidation (consolidation.py) --------------------------
+    consolidation_min_cluster: int = 3   # smallest cluster worth distilling
+    consolidation_similarity: float = 0.45   # real embeddings: same-topic ~0.55, cross-topic ~0.28
+    # abstractions forget slower than episodes (effective half-life multiplier
+    # for memories with source="consolidation")
+    consolidation_half_life_mult: float = 3.0
+
+    # --- core memory (Letta-style always-injected block) ---------------------
+    core_max_chars: int = 1200
+
+    # --- backends ------------------------------------------------------------
+    # llm: any OpenAI-compatible endpoint (API key required)
+    llm_backend: str = "openai"
+    llm_base_url: str = "https://api.openai.com/v1"
+    embedding_base_url: str = ""         # empty -> llm_base_url
+    llm_model: str = "gpt-4o-mini"
+    llm_api_key: Optional[str] = None
+    # embedding: "auto" tries dashscope -> openai (by available keys)
+    embedding_backend: str = "auto"      # auto|openai|dashscope
+    embedding_model: str = "text-embedding-3-small"
+    dashscope_api_key: Optional[str] = None
+    dashscope_base_url: str = "https://dashscope.aliyuncs.com/compatible-mode/v1"
+    dashscope_embedding_model: str = "qwen3.7-text-embedding"
+
+    # --- multimodal (multimodal.py) ----------------------------------------
+    # Media parts are described to text (vision model / optional STT) and the
+    # original bytes are stored content-addressed under media_dir.
+    multimodal_enabled: bool = True
+    media_dir: str = "memtide_media"          # content-addressed asset store
+    max_media_bytes: int = 10 * 1024 * 1024
+    # SECURITY: reading media from local paths is disabled by default — a REST
+    # deployment would otherwise let any caller read arbitrary local files
+    # ({"path": "/etc/passwd"} -> GET /media/<sha>). Enable only for trusted
+    # embedders (CLI / in-process agents).
+    media_allow_paths: bool = False
+    # vision: empty base_url/model -> fall back to the main LLM endpoint
+    # (works with any OpenAI-compatible vision model, e.g. qwen-vl-max)
+    vision_base_url: str = ""
+    vision_model: str = ""
+    vision_api_key: Optional[str] = None
+    # speech-to-text: empty stt_model disables transcription (audio kept as
+    # reference-only attachments)
+    stt_base_url: str = ""
+    stt_model: str = ""
+
+    # --- slot normalisation (slots.py) --------------------------------------
+    # Open-hint slots: canonicalise aliases (city/住址 -> location) so the
+    # same meaning with different names still matches. Extra user aliases
+    # merge over the built-in table.
+    slot_aliases: dict = field(default_factory=dict)
+
+    # --- service / ops -------------------------------------------------------
+    api_key: Optional[str] = None        # when set, REST requires it (X-API-Key)
+    auto_reflect_seconds: int = 0        # >0: run consolidate_background periodically
+
+    def resolve_api_key(self) -> Optional[str]:
+        if self.llm_api_key:
+            return self.llm_api_key
+        return os.environ.get("OPENAI_API_KEY") or os.environ.get("LLM_API_KEY")
+
+    def resolve_dashscope_key(self) -> Optional[str]:
+        if self.dashscope_api_key:
+            return self.dashscope_api_key
+        return os.environ.get("DASHSCOPE_API_KEY")
+
+
+def config_from_env() -> "MemoryConfig":
+    """Build a config from MEMTIDE_* / LLM_* / EMBEDDING_* / DASHSCOPE_* env
+    variables (used by the REST server and Docker deployment)."""
+    cfg = MemoryConfig(
+        storage_backend=(os.environ.get("MEMTIDE_STORAGE") or "postgres"),
+        pg_dsn=(os.environ.get("MEMTIDE_PG_DSN") or ""),
+        vector_backend=(os.environ.get("MEMTIDE_VECTOR_BACKEND") or "qdrant"),
+        qdrant_url=(os.environ.get("MEMTIDE_QDRANT_URL") or "http://localhost:6333"),
+        qdrant_collection=(os.environ.get("MEMTIDE_QDRANT_COLLECTION") or "memtide"),
+        llm_backend=(os.environ.get("LLM_BACKEND") or "openai"),
+        llm_base_url=(os.environ.get("LLM_BASE_URL") or "https://api.openai.com/v1"),
+        llm_model=(os.environ.get("LLM_MODEL") or "gpt-4o-mini"),
+        embedding_backend=(os.environ.get("EMBEDDING_BACKEND") or "auto"),
+        embedding_model=(os.environ.get("EMBEDDING_MODEL") or "text-embedding-3-small"),
+        dashscope_embedding_model=(os.environ.get("DASHSCOPE_EMBEDDING_MODEL")
+                                   or "qwen3.7-text-embedding"),
+        dashscope_base_url=os.environ.get(
+            "DASHSCOPE_BASE_URL",
+            "https://dashscope.aliyuncs.com/compatible-mode/v1"),
+        multimodal_enabled=(os.environ.get("MEMTIDE_MULTIMODAL") or "1") not in ("0", "false", "no"),
+        media_dir=(os.environ.get("MEMTIDE_MEDIA_DIR") or "memtide_media"),
+        media_allow_paths=(os.environ.get("MEMTIDE_MEDIA_ALLOW_PATHS") or "0") in ("1", "true", "yes"),
+        vision_base_url=(os.environ.get("MEMTIDE_VISION_BASE_URL") or ""),
+        vision_model=(os.environ.get("MEMTIDE_VISION_MODEL") or ""),
+        stt_base_url=(os.environ.get("MEMTIDE_STT_BASE_URL") or ""),
+        stt_model=(os.environ.get("MEMTIDE_STT_MODEL") or ""),
+    )
+    if cfg.storage_backend != "postgres":
+        raise ValueError("MEMTIDE_STORAGE 必须为 postgres；PostgreSQL 是唯一存储后端")
+    if not cfg.pg_dsn:
+        raise ValueError("请设置 MEMTIDE_PG_DSN（例如 postgresql://user:password@host:5432/db）")
+    if cfg.vector_backend != "qdrant":
+        raise ValueError("MEMTIDE_VECTOR_BACKEND 必须为 qdrant；Qdrant 是唯一向量后端")
+    if os.environ.get("LLM_API_KEY"):
+        cfg.llm_api_key = os.environ["LLM_API_KEY"]
+    if os.environ.get("DASHSCOPE_API_KEY"):
+        cfg.dashscope_api_key = os.environ["DASHSCOPE_API_KEY"]
+    if os.environ.get("MEMTIDE_VISION_API_KEY"):
+        cfg.vision_api_key = os.environ["MEMTIDE_VISION_API_KEY"]
+    if os.environ.get("MEMTIDE_API_KEY"):
+        cfg.api_key = os.environ["MEMTIDE_API_KEY"]
+    if os.environ.get("MEMTIDE_AUTO_REFLECT"):
+        try:
+            cfg.auto_reflect_seconds = max(60, int(os.environ["MEMTIDE_AUTO_REFLECT"]))
+        except ValueError:
+            pass
+    return cfg

memtide/consolidation.py

@@ -0,0 +1,134 @@
+"""Background consolidation (LangMem-style reflection).
+
+A periodic pass over the memory bank that does higher-level updating no
+single write can do:
+
+1. CLUSTER   greedy density clustering: a memory plus every memory within
+             cosine ``threshold`` of it forms a same-topic cluster (only
+             clusters with >= ``min_cluster`` members count; already-
+             consolidated summaries are excluded to keep one abstraction level
+             per pass).
+2. SUMMARIZE members are distilled into one summary memory (LLM when
+             configured, deterministic template otherwise — same contract).
+3. SUPERSEDE each member is invalidated (``invalid_at``) and linked to the
+             summary via ``superseded_by``; a CONSOLIDATE event lands in the
+             audit history, so nothing is lost and the chain is replayable.
+
+The summary inherits the strongest member's importance (plus a small bonus),
+which lifts it into the core-memory block — repeatedly observed patterns get
+promoted, exactly the "distillation" LangMem describes. Because superseded
+members are gone from FTS and the vector scan, this also *shrinks* retrieval
+space while keeping information reachable through the summary.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from typing import Any, Dict, List, Optional
+
+from .embeddings import cosine, pack, unpack
+from .types import Memory, MemoryType
+
+CONSOLIDATION_SUMMARY_PROMPT = """You are the background memory reflection module of an AI agent.
+The facts below are same-topic memories about one user. Distill them into ONE
+short summary memory (third person, keeping every distinct detail that
+matters; drop repetition). Write it in the language the facts mostly use;
+1-2 sentences, up to 4 for a large cluster.
+
+Output STRICT JSON: {{"summary": "..."}}
+
+Facts:
+{facts}"""
+
+
+def _is_zh(text: str) -> bool:
+    return (len(re.findall(r"[\u4e00-\u9fff]", text))
+            > len(re.findall(r"[a-zA-Z]", text)))
+
+
+def find_clusters(memories: List[Memory], vectors: Dict[str, List[float]],
+                  threshold: float, min_cluster: int) -> List[List[Memory]]:
+    """Greedy density clustering over memory vectors."""
+    remaining = list(memories)
+    clusters: List[List[Memory]] = []
+    while remaining:
+        seed = remaining[0]
+        group = [m for m in remaining
+                 if cosine(vectors[seed.id], vectors[m.id]) >= threshold]
+        if len(group) >= min_cluster:
+            clusters.append(group)
+            remaining = [m for m in remaining if m not in group]
+        else:
+            remaining = remaining[1:]
+    return clusters
+
+
+def consolidate(engine, user_id: str = "default", agent_id: Optional[str] = None,
+                run_id: Optional[str] = None, min_cluster: Optional[int] = None,
+                threshold: Optional[float] = None) -> Dict[str, Any]:
+    """Run one reflection pass; returns an auditable report."""
+    cfg = engine.cfg
+    min_cluster = min_cluster if min_cluster is not None else cfg.consolidation_min_cluster
+    threshold = threshold if threshold is not None else cfg.consolidation_similarity
+
+    memories = engine.store.all_valid(user_id, agent_id, run_id)
+    # one abstraction level per pass: never re-merge summaries
+    memories = [m for m in memories if not m.metadata.get("consolidated")]
+    if len(memories) < min_cluster:
+        return {"clusters": 0, "summaries": [], "members_absorbed": 0}
+
+    vectors = {}
+    blobs = engine.store.get_embeddings([m.id for m in memories])
+    for m in memories:
+        vec = unpack(blobs.get(m.id), cfg.embedding_dim)
+        if vec is not None:
+            vectors[m.id] = vec
+    memories = [m for m in memories if m.id in vectors]
+
+    report: Dict[str, Any] = {"clusters": 0, "summaries": [], "members_absorbed": 0}
+    for group in find_clusters(memories, vectors, threshold, min_cluster):
+        group = sorted(group, key=lambda m: m.created_at)
+        texts = [m.text for m in group]
+        summary_text: Optional[str] = None
+        data = engine.llm.complete_json(
+            "You are the background memory reflection module of an AI agent.",
+            CONSOLIDATION_SUMMARY_PROMPT.format(
+                facts=json.dumps(texts, ensure_ascii=False)),
+        )
+        if data and data.get("summary"):
+            summary_text = str(data["summary"]).strip()
+        if not summary_text:
+            # deterministic fallback promised by the module contract: never
+            # let one bad LLM response kill the whole consolidation pass
+            summary_text = " | ".join(texts)[:500]
+
+        entities = sorted({e for m in group for e in m.entities})
+        summary = Memory(
+            text=summary_text,
+            memory_type=MemoryType.FACT,
+            user_id=user_id,
+            agent_id=agent_id,
+            run_id=run_id,
+            entities=entities[:8],
+            metadata={
+                "consolidated": True,
+                "members": [m.id for m in group],
+                "gate": "consolidated",
+            },
+            importance=min(0.95, max(m.importance for m in group) + 0.05),
+            source="consolidation",
+        )
+        engine.store.insert(summary, pack(summary_vec := engine.embedder.embed(summary_text)))
+        engine.vector_store.upsert(
+            summary.id, summary_vec,
+            {"memory_id": summary.id, "user_id": user_id,
+             "agent_id": agent_id, "run_id": run_id})
+        for m in group:
+            engine.store.supersede(m.id, summary.id)
+            engine.vector_store.delete(m.id)
+        report["clusters"] += 1
+        report["members_absorbed"] += len(group)
+        report["summaries"].append({"id": summary.id, "text": summary_text,
+                                    "members": [m.id for m in group]})
+    return report

memtide/decay.py

@@ -0,0 +1,89 @@
+"""Forgetting & reinforcement (cognitive-science flavored).
+
+Retention follows a Ebbinghaus-style exponential decay whose half-life is
+stretched by each successful retrieval (spacing effect):
+
+    half_life_eff = half_life_days * min(1 + gain * ln(1 + access_count), max_mult)
+    retention     = 0.5 ** (age_days / half_life_eff)
+
+``age_days`` counts from when the fact became true (valid_at/created_at):
+re-reading a memory reinforces it (longer half-life via access_count) but no
+longer rejuvenates its age — otherwise hot memories would live forever.
+Episodic memories fade faster than facts (episodic_mult < 1).
+
+Memories below their floor are treated as forgotten: they stay in the
+database (auditable, Zep-style) but stop surfacing in retrieval and the core
+memory block, until a future query re-excites them.
+"""
+
+from __future__ import annotations
+
+import math
+from datetime import datetime, timezone
+from typing import Optional
+
+from .types import Memory
+
+
+def _parse(ts: Optional[str]) -> Optional[datetime]:
+    if not ts:
+        return None
+    try:
+        return datetime.fromisoformat(ts)
+    except ValueError:
+        return None
+
+
+def age_days(mem: Memory, now: Optional[datetime] = None) -> float:
+    # Age counts from when the fact became true — NOT last_accessed: a hit
+    # reinforces (see effective_half_life) but must not reset the clock.
+    now = now or datetime.now(timezone.utc)
+    ref = _parse(mem.valid_at) or _parse(mem.created_at)
+    if ref is None:
+        return 0.0
+    if ref.tzinfo is None:
+        ref = ref.replace(tzinfo=timezone.utc)
+    return max(0.0, (now - ref).total_seconds() / 86400.0)
+
+
+def effective_half_life(mem: Memory, base_days: float, gain: float,
+                        consolidation_mult: float = 1.0,
+                        episodic_mult: float = 0.5,
+                        max_mult: float = 4.0) -> float:
+    """Half-life stretched by retrieval (spacing effect), capped at
+    ``max_mult`` × base so hot memories can't become effectively immortal.
+    Abstractions (source="consolidation") fade slower than episodes when a
+    multiplier > 1 is configured — the distilled summary outlives its members.
+    Episodic memories fade faster (episodic_mult < 1)."""
+    stretch = min(1.0 + gain * math.log1p(mem.access_count), max_mult)
+    hl = base_days * stretch
+    if mem.memory_type == "episodic":
+        hl *= episodic_mult
+    if consolidation_mult != 1.0 and mem.source == "consolidation":
+        hl *= consolidation_mult
+    return hl
+
+
+def retention(mem: Memory, base_days: float, gain: float, now: Optional[datetime] = None,
+              consolidation_mult: float = 1.0,
+              episodic_mult: float = 0.5,
+              max_mult: float = 4.0) -> float:
+    """Memory strength in [0, 1] — used for ranking and forgetting decisions."""
+    a = age_days(mem, now)
+    if a <= 0.0:
+        return 1.0
+    hl = effective_half_life(mem, base_days, gain, consolidation_mult,
+                             episodic_mult, max_mult)
+    return 0.5 ** (a / hl)
+
+
+def is_forgotten(mem: Memory, base_days: float, gain: float, floor: float,
+                 now: Optional[datetime] = None,
+                 consolidation_mult: float = 1.0,
+                 episodic_floor: Optional[float] = None,
+                 episodic_mult: float = 0.5,
+                 max_mult: float = 4.0) -> bool:
+    if episodic_floor is not None and mem.memory_type == "episodic":
+        floor = episodic_floor
+    return retention(mem, base_days, gain, now, consolidation_mult,
+                     episodic_mult, max_mult) < floor