Anatomy of an entry

An entry's database row is the source of truth; a human-readable file is a mirror of it. This page lists every field, then the actual allowed values and the exact rule that sets each one.

Every field on a knowledge entry

The values themselves, and how each is computed

type — the 5 knowledge types

Set by the extraction LLM, then checked against a closed list. Anything off-list is dropped, never coerced. The five, and nothing else:

• framework — a repeatable, transferable mental model applied across situations. The most valuable type, because it helps reason about brand-new topics.
• decision — a specific choice together with its reasoning. Rejected if the WHY is missing — a decision without its rationale is worthless for extrapolation.
• standard — an enforceable bar phrased as "do this" or "don't do this". Distinct from a philosophy in that breaking a standard triggers pushback.
• philosophy — a genuine worldview belief phrased as "I believe...". Deeper than a standard and rare, so high signal. It informs reasoning but does not by itself trigger pushback.
• reaction — the principal evaluating someone's work, praise or criticism. Teaches the quality bar: what gets commended versus called out.

confidence — reliability, and auto-promotion

LLM-judged from how firmly the position is held (reliability — not merely whether it was said out loud). The three levels:

• high — stated explicitly and unambiguously as a held position.
• medium — stated clearly once, or a confident inference from explicit context. Also the default when the model leaves it unspecified.
• low — inferred, implied, or one-off.

How it can change without a human: once corroboration_count reaches 3, confidence is forced to high regardless of the original judgment — a position seen three separate times is, by definition, reliably held.

stability — durability, and how the decay is calculated

The "joints vs welds" idea, judged per entry (durability is independent of type — a philosophy can be an evergreen principle OR a shifting prior). The three levels, with the freshness half-life each maps to:

• evergreen — a core principle or identity that essentially never changes. Half-life is none; it never decays (a weld).
• stable — holds for a long time, revisited only on a real change. Half-life ~730 days (≈2 years). The default when unspecified.
• evolving — a current take or priority likely to shift within weeks. Half-life ~21 days.

The exact calculation (used only at read time, in the reranker):

freshness = exp( -days_old / half_life )

So an evolving entry loses about half its freshness weight every 3 weeks, a stable entry fades over years, and an evergreen entry keeps a freshness weight of 1.0 forever. An unparseable or future date returns 1.0 rather than being penalized.

Why not infer stability from type: an earlier design mapped all philosophy to "drifting", which would have decayed the core principles fastest — exactly backwards. It was rejected.

reasoning_pattern — how the slug is resolved

Not just copied from the model — it is resolved by the patterns engine (full detail in Reasoning patterns):

• If the extractor tagged a known slug, trust it and accumulate the observation onto that pattern. The field is that slug.
• If it tagged an unknown slug or gave free-text, that text is embedded and matched to the nearest existing pattern (cosine ≥ 0.72). If it matches, the field becomes the matched slug; otherwise a new provisional pattern is minted and the field becomes that new slug.
• If nothing applies (no signal, or the observation was rejected as pure communication style), the field is null.

tags — free-form, unioned on merge

An LLM-generated list of short topic keywords. There is no fixed vocabulary. On a merge, the surviving entry's tags become the union of both entries' tags — so a recurring position accumulates the labels people used across occurrences.

source_date — set at ingest, refreshed to the newer date

Initial value is the date of the source conversation. On every merge it is bumped to the newer of the two dates. Why: if the principal restates a position in a recent meeting, that position should count as fresh in ranking even though the entry was first created months ago.

corroboration_count — a plain counter that drives promotion

Not judged, just counted. Starts at 1 on insert, and gets +1 every time a near-duplicate is merged into this entry. It is the single input to the confidence auto-promotion above: reaching 3 promotes the entry to high confidence.

superseded_by — set only on a detected contradiction

Null while the entry is active. When a newer entry is judged to contradict this one (the principal changed their mind), this field is set to the new entry's id, and the row immediately drops out of all retrieval — search filters on superseded_by IS NULL. The old row is kept, not deleted, so the history of what was previously believed survives.

The read-time scores (computed, never stored)

Two numbers are computed on each /retrieve call and never written to the DB:

• relevance_score — cosine similarity of the question to the entry, clamped to [0,1] (1.0 = identical).
• final ranking score —

0.6 × relevance + 0.15 × type_weight + 0.15 × confidence_weight + 0.10 × freshness

• type_weight: framework 1.0, philosophy 0.9, standard 0.8, decision 0.7, reaction 0.5.
• confidence_weight: high 1.0, medium 0.7, low 0.4.
• freshness: the stability decay above.

Relevance leads at 0.6 so type and confidence act as tie-breakers among comparably-relevant entries — not overrides that let a generic-but-confident entry leapfrog a more-relevant one.