std::string kind; ///< decision | insight | note (see status::kKinds)

std::string text; ///< the ruling itself

std::string trigger; ///< "Use when ..." — future-query vocabulary

std::string rationale; ///< why; alternatives rejected ("" = NULL)

std::string scope; ///< what it does NOT apply to ("" = NULL)

std::string tags; ///< comma-separated, stored verbatim

std::string status = "current"; ///< current | provisional | pending

std::optional<int> supersedes; ///< decision_id this replaces

std::string session_guid; ///< source session GUID ("" = none)

std::string model_name; ///< producing model ("" = NULL model_id)

std::string source_timestamp; ///< historical created_at ("" = now)

std::vector<int> evidence; ///< turn_summary_ids backing the row

std::string text;

std::string model_name;

std::string session_guid;

int64_t span_start = 0;

int64_t span_end = 0;

std::vector<int> member_turn_summary_ids;

int id = 0; ///< new knowledge_id

std::string kind; ///< echoed kind of the stored row

std::optional<int> superseded; ///< knowledge_id flipped to 'superseded'

/// Flag-only hint (Phase 2 step 5): up to 3 OTHER active knowledge rows

/// (kind decision|insight) whose embedding cosine with the new row is

/// >= decision_supersede_threshold. Never a merge — the caller decides.

std::vector<std::pair<int,float>> possible_supersedes;

int id;

std::string text;

float score; // raw vector cosine similarity (reported score)

json metadata;

std::string timestamp;

// Per-signal ranking breakdown, captured for RAGGER_STATS instrumentation

// so each search type's contribution can be judged (tune/keep/drop a weight).

// Each *_score is the min-max-normalized [0,1] signal value that actually

// fed the weighted blend; a value of -1 means that signal was inactive for

// this search (bm25 disabled). `blended` is the final weighted ranking

// score (vector_weight*vec + bm25_weight*bm25). phon_score is retained at

// -1 for API/stats-schema compat only -- the old independent phonetic

// signal was folded into bm25_score by TextIndex::score_query() (v0.16;

// see fts_w_metaphone).

float vec_score = -1.0f;

float bm25_score = -1.0f;

float phon_score = -1.0f;

float blended = 0.0f;

std::string text;

std::string path;

std::string title;

std::string tags;

int year = 0;

int chunk_index = 0;

std::string imported_at;

std::string query;

std::vector<std::string> layers; ///< subset of turn|turn_summary|episode|summary|document|knowledge;

/// input aliases decision|insight accepted (PHASE7) = knowledge

/// restricted to that kind; empty = all

std::vector<std::string> kinds; ///< knowledge kinds filter (decision|insight|note); empty = all;

/// unknown kind -> invalid_argument

std::string since; ///< "YYYY-MM-DD", "YYYY-MM-DD HH:MM:SS", or relative "30d"/"12h"; "" = none

std::string until; ///< same formats; "" = none

std::string status = "active"; ///< knowledge only: "active" (current+provisional) | "any" | one exact status

std::string session; ///< only this session GUID

std::string exclude_session; ///< drop this session GUID

int limit = 10;

int max_tokens = 0; ///< 0 = no budget; else stop adding results past ~max_tokens (chars/4)

std::string id; ///< typed handle "<layer>:<rowid>"

std::string layer;

float score = 0;

std::string matched_by; ///< "vector" | "lexical" | "both"

std::string created; ///< local "YYYY-MM-DD HH:MM:SS"

std::string snippet; ///< first <=240 chars of text, cut at a word boundary, "…" appended if cut

json extra; ///< layer-specific: decision → {status, trigger}; summary → {level}; turn_summary → {turn_id, session}

std::vector<std::string> ids; ///< typed handles; mode 1

std::string expand = "none"; ///< none | context | sources | chain

std::string session; ///< mode 2: history range for this session GUID

int after_turn = 0; ///< mode 2: turns with turn_id > after_turn (0 = from start)

int before_turn = 0; ///< mode 2: turns with turn_id < before_turn (0 = to end)

int limit = 20; ///< mode 2 page size, clamped [1,100]

std::string session; ///< GUID; "" = all

std::string since, until; ///< same formats as AgentSearchQuery

std::string granularity = "episode"; ///< turn | episode | session

int limit = 20; ///< clamp [1,100]

std::string cursor; ///< opaque "<created_epoch>:<rowid>"; "" = newest first page

std::string id; ///< typed handle

std::optional<std::string> status;

std::optional<std::string> tags; ///< replaces the whole tag string

std::optional<std::string> text; ///< present => always rejected

int id;

std::string username;

// is_admin removed — sudo is the admin gate

std::string token_hash;

int summary_id;

std::string text;

std::string status;

std::string timestamp;

int turn_summary_id;

std::string summary_text; // L2 turn-summary text

std::string timestamp; // "%F %T" local-time string for store_episode

int64_t epoch; // created_at epoch seconds (for gap math)

std::vector<float> turn_embedding; // from turns.embedding

std::vector<float> summary_embedding;// from turn_summaries.embedding

std::string type;

std::string name;

std::string tbl_name;

std::string sql;

enum class Type { Null, Integer, Float, Text, Blob };

Type type = Type::Null;

int64_t int_val = 0;

double float_val = 0.0;

std::string text_val;

std::vector<uint8_t> blob_val;