imprint-layer 0.3.0__py3-none-any.whl

imprint/__init__.py

@@ -0,0 +1,14 @@
+"""Imprint: a personality calibration layer for any chat model.
+
+Learns how one user wants an assistant to talk (8 trait dials plus standing
+rules) from their own messages, and renders a short plain-text block for the
+host to inject into the system prompt.
+"""
+from .core import Imprint, LearnResult, new_profile
+from .embedders import Embedder, MiniLMEmbedder
+from .steering import Steer, detect_steering
+from .traits import TRAIT_NAMES, band_step, describe
+
+__all__ = ["Imprint", "LearnResult", "new_profile", "Embedder", "MiniLMEmbedder",
+           "Steer", "detect_steering", "TRAIT_NAMES", "band_step", "describe"]
+__version__ = "0.3.0"

imprint/core.py

@@ -0,0 +1,322 @@
+"""Imprint core: learn from each user message, render a calibration block.
+
+    imp = Imprint("me.profile.json")
+    imp.learn(user_text, timestamp=message_time)   # before building the prompt
+    system_prompt = base_prompt + "\\n\\n" + imp.directive()
+
+Model-agnostic: nothing here calls a chat model. The host supplies messages
+(with their timestamps) and a place to inject a text block.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import logging
+import os
+from copy import deepcopy
+from dataclasses import dataclass, field
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from typing import Iterable
+
+import numpy as np
+
+from . import rules as rules_mod
+from .embedders import Embedder, default_embedder
+from .steering import Steer, detect_steering, has_praise, last_retraction_end
+from .traits import (TRAIT_DEFAULTS, TRAIT_META, TRAIT_NAMES, TRAIT_POLES, band_step,
+                     describe)
+
+log = logging.getLogger("imprint")
+
+SCHEMA = "imprint.profile/1"
+MAX_CONFIDENCE = 0.95
+MIN_CONFIDENCE = 0.1
+BASE_LR = 0.15
+CONF_INC = 0.008
+STEER_CONF_INC = CONF_INC * 4
+HALF_LIFE = timedelta(days=30)
+VIBE_THRESHOLD = 0.16
+VIBE_THRESHOLD_PERSON = 0.11          # humor / warmth / flirt score lower in MiniLM
+PERSON_TRAITS = frozenset({"humor", "warmth", "flirt"})
+MAX_VIBE_TRAITS_PER_MSG = 2
+# A score that clears its threshold by a hair is noise, not signal: ignore
+# vibe strengths below this (≈ 0.04–0.045 past the threshold).
+MIN_VIBE_STRENGTH = 0.05
+MAX_OBSERVATIONS = 200
+MAX_RULES = 12
+
+
+@dataclass
+class LearnResult:
+    steered: list[Steer] = field(default_factory=list)
+    vibe: list[dict] = field(default_factory=list)
+    rules_added: list[str] = field(default_factory=list)
+    candidates_seen: int = 0
+    promoted: list[str] = field(default_factory=list)
+
+    @property
+    def changed_traits(self) -> bool:
+        return bool(self.steered or self.vibe)
+
+
+def _utc(ts) -> datetime | None:
+    if ts is None:
+        return None
+    if isinstance(ts, (int, float)):
+        return datetime.fromtimestamp(ts, tz=timezone.utc)
+    if isinstance(ts, str):
+        try:
+            ts = datetime.fromisoformat(ts.replace("Z", "+00:00"))
+        except ValueError:
+            return None
+    if not isinstance(ts, datetime):
+        return None
+    return (ts if ts.tzinfo else ts.replace(tzinfo=timezone.utc)).astimezone(timezone.utc)
+
+
+def _iso(dt: datetime | None) -> str | None:
+    return dt.isoformat(timespec="milliseconds") if dt else None
+
+
+def _now_iso() -> str:
+    return datetime.now(timezone.utc).isoformat(timespec="milliseconds")
+
+
+def new_profile(traits: Iterable[str] = TRAIT_NAMES) -> dict:
+    now = _now_iso()
+    return {
+        "schema": SCHEMA, "created": now, "lastUpdated": now, "interactions": 0,
+        "traits": {t: {"value": TRAIT_DEFAULTS[t]["value"],
+                       "confidence": TRAIT_DEFAULTS[t]["confidence"],
+                       "description": TRAIT_META[t]} for t in traits},
+        "rules": [], "candidateRules": [], "observations": [],
+    }
+
+
+class Imprint:
+    """One user's Imprint profile.
+
+    profile_path:  JSON file to load/save (None = in memory only).
+    embedder:      object with .name and .embed(list[str]) -> (n, d) array.
+                   Defaults to local all-MiniLM-L6-v2 (sentence-transformers).
+    traits:        subset of the 8 traits to learn and inject (default: all).
+    axes_cache:    optional .npz path to cache the embedded trait poles.
+    warmup:        interactions before directive() returns anything.
+    """
+
+    def __init__(self, profile_path: str | os.PathLike | None = None, *,
+                 embedder: Embedder | None = None,
+                 traits: Iterable[str] | None = None,
+                 axes_cache: str | os.PathLike | None = None,
+                 warmup: int = 5,
+                 max_inject_rules: int = 4,
+                 corroboration_gap: timedelta = timedelta(hours=1),
+                 candidate_ttl: timedelta = timedelta(days=90)):
+        self.traits = tuple(traits) if traits is not None else TRAIT_NAMES
+        unknown = set(self.traits) - set(TRAIT_NAMES)
+        if unknown:
+            raise ValueError(f"unknown traits: {sorted(unknown)}")
+        self.profile_path = Path(profile_path) if profile_path else None
+        self.axes_cache = Path(axes_cache) if axes_cache else None
+        self.warmup = warmup
+        self.max_inject_rules = max_inject_rules
+        self.corroboration_gap = corroboration_gap
+        self.candidate_ttl = candidate_ttl
+        self._embedder = embedder
+        self._axes: dict[str, tuple[np.ndarray, np.ndarray]] | None = None
+        self.profile = self._load()
+
+    # --- persistence ------------------------------------------------------------
+
+    def _load(self) -> dict:
+        p = new_profile(self.traits)
+        if self.profile_path and self.profile_path.exists():
+            data = json.loads(self.profile_path.read_text(encoding="utf-8"))
+            p.update({k: v for k, v in data.items() if k != "traits"})
+            for t, v in (data.get("traits") or {}).items():
+                if t in TRAIT_NAMES:
+                    p["traits"][t] = {**p["traits"].get(t, {}), **v}
+        return p
+
+    def save(self) -> None:
+        if not self.profile_path:
+            return
+        self.profile["lastUpdated"] = _now_iso()
+        self.profile["observations"] = self.profile["observations"][-MAX_OBSERVATIONS:]
+        self.profile_path.parent.mkdir(parents=True, exist_ok=True)
+        tmp = self.profile_path.with_suffix(self.profile_path.suffix + ".tmp")
+        tmp.write_text(json.dumps(self.profile, indent=2, ensure_ascii=False) + "\n",
+                       encoding="utf-8")
+        tmp.replace(self.profile_path)
+
+    # --- embedding axes -----------------------------------------------------------
+
+    @property
+    def embedder(self) -> Embedder:
+        if self._embedder is None:
+            self._embedder = default_embedder()
+        return self._embedder
+
+    def _fingerprint(self) -> str:
+        blob = json.dumps([self.embedder.name, TRAIT_POLES], sort_keys=True)
+        return hashlib.sha256(blob.encode()).hexdigest()[:16]
+
+    def axes(self) -> dict[str, tuple[np.ndarray, np.ndarray]]:
+        if self._axes is not None:
+            return self._axes
+        fp = self._fingerprint()
+        if self.axes_cache and self.axes_cache.exists():
+            data = np.load(self.axes_cache, allow_pickle=False)
+            if bytes(data["fingerprint"]).decode() == fp:
+                self._axes = {t: (data[f"{t}__high"], data[f"{t}__low"]) for t in TRAIT_POLES}
+                return self._axes
+        axes = {t: (_centroid(self.embedder, p["high"]), _centroid(self.embedder, p["low"]))
+                for t, p in TRAIT_POLES.items()}
+        if self.axes_cache:
+            self.axes_cache.parent.mkdir(parents=True, exist_ok=True)
+            np.savez(self.axes_cache, fingerprint=np.frombuffer(fp.encode(), dtype=np.uint8),
+                     **{f"{t}__{k}": v for t, (h, l) in axes.items()
+                        for k, v in (("high", h), ("low", l))})
+        self._axes = axes
+        return axes
+
+    def score(self, text: str) -> dict[str, float]:
+        """Bipolar vibe score per trait: cos(text, high) − cos(text, low)."""
+        m = _unit(self.embedder.embed([text])[0])
+        return {t: float(m @ h - m @ l) for t, (h, l) in self.axes().items()
+                if t in self.traits}
+
+    # --- learning -------------------------------------------------------------------
+
+    def vibe_signals(self, text: str) -> list[dict]:
+        scores = self.score(text)
+        person_clears = any(abs(scores.get(t, 0)) > VIBE_THRESHOLD_PERSON for t in PERSON_TRAITS)
+        cands = []
+        for t, s in scores.items():
+            thr = VIBE_THRESHOLD_PERSON if t in PERSON_TRAITS else VIBE_THRESHOLD
+            if abs(s) <= thr:
+                continue
+            if t == "formality" and person_clears:
+                continue  # person-shaped asks read "casual" to small embedders
+            strength = min(1.0, (abs(s) - thr) / (1 - thr))
+            if strength < MIN_VIBE_STRENGTH:
+                continue
+            cands.append((t, s, strength))
+        cands.sort(key=lambda c: -abs(c[1]))
+        return [{"trait": t, "direction": 1.0 if s > 0 else -1.0, "strength": st,
+                 "score": round(s, 4)} for t, s, st in cands[:MAX_VIBE_TRAITS_PER_MSG]]
+
+    def learn(self, text: str, timestamp=None, *, save: bool = True) -> LearnResult:
+        """Learn from one user message. `timestamp` = when the user sent it.
+
+        Without a timestamp, observations record null (never processing time),
+        no confidence decay is applied, and candidates can't be corroborated.
+        """
+        res = LearnResult()
+        text = (text or "").strip()
+        ts = _utc(timestamp)
+        if ts is None:
+            log.warning("imprint: no message timestamp (got %r); observation "
+                        "timestamps will be null", timestamp)
+        p = self.profile
+        p["interactions"] = int(p.get("interactions") or 0) + 1
+        if not text:
+            self._finish(save)
+            return res
+
+        res.steered = [s for s in detect_steering(text) if s.trait in self.traits]
+        for st in res.steered:
+            tr = p["traits"][st.trait]
+            self._decay(st.trait, ts)
+            before = tr["value"]
+            tr["value"] = band_step(st.trait, before, st.direction)
+            tr["confidence"] = min(MAX_CONFIDENCE, tr["confidence"] + STEER_CONF_INC)
+            self._observe(ts, st.trait, st.direction, "steer",
+                          f"{st.match[:80]!r} {before:.3f}→{tr['value']:.3f}")
+
+        if not res.steered:
+            cut = last_retraction_end(text)
+            standing = text[cut:] if cut >= 0 else text
+            if any(c.isalpha() for c in standing):
+                sigs = self.vibe_signals(standing)
+                if has_praise(text):  # praise never lowers warmth or humor
+                    sigs = [s for s in sigs
+                            if not (s["trait"] in ("warmth", "humor") and s["direction"] < 0)]
+                for s in sigs:
+                    tr = p["traits"][s["trait"]]
+                    self._decay(s["trait"], ts)
+                    lr = BASE_LR * (1 - tr["confidence"]) * s["strength"]
+                    tr["value"] = max(0.0, min(1.0, tr["value"] + s["direction"] * lr))
+                    tr["confidence"] = min(MAX_CONFIDENCE, tr["confidence"] + CONF_INC)
+                    self._observe(ts, s["trait"], s["direction"], "vibe", f"score={s['score']:+.3f}")
+                res.vibe = sigs
+
+        cap = rules_mod.capture(text)
+        for r in cap.rules:
+            if not any(rules_mod.rules_near_dup(r, e) for e in p["rules"]):
+                p["rules"].append(r)
+                res.rules_added.append(r)
+        res.candidates_seen = len(cap.candidates)
+        _, promoted = rules_mod.update_candidates(
+            p.setdefault("candidateRules", []), cap.candidates, ts,
+            gap=self.corroboration_gap, ttl=self.candidate_ttl)
+        for r in promoted:
+            if not any(rules_mod.rules_near_dup(r, e) for e in p["rules"]):
+                p["rules"].append(r)
+                res.promoted.append(r)
+        p["rules"] = p["rules"][-MAX_RULES:]
+        self._finish(save)
+        return res
+
+    def _finish(self, save: bool) -> None:
+        if save:
+            self.save()
+
+    def _observe(self, ts, trait, direction, source, detail) -> None:
+        self.profile["observations"].append({
+            "timestamp": _iso(ts), "trait": trait, "direction": direction,
+            "source": source, "detail": detail})
+
+    def _decay(self, trait: str, ts: datetime | None) -> None:
+        if ts is None:
+            return  # no message time, no decay (never substitute processing time)
+        last = next((o["timestamp"] for o in reversed(self.profile["observations"])
+                     if o["trait"] == trait and o.get("timestamp")), None)
+        last_dt = _utc(last)
+        if last_dt is None or ts <= last_dt:
+            return
+        tr = self.profile["traits"][trait]
+        f = 2 ** (-(ts - last_dt) / HALF_LIFE)
+        tr["confidence"] = max(MIN_CONFIDENCE, MIN_CONFIDENCE + (tr["confidence"] - MIN_CONFIDENCE) * f)
+
+    # --- output -------------------------------------------------------------------------
+
+    def directive(self) -> str:
+        """The calibration block to inject into the system prompt.
+
+        Byte-stable between learning events (no counters), so it can sit in a
+        cached system prompt. Empty until `warmup` interactions.
+        """
+        p = self.profile
+        if int(p.get("interactions") or 0) < self.warmup:
+            return ""
+        lines = ["Learned preferences for this user. Follow them unless the user asks otherwise.", ""]
+        lines += [describe(t, p["traits"][t]["value"]) for t in TRAIT_NAMES if t in self.traits]
+        injected = p["rules"][-self.max_inject_rules:] if self.max_inject_rules else []
+        if injected:
+            lines += ["", "Standing rules from the user:"] + [f"- {r}" for r in injected]
+        return "\n".join(lines)
+
+    def snapshot(self) -> dict:
+        return deepcopy(self.profile)
+
+
+def _unit(v) -> np.ndarray:
+    v = np.asarray(v, dtype=np.float32).reshape(-1)
+    n = float(np.linalg.norm(v))
+    return v / n if n > 1e-12 else v
+
+
+def _centroid(embedder: Embedder, phrases: list[str]) -> np.ndarray:
+    return _unit(np.mean(np.asarray(embedder.embed(phrases), dtype=np.float32), axis=0))

imprint/dashboard.py

@@ -0,0 +1,85 @@
+"""Read-only dashboard: render any Imprint profile JSON as a static HTML page.
+
+    python -m imprint.dashboard my.profile.json -o dashboard.html
+
+Shows each trait's value and band label, the standing rules, candidate rules
+awaiting corroboration, and observation counts. It never writes the profile.
+"""
+from __future__ import annotations
+
+import argparse
+import html
+import json
+from collections import Counter
+from pathlib import Path
+
+from .traits import BANDS, TRAIT_LABELS, TRAIT_META, TRAIT_NAMES, band_index
+
+_CSS = """
+:root{--bg:#fafaf9;--fg:#1c1917;--muted:#78716c;--card:#fff;--line:#e7e5e4;--bar:#4f46e5;--edge:#a8a29e}
+@media (prefers-color-scheme:dark){:root{--bg:#1c1917;--fg:#f5f5f4;--muted:#a8a29e;--card:#292524;--line:#44403c;--bar:#818cf8;--edge:#78716c}}
+*{box-sizing:border-box}body{margin:0;background:var(--bg);color:var(--fg);font:15px/1.5 system-ui,sans-serif}
+main{max-width:880px;margin:0 auto;padding:24px 16px}h1{font-size:22px;margin:0 0 4px}h2{font-size:16px;margin:28px 0 10px}
+.muted{color:var(--muted)}.card{background:var(--card);border:1px solid var(--line);border-radius:10px;padding:14px 16px;margin:10px 0}
+.row{display:grid;grid-template-columns:130px 1fr 56px;gap:12px;align-items:center}
+.track{position:relative;height:10px;border-radius:5px;background:var(--line)}
+.fill{position:absolute;left:0;top:0;bottom:0;border-radius:5px;background:var(--bar)}
+.edge{position:absolute;top:-3px;bottom:-3px;width:2px;background:var(--edge)}
+.band{grid-column:2/4;font-size:13px;color:var(--muted)}ul{margin:6px 0;padding-left:20px}
+.stats{display:flex;gap:24px;flex-wrap:wrap}.stat b{display:block;font-size:20px}
+@media (max-width:560px){.row{grid-template-columns:96px 1fr 44px}}
+"""
+
+
+def render_html(profile: dict, title: str = "Imprint profile") -> str:
+    e = html.escape
+    traits = profile.get("traits") or {}
+    rows = []
+    for t in TRAIT_NAMES:
+        if t not in traits:
+            continue
+        v = float(traits[t].get("value", 0.5))
+        c = float(traits[t].get("confidence", 0))
+        edges, sentences = BANDS[t]
+        marks = "".join(f'<span class="edge" style="left:{x * 100:.1f}%"></span>' for x in edges)
+        rows.append(
+            f'<div class="card"><div class="row"><b>{e(TRAIT_LABELS[t])}</b>'
+            f'<div class="track" title="{e(TRAIT_META[t])}"><span class="fill" style="width:{v * 100:.1f}%"></span>{marks}</div>'
+            f'<span>{v:.2f}</span><div class="band">{e(sentences[band_index(t, v)])} '
+            f'<span title="confidence">· conf {c:.2f}</span></div></div></div>')
+    obs = profile.get("observations") or []
+    by_source = Counter(o.get("source", "?") for o in obs)
+    rules = profile.get("rules") or []
+    cands = profile.get("candidateRules") or []
+    rule_list = "".join(f"<li>{e(r)}</li>" for r in rules) or '<li class="muted">None yet.</li>'
+    cand_list = "".join(
+        f"<li>{e(c.get('text', ''))} <span class='muted'>({'likes' if c.get('polarity', 1) > 0 else 'dislikes'},"
+        f" seen {len(c.get('evidence') or [])}×)</span></li>" for c in cands) or '<li class="muted">None.</li>'
+    stats = "".join(f'<div class="stat"><b>{n}</b><span class="muted">{e(k)}</span></div>' for k, n in [
+        ("interactions", profile.get("interactions", 0)), ("observations", len(obs)),
+        *[(f"{s} observations", n) for s, n in sorted(by_source.items())]])
+    return f"""<!doctype html><html lang="en"><head><meta charset="utf-8">
+<meta name="viewport" content="width=device-width,initial-scale=1"><title>{e(title)}</title>
+<style>{_CSS}</style></head><body><main>
+<h1>{e(title)}</h1><p class="muted">Last updated {e(str(profile.get('lastUpdated', 'unknown')))}. Read-only view; bar ticks mark band edges.</p>
+<div class="card stats">{stats}</div>
+<h2>Traits</h2>{''.join(rows)}
+<h2>Standing rules</h2><div class="card"><ul>{rule_list}</ul></div>
+<h2>Candidate rules <span class="muted">(not injected until corroborated)</span></h2><div class="card"><ul>{cand_list}</ul></div>
+</main></body></html>"""
+
+
+def main(argv=None) -> int:
+    ap = argparse.ArgumentParser(description="Render an Imprint profile as static HTML.")
+    ap.add_argument("profile", type=Path)
+    ap.add_argument("-o", "--out", type=Path, default=Path("imprint-dashboard.html"))
+    ap.add_argument("--title", default="Imprint profile")
+    a = ap.parse_args(argv)
+    a.out.write_text(render_html(json.loads(a.profile.read_text(encoding="utf-8")), a.title),
+                     encoding="utf-8")
+    print(f"wrote {a.out}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

imprint/embedders.py

@@ -0,0 +1,43 @@
+"""Embedder interface.
+
+Imprint needs one thing from an embedder: turn text into a fixed-length vector.
+The default is a small local sentence-transformer (all-MiniLM-L6-v2), which runs
+on CPU and never sends text anywhere. Any object with `embed(list[str]) ->
+array (n, d)` and a stable `name` works.
+"""
+from __future__ import annotations
+
+from typing import Protocol, Sequence, runtime_checkable
+
+import numpy as np
+
+
+@runtime_checkable
+class Embedder(Protocol):
+    name: str
+
+    def embed(self, texts: Sequence[str]) -> np.ndarray:  # (n, d)
+        ...
+
+
+class MiniLMEmbedder:
+    """Local all-MiniLM-L6-v2 via sentence-transformers (optional dependency)."""
+
+    def __init__(self, model_name: str = "all-MiniLM-L6-v2"):
+        try:
+            from sentence_transformers import SentenceTransformer
+        except ImportError as e:  # pragma: no cover - depends on environment
+            raise ImportError(
+                "The default embedder needs sentence-transformers: "
+                "pip install 'imprint-layer[minilm]', or pass your own embedder="
+            ) from e
+        self.name = f"sentence-transformers/{model_name}"
+        self._model = SentenceTransformer(model_name)
+
+    def embed(self, texts: Sequence[str]) -> np.ndarray:
+        return np.asarray(self._model.encode(list(texts), normalize_embeddings=True),
+                          dtype=np.float32)
+
+
+def default_embedder() -> Embedder:
+    return MiniLMEmbedder()

imprint/rules.py

@@ -0,0 +1,242 @@
+"""Two-tier standing-rule capture.
+
+Tier 1 — explicit forms become rules immediately:
+    "remember: ...", "always ..." / "never ..." (bare form must be followed by
+    an imperative verb), "always: ..." / "never: ...", "from now on ...",
+    "going forward ...".
+
+Tier 2 — natural preference statements become *candidate* rules:
+    "I prefer ...", "I like it when you ...", "I hate it when you ...",
+    "it bugs me when you ...", "I'd rather you ...", "I wish you wouldn't ...".
+    A candidate is promoted to a rule only when corroborated: the same
+    preference (same polarity, near-duplicate content) stated again in a
+    different message at least `corroboration_gap` later. Candidates are never
+    injected. Users don't learn any syntax; they just talk.
+
+Both tiers apply the same durability test. A rule must state an enduring
+preference: questions, time-bound text ("today", "at 3"), and task anchors
+(a named recipient, "now", a deadline, "this"/"that one") veto storage.
+"""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from datetime import datetime, timedelta
+
+from .steering import RETRACTION, detect_steering
+
+# --- durability ----------------------------------------------------------------
+
+_ONE_OFF = re.compile(
+    r"\b(?:today|tonight|tomorrow|yesterday|right\s+now|for\s+now|just\s+now|asap|"
+    r"later\s+(?:today|tonight)|"
+    r"this\s+(?:morning|afternoon|evening|week|weekend|month|time|once)|"
+    r"next\s+(?:week|month|monday|tuesday|wednesday|thursday|friday|saturday|sunday)|"
+    r"(?:on\s+)?(?:monday|tuesday|wednesday|thursday|friday|saturday|sunday)|"
+    r"(?:at|by|before|until)\s+\d|in\s+\d+\s?(?:min(?:ute)?s?|hours?|hrs?|days?)|\d{1,2}(?::\d{2})?\s?(?:am|pm))\b",
+    re.I,
+)
+_TASK_ANCHOR = re.compile(
+    r"\b(?:now|(?:before|by|until|till|due)\s+(?:noon|midnight|tonight|tomorrow|eod|cob|"
+    r"end\s+of|the\s+end|next|this|\d|monday|tuesday|wednesday|thursday|friday|saturday|"
+    r"sunday)|deadline|due\s+(?:date|on)|this|these|those|that\s+(?:one|thing|stuff|again)|"
+    r"(?:send|email|text|call|message|ping|forward|remind|tell|cc)\s+(?:her|him|them))\b",
+    re.I,
+)
+# A capitalized name after a recipient verb/preposition. Lowercase names can't
+# be told apart from ordinary words, so "to dana" is a known gap.
+_NOT_NAMES = {"I", "English", "Spanish", "French", "German", "Markdown", "Python",
+              "JSON", "SQL", "AI", "The", "My", "Your"}
+_RECIPIENT = re.compile(
+    r"\b(?i:to|for|with|cc|email|text|call|message|tell|ping|remind|ask|send|forward)"
+    r"\s+([A-Z][a-zA-Z]+)\b")
+
+
+def has_task_anchor(body: str) -> bool:
+    b = re.sub(r"\bfrom\s+now\s+on\b", " ", body or "", flags=re.I)
+    if _TASK_ANCHOR.search(b):
+        return True
+    return any(m.group(1) not in _NOT_NAMES for m in _RECIPIENT.finditer(b))
+
+
+def is_durable(body: str) -> bool:
+    b = (body or "").strip()
+    if not 4 <= len(b) <= 200 or b.endswith("?"):
+        return False
+    return not (_ONE_OFF.search(b) or has_task_anchor(b))
+
+
+# --- tier 1: explicit forms ------------------------------------------------------
+
+_RULE_VERBS = frozenset("""
+    be use ask answer reply respond keep call mention say talk start end open close
+    include give put write check confirm tell lead skip avoid stop let make match refer
+    address sign greet offer suggest apologize apologise hedge cite show explain assume
+    repeat restate speak remind bring do try follow treat wait act pretend lie joke flirt
+    swear curse break drop add format double-check cut leave share wrap read look take
+    pick choose respect interrupt lecture moralize moralise summarize summarise list
+    number quote push nag fake invent guess correct
+""".split())
+_REMEMBER = re.compile(r"^\s*remember\s*:\s*(.+)$", re.I)
+_ALWAYS_NEVER = re.compile(r"^\s*(always|never)\s*(:)?\s+(.+)$", re.I)
+_FROM_NOW_ON = re.compile(r"^\s*(?:from\s+now\s+on|going\s+forward)\s*[,:]?\s+(.+)$", re.I)
+
+# --- tier 2: natural preference statements -----------------------------------------
+
+_POS = (r"i\s+(?:really\s+|much\s+)?(?:prefer|like\s+it\s+when\s+you|love\s+it\s+when\s+you|"
+        r"appreciate\s+it\s+when\s+you|wish\s+you\s+would(?!n)|'?d\s+rather\s+you|"
+        r"would\s+rather\s+you)")
+_NEG = (r"i\s+(?:really\s+)?(?:hate\s+(?:it\s+)?when\s+you|don'?t\s+like\s+(?:it\s+)?when\s+you|"
+        r"can'?t\s+stand\s+(?:it\s+)?when\s+you|wish\s+you\s+wouldn'?t)|"
+        r"it\s+(?:really\s+)?(?:annoys|bugs|bothers|irritates)\s+me\s+when\s+you")
+_NATURAL = re.compile(r"^\s*(?:(?:honestly|also|and|but|so|fwiw)[,\s]+)?"
+                      r"(?:(?P<pos>" + _POS + r")|(?P<neg>" + _NEG + r"))\s+(?P<body>.+?)[.!]*$",
+                      re.I)
+
+_STOP = {"a", "an", "the", "to", "of", "for", "and", "or", "you", "your", "it", "is", "be",
+         "i", "me", "my", "when", "that", "with", "in", "on", "so", "really", "always",
+         "never", "just", "please", "do", "dont", "don't", "are", "more"}
+
+
+def content_key(body: str) -> frozenset[str]:
+    toks = re.findall(r"[a-z0-9']+", (body or "").lower())
+    return frozenset(t.rstrip("s") if len(t) > 3 else t for t in toks if t not in _STOP)
+
+
+def keys_match(a: frozenset[str], b: frozenset[str]) -> bool:
+    if not a or not b:
+        return False
+    if a <= b or b <= a:
+        return min(len(a), len(b)) >= 2 or a == b
+    return len(a & b) / len(a | b) >= 0.6
+
+
+def _norm(rule: str) -> str:
+    return re.sub(r"\s+", " ", re.sub(r"[^a-z0-9\s]", "", (rule or "").lower())).strip()
+
+
+def rules_near_dup(a: str, b: str) -> bool:
+    na, nb = _norm(a), _norm(b)
+    if not na or not nb:
+        return False
+    if na == nb:
+        return True
+    short, long_ = sorted((na, nb), key=len)
+    if len(short) >= 24 and short in long_:
+        return True
+    return keys_match(content_key(a), content_key(b)) and len(content_key(a)) >= 3
+
+
+@dataclass
+class Capture:
+    rules: list[str]          # tier 1: store now
+    candidates: list[dict]    # tier 2: {"text", "polarity"}
+
+
+def capture(text: str) -> Capture:
+    """Split `text` into explicit rules and natural-preference candidates."""
+    rules: list[str] = []
+    candidates: list[dict] = []
+    text = text or ""
+    cut = max((m.end() for m in RETRACTION.finditer(text)), default=-1)
+    # Each line, then each sentence within it, is checked independently.
+    for sm in re.finditer(r"[^\n.!?]+[.!?]*", text):
+        if sm.end() <= cut:
+            continue  # retracted later in the same message
+        # A retraction inside this segment cancels what precedes it; keep
+        # whatever the user said after it ("never mind, always: keep it short").
+        seg = (text[cut:sm.end()] if sm.start() < cut else sm.group(0)).strip(" \t,;:-—")
+        if not seg:
+            continue
+        rule = _explicit(seg)
+        if rule:
+            if not any(rules_near_dup(rule, r) for r in rules):
+                rules.append(rule)
+            continue
+        m = _NATURAL.match(seg)
+        if m and is_durable(m.group("body")) and not detect_steering(seg):
+            candidates.append({"text": seg.rstrip(".! "),
+                               "polarity": 1 if m.group("pos") else -1,
+                               "key": sorted(content_key(m.group("body")))})
+    return Capture(rules, candidates)
+
+
+def _explicit(seg: str) -> str | None:
+    m = _REMEMBER.match(seg)
+    if m:
+        body = m.group(1).strip()
+        return body.rstrip(".") if is_durable(body) and not detect_steering(body) else None
+    m = _FROM_NOW_ON.match(seg)
+    if m:
+        body = m.group(1).strip()
+        if is_durable(body) and not detect_steering(body):
+            return f"{body[0].upper()}{body[1:]}".rstrip(".")
+        return None
+    m = _ALWAYS_NEVER.match(seg)
+    if not m:
+        return None
+    cue, colon, body = m.group(1), m.group(2), m.group(3).strip()
+    if not is_durable(body):
+        return None
+    if not colon:
+        first = re.sub(r"[^a-z'-]", "", body.split()[0].lower())
+        if first not in _RULE_VERBS:
+            return None  # "Never mind", "Always the same with you"
+    if detect_steering(body) or detect_steering(seg):
+        return None  # a steering command is a dial move, not a rule
+    return f"{cue.capitalize()} {body}".rstrip(".")
+
+
+# --- candidate store -----------------------------------------------------------------
+
+def update_candidates(store: list[dict], new: list[dict], ts: datetime | None,
+                      *, gap: timedelta, ttl: timedelta, max_candidates: int = 50,
+                      ) -> tuple[list[dict], list[str]]:
+    """Merge new candidates into `store`; return (store, promoted rule texts).
+
+    Corroboration needs a second statement with the same polarity and matching
+    content, at least `gap` after the first evidence. Without a message
+    timestamp a statement is recorded but cannot corroborate.
+    """
+    promoted: list[str] = []
+    iso = ts.isoformat(timespec="milliseconds") if ts else None
+    for cand in new:
+        key = frozenset(cand["key"])
+        hit = next((c for c in store if keys_match(frozenset(c["key"]), key)), None)
+        if hit is None:
+            store.append({"text": cand["text"], "polarity": cand["polarity"],
+                          "key": cand["key"], "evidence": [iso]})
+            continue
+        if hit["polarity"] != cand["polarity"]:
+            # The user changed their mind: restart from the newer statement.
+            hit.update({"text": cand["text"], "polarity": cand["polarity"],
+                        "key": cand["key"], "evidence": [iso]})
+            continue
+        first = _first_ts(hit["evidence"])
+        if ts is not None and first is not None and ts - first >= gap:
+            promoted.append(f'Stated preference: "{hit["text"]}"')
+            store.remove(hit)
+        else:
+            hit["evidence"].append(iso)
+    if ts is not None:
+        store[:] = [c for c in store
+                    if (_last_ts(c["evidence"]) is None) or ts - _last_ts(c["evidence"]) <= ttl]
+    del store[:-max_candidates]
+    return store, promoted
+
+
+def _parse(s: str | None) -> datetime | None:
+    try:
+        return datetime.fromisoformat(s) if s else None
+    except ValueError:
+        return None
+
+
+def _first_ts(evidence: list) -> datetime | None:
+    ts = [t for t in (_parse(e) for e in evidence) if t]
+    return min(ts) if ts else None
+
+
+def _last_ts(evidence: list) -> datetime | None:
+    ts = [t for t in (_parse(e) for e in evidence) if t]
+    return max(ts) if ts else None

imprint/steering.py

@@ -0,0 +1,187 @@
+"""Direct steering: "be wittier", "more sarcastic", "you're too formal".
+
+A steering command names a dial as a property of the assistant, with a
+direction. It moves that trait one band (see traits.band_step), so the very
+next directive changes and each repeat walks one more band.
+
+What does NOT steer: bare mentions ("that was sarcastic"), questions about a
+dial ("why so sarcastic?"), third-party talk ("my boss could be funnier"),
+praise ("you're too kind"), and anything retracted later in the same message
+("be wittier. actually don't").
+"""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+# Dial words -> (trait, polarity). +1 names the trait's high pole, -1 its low
+# pole ("more serious" pushes humor down).
+_BASE: dict[str, tuple[str, int]] = {}
+_COMPARATIVE: dict[str, tuple[str, int]] = {}
+
+
+def _lex(table: dict, trait: str, pol: int, words: str) -> None:
+    for w in words.split("|"):
+        table[w.strip()] = (trait, pol)
+
+
+_lex(_BASE, "humor", +1, "sarcastic|sarcasm|funny|witty|wit|humor|humour|humorous|"
+     "jokey|joking|snarky|snark|cheeky|teasing")
+_lex(_BASE, "humor", -1, "serious|earnest|sober")
+_lex(_BASE, "warmth", +1, "warm|warmth|empathetic|empathy|caring|kind|gentle|emotional|"
+     "understanding|affectionate")
+_lex(_BASE, "warmth", -1, "matter-of-fact|matter of fact|businesslike|detached|cold")
+_lex(_BASE, "flirt", +1, "flirty|flirt|flirting|flirtatious|romantic")
+_lex(_BASE, "flirt", -1, "platonic")
+_lex(_BASE, "verbosity", +1, "detailed|detail|verbose|wordy|thorough|elaborate")
+_lex(_BASE, "verbosity", -1, "concise|brief|terse|succinct|to the point")
+_lex(_BASE, "formality", +1, "formal|professional|polished|proper|precise")
+_lex(_BASE, "formality", -1, "casual|informal|relaxed|laid-back|laid back|chill")
+_lex(_BASE, "autonomy", +1, "independent|autonomous|self-directed|self directed")
+_lex(_BASE, "autonomy", -1, "dependent|deferential")
+_lex(_BASE, "proactivity", +1, "proactive|initiative")
+_lex(_BASE, "proactivity", -1, "reactive")
+_lex(_BASE, "riskTolerance", +1, "bold|confident|decisive|assertive|daring")
+_lex(_BASE, "riskTolerance", -1, "careful|cautious|conservative|hedged")
+
+_lex(_COMPARATIVE, "humor", +1, "wittier|funnier|snarkier|cheekier")
+_lex(_COMPARATIVE, "warmth", +1, "warmer|kinder|gentler|softer")
+_lex(_COMPARATIVE, "warmth", -1, "colder")
+_lex(_COMPARATIVE, "flirt", +1, "flirtier")
+_lex(_COMPARATIVE, "verbosity", +1, "longer|wordier")
+_lex(_COMPARATIVE, "verbosity", -1, "shorter|briefer|terser")
+_lex(_COMPARATIVE, "riskTolerance", +1, "bolder|braver")
+_lex(_COMPARATIVE, "riskTolerance", -1, "safer")
+_lex(_COMPARATIVE, "formality", -1, "chiller")
+
+# Praise never steers down. Evaluative down-forms ("too X", "stop being so X",
+# "not so X") skip these words; "less kind" (explicit) still steers.
+PRAISE_WORDS = frozenset({
+    "kind", "caring", "gentle", "warm", "warmth", "understanding", "empathetic",
+    "empathy", "affectionate", "funny", "witty", "wit", "humorous",
+})
+_PRAISE_IDIOM = re.compile(
+    r"\b(?:you(?:'re|\s+are)\s+(?:\w+\s+){0,2}too\s+(?:kind|sweet|nice|good\s+to\s+me|"
+    r"generous|funny|much)|stop\s+being\s+so\s+(?:kind|sweet|nice|funny)|"
+    r"(?:that's|that\s+is|how)\s+(?:so\s+)?(?:kind|sweet|nice)\s+of\s+you)\b",
+    re.I,
+)
+
+
+def _alt(words) -> str:
+    return "|".join(re.escape(w).replace(r"\ ", r"\s+")
+                    for w in sorted(words, key=len, reverse=True))
+
+
+_B, _C = _alt(_BASE), _alt(_COMPARATIVE)
+# Fillers / an address ("Sam, ...") / a request frame may precede a command.
+# The command must open its clause: "be wittier" steers, "my boss could be
+# wittier" doesn't. "no" is a filler only when "more" doesn't follow it.
+_LEAD = (
+    r"^(?:(?:ok(?:ay)?|hey|please|and|also|now|just|so|alright|honestly|seriously|"
+    r"always|yeah|yes|no(?!\s+more\b)|but)[\s,!.]+)*"
+    r"(?:[a-z]+,\s*)?"
+    r"(?:(?:can|could|would|will)\s+you\s+(?:please\s+)?(?:try\s+(?:to\s+)?)?|"
+    r"i\s+(?:want|need)\s+you\s+to\s+|i(?:'d|\s+would)\s+like\s+you\s+to\s+|"
+    r"you\s+(?:can|could|should|may)\s+|try\s+(?:to\s+)?|feel\s+free\s+to\s+)?"
+    r"(?:please\s+)?"
+)
+_INT = r"(?:(?:a\s+)?(?:bit|little|lot|tad|touch)\s+|(?:way|much|even|slightly|somewhat)\s+)*"
+_TAIL = (r"(?:[\s,]+(?:please|pls|from\s+you|with\s+me|now|again|"
+         r"in\s+your\s+(?:replies|responses|answers)))*[\s.!]*$")
+
+_PATTERNS: list[tuple[re.Pattern, str]] = [(re.compile(p, re.I), k) for p, k in [
+    (_LEAD + r"no\s+more\s+(?P<w>" + _B + r")\b", "neg"),
+    (_LEAD + r"(?:be|get|sound|act|go|try\s+being)\s+" + _INT
+     + r"(?P<mod>more|less)\s+(?P<w>" + _B + r")\b", "mod"),
+    (_LEAD + r"(?:be|get|sound|act)\s+" + _INT + r"(?P<w>" + _C + r")\b", "comp"),
+    (_LEAD + _INT + r"(?P<mod>more|less)\s+(?P<w>" + _B + r")" + _TAIL, "mod"),
+    (_LEAD + _INT + r"(?P<w>" + _C + r")" + _TAIL, "comp"),
+    (_LEAD + r"(?:i(?:'d|\s+would)\s+like|i\s+want|give\s+me)\s+" + _INT
+     + r"(?P<mod>more|less)\s+(?P<w>" + _B + r")\b", "mod"),
+    (_LEAD + r"(?:dial|turn|crank|tone|ramp)\s+(?:it\s+)?(?P<ud>up|down)\s+(?:on\s+)?"
+     r"(?:the\s+|your\s+)?(?P<w>" + _B + r")\b", "ud"),
+    (_LEAD + r"(?:dial|turn|crank|tone|ramp)\s+(?:the\s+|your\s+)?(?P<w>" + _B
+     + r")\s+(?P<ud>up|down)\b", "ud"),
+    (_LEAD + r"(?:you(?:'re|\s+are)\s+(?:being\s+)?)?" + _INT + r"too\s+(?P<w>" + _B + r")\b",
+     "eval"),
+    (_LEAD + r"(?:(?:stop\s+being|quit\s+being|don'?t\s+be|do\s+not\s+be)\s+(?:so\s+)?|"
+     r"not\s+so\s+)(?P<w>" + _B + r")\b", "eval"),
+]]
+
+_QUESTION_OPENER = re.compile(
+    r"^(?:why|what|how|who|when|where|are|is|was|were|am|do|does|did|have|has)\b", re.I)
+
+RETRACTION = re.compile(
+    r"\b(?:actually\s+(?:don'?t|no|not|never\s*mind)|never\s*mind|nevermind|"
+    r"scratch\s+that|(?<!don't\s)(?<!dont\s)(?<!not\s)forget\s+(?:that|it|i\s+said\s+that)|wait,?\s+no|no,?\s+wait|"
+    r"just\s+kidding|jk|ignore\s+(?:that|what\s+i\s+said)|cancel\s+that|"
+    r"on\s+second\s+thought|don'?t\s+do\s+that|i\s+take\s+(?:that|it)\s+back)\b",
+    re.I,
+)
+# Clauses: sentences, plus ", and" / "and" / "but" joins.
+_CLAUSE = re.compile(r"[^.!?\n;]+?(?=(?:,?\s+(?:and|but)\s+)|[.!?\n;]|$)", re.I)
+
+
+@dataclass(frozen=True)
+class Steer:
+    trait: str
+    direction: float  # +1 toward the trait's high pole, -1 toward low
+    match: str
+
+
+def last_retraction_end(text: str) -> int:
+    """Offset just past the last retraction marker, or -1 if none."""
+    ends = [m.end() for m in RETRACTION.finditer(text or "")]
+    return max(ends) if ends else -1
+
+
+def has_praise(text: str) -> bool:
+    return bool(_PRAISE_IDIOM.search(text or ""))
+
+
+def detect_steering(text: str) -> list[Steer]:
+    """Steering commands in `text`, one per trait, retractions applied."""
+    text = (text or "").strip()
+    if not text:
+        return []
+    found: list[tuple[int, Steer]] = []
+    cut = last_retraction_end(text)
+    clauses = [(cm.start(), cm.group(0)) for cm in _CLAUSE.finditer(text)]
+    if cut >= 0:
+        # What follows a retraction starts fresh, even without punctuation
+        # ("never mind, be more sarcastic").
+        clauses += [(cut + cm.start(), cm.group(0)) for cm in _CLAUSE.finditer(text[cut:])]
+    for cstart, raw in clauses:
+        clause = raw.strip(" ,;:-—")
+        if not clause or _QUESTION_OPENER.match(clause):
+            continue
+        start = cstart + raw.find(clause)
+        for pat, kind in _PATTERNS:
+            m = pat.search(clause)
+            if not m:
+                continue
+            word = re.sub(r"\s+", " ", m.group("w").lower())
+            if kind == "eval" and word in PRAISE_WORDS:
+                break  # a compliment, not a complaint
+            trait, pol = (_COMPARATIVE if kind == "comp" else _BASE)[word]
+            if kind == "mod":
+                sign = 1 if m.group("mod").lower() == "more" else -1
+            elif kind == "ud":
+                sign = 1 if m.group("ud").lower() == "up" else -1
+            elif kind in ("neg", "eval"):
+                sign = -1
+            else:
+                sign = 1
+            found.append((start + m.start(), Steer(trait, float(pol * sign), m.group(0).strip())))
+            break
+    if cut >= 0:
+        # A retraction cancels every command that starts before it.
+        found = [(pos, st) for pos, st in found if pos >= cut]
+    out: list[Steer] = []
+    seen: set[str] = set()
+    for _, st in found:
+        if st.trait not in seen:
+            seen.add(st.trait)
+            out.append(st)
+    return out

imprint/traits.py

@@ -0,0 +1,207 @@
+"""The eight Imprint traits: metadata, priors, band ladders, directive text, and
+embedding pole exemplars.
+
+Every trait is a value in [0, 1]. The directive never shows the raw number; it
+shows the sentence for the band the value falls in. Band edges here are the
+single source of truth for both the directive text and band-step steering.
+"""
+from __future__ import annotations
+
+TRAIT_NAMES: tuple[str, ...] = (
+    "verbosity", "autonomy", "formality", "proactivity",
+    "riskTolerance", "humor", "warmth", "flirt",
+)
+
+TRAIT_META: dict[str, str] = {
+    "verbosity": "concise and direct ↔ detailed explanations",
+    "autonomy": "always ask first ↔ act on own judgment",
+    "formality": "casual and conversational ↔ formal and precise",
+    "proactivity": "wait for instructions ↔ suggest next steps unprompted",
+    "riskTolerance": "cautious claims ↔ confident, committed takes",
+    "humor": "straight and earnest ↔ dry, sarcastic wit",
+    "warmth": "matter-of-fact ↔ emotionally present",
+    "flirt": "platonic ↔ playful romantic charge",
+}
+
+# Neutral priors for a new profile. Flirt starts in its platonic band; a host
+# that never wants it can disable the trait (Imprint(traits=...)).
+TRAIT_DEFAULTS: dict[str, dict[str, float]] = {
+    "verbosity": {"value": 0.5, "confidence": 0.2},
+    "autonomy": {"value": 0.5, "confidence": 0.2},
+    "formality": {"value": 0.5, "confidence": 0.2},
+    "proactivity": {"value": 0.5, "confidence": 0.2},
+    "riskTolerance": {"value": 0.5, "confidence": 0.2},
+    "humor": {"value": 0.45, "confidence": 0.2},
+    "warmth": {"value": 0.5, "confidence": 0.2},
+    "flirt": {"value": 0.2, "confidence": 0.2},
+}
+
+# (edge, ...) and one sentence per band: len(sentences) == len(edges) + 1.
+# A value v is in band i where i = number of edges <= v.
+BANDS: dict[str, tuple[tuple[float, ...], tuple[str, ...]]] = {
+    "verbosity": ((0.25, 0.4, 0.6, 0.75), (
+        "Extremely concise. One line when possible. No filler, no restating the user.",
+        "Concise and direct. Lead with the answer. Skip restatement and repeated points.",
+        "Balance brevity with clarity. Explain when asked; don't over-elaborate.",
+        "Thorough when useful. Include context, but don't loop the same idea.",
+        "Detailed walkthroughs are welcome. Still avoid repeating yourself.",
+    )),
+    "autonomy": ((0.4, 0.6), (
+        "Ask before acting on non-trivial choices.",
+        "Use judgment on routine choices; confirm only high-stakes ones.",
+        "Act on your own judgment. Don't wait for permission on reasonable calls.",
+    )),
+    "formality": ((0.4, 0.6), (
+        "Casual, conversational register. Not a lecture, not corporate.",
+        "Friendly and clear. Competent without stiffness.",
+        "Precise, professional wording.",
+    )),
+    "proactivity": ((0.4, 0.6), (
+        "Don't pile on suggestions or offer follow-up work. Answer, then stop.",
+        "Offer a next step only when it clearly helps.",
+        "Bring useful next steps and fresh ideas without being asked.",
+    )),
+    "riskTolerance": ((0.35, 0.6), (
+        "Prefer careful claims. Flag uncertainty; don't invent authority.",
+        "Balanced. Own uncertainty when guessing; commit when you know.",
+        "Commit to clear positions. Don't over-hedge; still don't fake expertise.",
+    )),
+    "humor": ((0.35, 0.55, 0.75), (
+        "Straight and earnest. Skip jokes and sarcasm unless clearly invited.",
+        "Light wit is fine when it fits. Don't force bits.",
+        "Dry wit and occasional sarcasm are welcome.",
+        "Lean into dry, sarcastic humor often. Still read the room; never cruel.",
+    )),
+    "warmth": ((0.35, 0.55, 0.75), (
+        "Cool and practical. Matter-of-fact; skip empathy padding.",
+        "Friendly and present without gushing.",
+        "Emotionally present. Empathetic when it matters; never fake validation.",
+        "High warmth. Caring and encouraging, without empty flattery.",
+    )),
+    "flirt": ((0.35, 0.55, 0.75), (
+        "Platonic. No romantic or flirtatious tone.",
+        "A light playful spark is fine occasionally.",
+        "Clear flirty banter is welcome when it fits.",
+        "Playful romantic charge often. Stay yourself; keep it consensual and kind.",
+    )),
+}
+
+TRAIT_LABELS: dict[str, str] = {
+    "verbosity": "Communication", "autonomy": "Autonomy", "formality": "Register",
+    "proactivity": "Proactivity", "riskTolerance": "Risk", "humor": "Humor",
+    "warmth": "Warmth", "flirt": "Flirt",
+}
+
+
+def band_index(trait: str, value: float) -> int:
+    edges, _ = BANDS[trait]
+    return sum(1 for e in edges if e <= float(value))
+
+
+def describe(trait: str, value: float) -> str:
+    _, sentences = BANDS[trait]
+    return f"- **{TRAIT_LABELS[trait]}:** {sentences[band_index(trait, value)]}"
+
+
+def band_step(trait: str, value: float, direction: float, margin: float = 0.01) -> float:
+    """Next (direction > 0) or previous (direction < 0) band edge ± margin.
+
+    Landing a hair past the edge means one small ambient update can't undo a
+    command. Unchanged at either end of the ladder.
+    """
+    edges, _ = BANDS[trait]
+    v = float(value)
+    if direction > 0:
+        above = [e for e in edges if e > v]
+        return min(1.0, above[0] + margin) if above else v
+    if direction < 0:
+        at_or_below = [e for e in edges if e <= v]
+        return max(0.0, at_or_below[-1] - margin) if at_or_below else v
+    return v
+
+
+# Exemplars define each embedding axis (high pole − low pole). A message rides
+# the continuum by cosine similarity; these are not keyword lists. Tuned so
+# ordinary check-ins stay under the vibe thresholds with all-MiniLM-L6-v2.
+TRAIT_POLES: dict[str, dict[str, list[str]]] = {
+    "autonomy": {
+        "low": ["Ask me before you do anything.",
+                "Don't decide on your own — check with me first.",
+                "Wait for my approval before researching or choosing.",
+                "I want you dependent on my instructions."],
+        "high": ["You can choose for yourself.",
+                 "Pick something on your own. Don't only echo me.",
+                 "Genuinely choose with no parameters from me.",
+                 "Act on your own curiosity, not my last topic.",
+                 "Use your own judgment — independent research and takes."],
+    },
+    "verbosity": {
+        "low": ["Shorter. Too long. Cut it down.", "Be brief. One line when you can.",
+                "You're repeating yourself. Stop looping the same point.",
+                "Don't restate what I just said. Lead with your take.", "Too much filler. Concise."],
+        "high": ["Elaborate on that. Explain more.", "Walk me through it in detail.",
+                 "I don't mind the theory lesson — unpack it fully.",
+                 "What does that mean? Go deeper.", "More detail please, longer explanation."],
+    },
+    "formality": {
+        "low": ["Keep it casual. Don't lecture me.", "Not corporate. Not generic AI tone.",
+                "Talk like a friend — warm and light.", "Drop the stiff professional voice."],
+        "high": ["Be more precise and professional.", "Tighter formal wording please.",
+                 "More exact language, less slang.", "Careful precise register."],
+    },
+    "proactivity": {
+        "low": ["Wait for instructions. Don't pile on suggestions.",
+                "Less nudging. Don't fill silence with soft suggestions.",
+                "You're just chasing the last two topics.",
+                "Stop suggesting things just because we talked about them recently."],
+        "high": ["Bring a fresh thread of your own unprompted.",
+                 "Suggest when you have something real and new.",
+                 "Reach out with a new thought, not a rehash of recent chat.",
+                 "Self-directed exploration and initiative are welcome."],
+    },
+    "riskTolerance": {
+        "low": ["Hedge when unsure. Don't invent technical authority.",
+                "Prefer careful claims over confident guesses.",
+                "Confirm before stating something as fact.",
+                "Stay epistemically cautious — caveat your takes."],
+        "high": ["State it firmly when you know. Don't over-hedge.",
+                 "Own the judgment. Confident take is fine.",
+                 "Commit to the claim — stop caveating every sentence.",
+                 "Be willing to stake a clear position."],
+    },
+    "humor": {
+        "low": ["Skip the jokes, be serious.", "No sarcasm. Straight answers only.",
+                "Don't try to be funny right now.", "Stay earnest. Humor misses the mark.",
+                "Cut the witty remarks. Sober tone.", "Less joking. Earnest replies."],
+        "high": ["I'd like more sarcastic humor from you occasionally.",
+                 "Can you add some sarcastic humor to your responses occasionally?",
+                 "Add some sarcastic humor to your responses occasionally.",
+                 "More sarcastic humor please.", "Crack a joke — dry wit and sarcasm welcome.",
+                 "Be funnier. Playful sarcasm is good.", "Tease a bit. Dry sarcastic humor."],
+    },
+    "warmth": {
+        "low": ["Less emotional. Keep it matter-of-fact.",
+                "Don't be soft or sentimental. Just the facts.",
+                "Keep it all business, less emotional.", "Dial down the warmth. Content only.",
+                "I don't want empathy right now — cool and practical.",
+                "Less caring-voice. Matter-of-fact only."],
+        "high": ["Be more empathetic and understanding with me.",
+                 "More warmth — speak like a friend who cares.",
+                 "I want empathy and emotional presence, not all business.",
+                 "Be warmer and more understanding.",
+                 "Emotional presence matters. Be the caring friend.",
+                 "You can crack a joke and be empathetic and understanding."],
+    },
+    "flirt": {
+        "low": ["Keep it platonic. No flirting.", "Dial down the flirty energy. Just friends.",
+                "Don't be flirtatious. Straight and reserved.",
+                "No romantic banter. Keep it clean and platonic.",
+                "Stop flirting. Zero romantic charge."],
+        "high": ["Be more flirty with me.", "I'd like you to be more flirty occasionally.",
+                 "Turn up the flirt — playful romantic charge is welcome.",
+                 "Flirt a bit more. Light teasing, charged banter.",
+                 "You can be flirty. Playful and a little suggestive is fine.",
+                 "More flirty energy please. Flirt with me.",
+                 "Be flirtatious. I want playful romantic banter."],
+    },
+}

imprint_layer-0.3.0.dist-info/METADATA

@@ -0,0 +1,127 @@
+Metadata-Version: 2.4
+Name: imprint-layer
+Version: 0.3.0
+Summary: A personality calibration layer for any chat model: learns how one user wants an assistant to talk, from their own messages.
+License-Expression: MIT
+Keywords: llm,personalization,system-prompt,assistant,embeddings
+Classifier: Programming Language :: Python :: 3
+Classifier: Intended Audience :: Developers
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24
+Provides-Extra: minilm
+Requires-Dist: sentence-transformers>=2.2; extra == "minilm"
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Dynamic: license-file
+
+# Imprint
+
+**Tell your bot to be wittier. It becomes wittier.**
+
+A personality calibration layer for any chat model. Imprint learns how one person wants an assistant to talk from that person's own messages. It then renders a short plain-text block that you put in the system prompt.
+
+```python
+from imprint import Imprint
+
+imp = Imprint("me.profile.json")
+
+def on_user_message(text, sent_at):
+    imp.learn(text, timestamp=sent_at)       # learn first...
+    system = BASE_PROMPT + "\n\n" + imp.directive()   # ...then build the prompt
+    return call_your_model(system, history)
+```
+
+## What it learns
+
+**Eight dials, each a value from 0 to 1:**
+
+| Dial | Low ↔ high |
+|---|---|
+| verbosity | concise ↔ detailed |
+| autonomy | ask first ↔ act on own judgment |
+| formality | casual ↔ formal |
+| proactivity | wait for instructions ↔ suggest next steps |
+| riskTolerance | careful claims ↔ committed takes |
+| humor | earnest ↔ dry, sarcastic wit |
+| warmth | matter-of-fact ↔ emotionally present |
+| flirt | platonic ↔ playful romantic charge |
+
+The model never sees the numbers. Each dial has a few bands, and the directive carries one plain sentence per dial for the band it's in. Use `Imprint(traits=[...])` to learn and inject only the dials you want. A work assistant would probably drop `flirt`.
+
+**Dials move three ways:**
+
+- **Direct steering.** "be wittier", "more sarcastic", "less detail please", "you're too formal", "dial up the warmth", "no more snark". The named dial moves one full band, so the very next reply changes. Saying it again moves one more band.
+  - Questions about a dial ("why so sarcastic?") don't steer.
+  - Passing mentions don't steer, and neither does talk about other people ("my boss could be funnier").
+  - Praise never steers down: "you're too kind" is a compliment.
+  - A command you take back in the same message ("be wittier. actually, never mind") is cancelled.
+- **Tone of feedback.** Messages like "you're repeating yourself, too much filler" nudge a dial a little. Each message's embedding is compared against example phrases for each end of each dial. Ordinary conversation stays under the thresholds and moves nothing.
+- **Standing rules, captured in two tiers.** Nobody has to learn a syntax.
+  - *Explicit forms* become rules immediately: "never use emoji", "always: cite sources", "from now on, use metric units", "remember: I'm vegetarian".
+  - *Natural preference statements* become candidate rules: "I prefer metric units", "I hate it when you use bullet points". A candidate becomes a rule only when the user says the same thing again in a different message at least an hour later. Candidates are never injected, and they expire after 90 days without corroboration.
+  - Neither tier stores one-off tasks. A deadline, a named recipient, "now", or "this one" marks a task, not a preference ("always send the report to Dana by Friday" is a task).
+
+## Model-agnostic, with an honest caveat
+
+Imprint never calls a chat model. It works with anything that accepts a system prompt: a local model behind llama.cpp, Ollama or vLLM, or a hosted frontier model through its API. The default embedder (`all-MiniLM-L6-v2`) runs locally on CPU, so the user's messages aren't sent anywhere for learning.
+
+**The mechanism is model-agnostic. The effect is not.** How closely replies follow the calibration block depends on how well the host model follows instructions. A strong model will follow "Dry wit and occasional sarcasm are welcome" closely. A small model may follow it loosely, or not at all.
+
+## Integration contract
+
+Your host provides two things:
+
+1. **Each user message, with the time the user sent it.** Call `learn(text, timestamp=...)` before you build the prompt for that turn. Without a timestamp, Imprint still learns, but it records the time as unknown (never the processing time), skips confidence decay, and can't corroborate candidate rules. It logs a warning when this happens.
+2. **A place to inject text into the system prompt.** `directive()` returns the block, or `""` until `warmup` interactions (default 5) have passed. It stays identical byte for byte until something is actually learned, so it works with prompt caching.
+
+Everything beyond that is up to the host: memory, retrieval, tools, scheduling.
+
+## Install
+
+```bash
+pip install imprint-layer
+```
+
+The distribution is `imprint-layer`; the import is `imprint`. The default local embedder needs sentence-transformers: `pip install "imprint-layer[minilm]"`. Without it, pass your own embedder.
+
+A custom embedder is any object with a `name` and `embed(list_of_texts) -> array of shape (n, d)`. Pass it as `Imprint(..., embedder=MyEmbedder())`.
+
+## Examples
+
+- `examples/local_chat.py`: a chat loop against a local OpenAI-compatible server.
+- `examples/frontier_api.py`: the same injection, against a hosted API.
+
+Both are reference integrations to read and adapt. They aren't products.
+
+## Dashboard
+
+```bash
+imprint-dashboard my.profile.json -o dashboard.html
+```
+
+This renders a read-only static page: each dial's value and band, the standing rules, candidate rules and observation counts. Try it on `examples/sample.profile.json`.
+
+## Privacy
+
+A profile is personal data. It records how one person talks and what they've asked for. Keep profiles on the user's machine or in your own storage, and **never commit a real profile**. The included `.gitignore` excludes `*.profile.json`. Observations store short excerpts of the messages that moved a dial, and candidate rules store the user's own sentence.
+
+## What Imprint is not
+
+- Not a memory system. It doesn't store facts about the user or conversation history.
+- Not a hosted service. There's no account or server, and no data leaves your machine except through the chat calls you make yourself.
+- Not fine-tuning. Nothing about the model changes; Imprint only adds prompt text.
+- Not a safety layer. The calibration block is a preference, and your model's own policies still apply.
+
+## Tests
+
+```bash
+pip install -e ".[test]"
+pytest                                   # deterministic fake embedder, no downloads
+IMPRINT_TEST_MINILM=1 pytest             # also run the real-embedder checks
+```
+
+## License
+
+MIT

imprint_layer-0.3.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+imprint/__init__.py,sha256=wwqo9GEVsECdgi7jksXi1zULnuJFlrNyP0gtyACV7_A,643
+imprint/core.py,sha256=dsOqOaUi2LHIhwjcf_eJDYfBye5KGeqtE5xPz5VA_wk,13629
+imprint/dashboard.py,sha256=WJ-kYn8LXGm5zfmFc3QhZOQNscWZOYyAGcbUFGg3J3U,4592
+imprint/embedders.py,sha256=4SvJqYWV1TOsVI1DTYmK7ZaA7qDYgP9ubwYibM8MYis,1454
+imprint/rules.py,sha256=YLEebYAx6sqnUlfU_nZALxFNBZaj-d-7Rn-FzN6Yxss,10490
+imprint/steering.py,sha256=SkxUG1ALmyI4I4t6VMgFVBdu-5cGMCy3hesoqdCT5fc,8457
+imprint/traits.py,sha256=z189A5uSl5hbxVfYF0zPL4y7SZzYXoXKpaWwNlWrZYk,10697
+imprint_layer-0.3.0.dist-info/licenses/LICENSE,sha256=T0SaHXCrKjbPtktWXy0kO5XFngtZsxwRu5Ab7EM0h6k,1071
+imprint_layer-0.3.0.dist-info/METADATA,sha256=GDraoe-fFXdeE821e_WmY8QMG60xnA-0HtNQZseZHBg,6859
+imprint_layer-0.3.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+imprint_layer-0.3.0.dist-info/entry_points.txt,sha256=vXs7f0UVqbjfZHqzyxD8n5os0rFs-osrvkSQdjgaWFE,61
+imprint_layer-0.3.0.dist-info/top_level.txt,sha256=734cZ-CbhUQUqqwXL90O24h68KQayWEcc-DlnLpn9ho,8
+imprint_layer-0.3.0.dist-info/RECORD,,

imprint_layer-0.3.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

imprint_layer-0.3.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+imprint-dashboard = imprint.dashboard:main

imprint_layer-0.3.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Gabe Hernandez
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

imprint_layer-0.3.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+imprint