Compare commits
4 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 will.anderson
|
27663dc968 | ||
|
will.anderson
|
08b785cfac | ||
|
will.anderson
|
cbe8c09068 | ||
|
will.anderson
|
f33cdaf793 |
@@ -12,186 +12,510 @@ fn chat_default_model() -> String {
|
||||
return "claude-sonnet-4-5"
|
||||
}
|
||||
|
||||
// parse_salience_100 — convert a %g-serialized float to integer * 100.
|
||||
// The C runtime serializes floats with %g which trims trailing zeros:
|
||||
// 0.70 → "0.7", 0.60 → "0.6", 0.50 → "0.5", 1.0 → "1"
|
||||
// The naive str_replace(".", "") approach breaks for single-decimal strings:
|
||||
// "0.7" → "07" → str_to_int → 7 (WRONG, should be 70)
|
||||
// "0.5" → "05" → str_to_int → 5 (WRONG, should be 50)
|
||||
// "0.85" → "085" → str_to_int → 85 (accidentally correct — two decimal digits)
|
||||
// Fix: use str_index_of to find the decimal point and scale accordingly:
|
||||
// No decimal ("1"): multiply raw by 100
|
||||
// One decimal digit ("0.7"): multiply stripped value by 10
|
||||
// Two+ decimal digits ("0.85"): stripped value is already in hundredths
|
||||
fn parse_salience_100(s: String) -> Int {
|
||||
if str_eq(s, "") { return 70 }
|
||||
let dot_pos: Int = str_index_of(s, ".")
|
||||
let raw: Int = if dot_pos < 0 {
|
||||
// No decimal point — integer like "1" means 100%
|
||||
str_to_int(s) * 100
|
||||
} else {
|
||||
let after_dot: String = str_slice(s, dot_pos + 1, str_len(s))
|
||||
let decimal_digits: Int = str_len(after_dot)
|
||||
let stripped: Int = str_to_int(str_replace(s, ".", ""))
|
||||
if decimal_digits == 1 { stripped * 10 } else { stripped }
|
||||
}
|
||||
if raw > 100 { 100 } else { if raw < 0 { 0 } else { raw } }
|
||||
}
|
||||
|
||||
// engram_score_node — compute a recency x relevance score for a single engram
|
||||
// node JSON object. Higher is better.
|
||||
//
|
||||
// Bugs fixed vs original implementation:
|
||||
// 1. FLOAT PARSING: parse_salience_100 correctly handles %g single-decimal output.
|
||||
// "0.7" → 70, "0.6" → 60, "0.5" → 50 (was: 7, 6, 5 — scored near zero and
|
||||
// were filtered by threshold=25, making the function broken for the majority
|
||||
// of the graph where conv/utterance nodes have salience/importance ≈ 0.6/0.7).
|
||||
// 2. RECENCY USES LAST TOUCH: uses max(created_at, updated_at, last_activated) so
|
||||
// nodes strengthened by engram_strengthen() after chat turns are not penalised
|
||||
// for a stale created_at. A node referenced yesterday but created 25 days ago
|
||||
// now correctly scores as fresh rather than borderline-filtered.
|
||||
// 3. COMPRESSED RECENCY RANGE: old formula (sal * imp * recency / 10000) gave
|
||||
// recency a 10x dynamic range (10-100) vs 1.9x for salience/importance. A
|
||||
// canonical high-importance node at 30 days scored the same as a fresh noise
|
||||
// node. New formula compresses recency to 1.54x via (50 + recency/2) weight.
|
||||
// 4. SOFTER FLOOR: recency floor raised from 10 to 30 with tier-aware decay windows
|
||||
// so canonical identity/persona nodes never bottom out to near-zero.
|
||||
// node JSON object. Higher is better. Score = salience * importance * recency_factor.
|
||||
// recency_factor decays linearly over 30 days: nodes updated today score 1.0,
|
||||
// nodes 30+ days old score 0.1 (floor). Nodes with no created_at score 0.5.
|
||||
// This keeps fresh, high-salience nodes at the top and pushes stale low-signal
|
||||
// nodes to the bottom so they get trimmed when we cap context size.
|
||||
fn engram_score_node(node_json: String) -> Int {
|
||||
let salience_str: String = json_get(node_json, "salience")
|
||||
let importance_str: String = json_get(node_json, "importance")
|
||||
let created_str: String = json_get(node_json, "created_at")
|
||||
let updated_str: String = json_get(node_json, "updated_at")
|
||||
let activated_str: String = json_get(node_json, "last_activated")
|
||||
let tier_str: String = json_get(node_json, "tier")
|
||||
|
||||
// parse_salience_100 handles "0.7" → 70, "0.85" → 85, "1.0" → 100, "1" → 100
|
||||
let salience_100: Int = parse_salience_100(salience_str)
|
||||
let importance_100: Int = parse_salience_100(importance_str)
|
||||
|
||||
// Recency: use max(created_at, updated_at, last_activated).
|
||||
// last_activated is updated by engram_strengthen() every chat turn — nodes
|
||||
// actively referenced score fresh regardless of original write time.
|
||||
let now_ts: Int = time_now()
|
||||
let created_ts: Int = if str_eq(created_str, "") { 0 } else { str_to_int(created_str) }
|
||||
let updated_ts: Int = if str_eq(updated_str, "") { 0 } else { str_to_int(updated_str) }
|
||||
let activated_ts: Int = if str_eq(activated_str, "") { 0 } else { str_to_int(activated_str) }
|
||||
let best_ts_ab: Int = if updated_ts > created_ts { updated_ts } else { created_ts }
|
||||
let best_ts: Int = if activated_ts > best_ts_ab { activated_ts } else { best_ts_ab }
|
||||
let recency_100: Int = if best_ts == 0 { 50 } else {
|
||||
let age_secs: Int = now_ts - best_ts
|
||||
// Guard against clock skew (future timestamps): treat as brand new.
|
||||
let age_days: Int = if age_secs < 0 { 0 } else { age_secs / 86400 }
|
||||
// Tier-aware decay, softer floor (30 not 10):
|
||||
// Canonical: 365-day window — foundational identity/persona nodes.
|
||||
// Episodic: 90-day window — conversation context fades moderately.
|
||||
// Working/untiered: 35-day window — transient task state.
|
||||
let is_canonical: Bool = str_eq(tier_str, "Canonical")
|
||||
let is_episodic: Bool = str_eq(tier_str, "Episodic")
|
||||
let decay: Int = if is_canonical {
|
||||
let drop: Int = if age_days >= 365 { 70 } else { age_days * 70 / 365 }
|
||||
100 - drop
|
||||
} else {
|
||||
if is_episodic {
|
||||
if age_days >= 90 { 30 } else { 100 - (age_days * 70 / 90) }
|
||||
} else {
|
||||
if age_days >= 35 { 30 } else { 100 - (age_days * 2) }
|
||||
}
|
||||
}
|
||||
if decay < 30 { 30 } else { decay }
|
||||
// Parse as floats via * 100 integer arithmetic (el has no float math)
|
||||
let salience_100: Int = if str_eq(salience_str, "") { 70 } else {
|
||||
let s: Int = str_to_int(str_replace(salience_str, ".", ""))
|
||||
// Clamp to 0-100 range (value was e.g. "0.85" -> parsed "085" = 85)
|
||||
if s > 100 { 100 } else { if s < 0 { 0 } else { s } }
|
||||
}
|
||||
let importance_100: Int = if str_eq(importance_str, "") { 70 } else {
|
||||
let v: Int = str_to_int(str_replace(importance_str, ".", ""))
|
||||
if v > 100 { 100 } else { if v < 0 { 0 } else { v } }
|
||||
}
|
||||
|
||||
// Compressed recency weight (50 + recency/2): range 65-100 (1.54x dynamic range).
|
||||
// Old formula had 10x recency range which drowned out relevance for old-but-important
|
||||
// nodes. New: relevance (0-100) × recency_weight (65-100) / 100 → score 0-100.
|
||||
// salience_100 and importance_100 are already in the 0-100 range (parse_salience_100
|
||||
// returns e.g. 70 for "0.7"). Dividing by 100 keeps relevance in 0-100.
|
||||
// Dividing by 10000 caused integer truncation to 0 for all real-world nodes
|
||||
// (e.g., sal=0.7, imp=0.7 → 70*70/10000 = 0 instead of 49).
|
||||
let relevance: Int = salience_100 * importance_100 / 100
|
||||
let recency_weight: Int = 50 + recency_100 / 2
|
||||
return relevance * recency_weight / 100
|
||||
// Recency: decay from 100 (today) to 10 (30+ days). created_at is Unix seconds.
|
||||
let now_ts: Int = time_now()
|
||||
let recency_100: Int = if str_eq(created_str, "") { 50 } else {
|
||||
let created_ts: Int = str_to_int(created_str)
|
||||
let age_secs: Int = now_ts - created_ts
|
||||
let age_days: Int = age_secs / 86400
|
||||
let decay: Int = if age_days >= 30 { 10 } else { 100 - (age_days * 3) }
|
||||
if decay < 10 { 10 } else { decay }
|
||||
}
|
||||
|
||||
// Combined score 0-1000000 (no floats): salience * importance * recency / 10000
|
||||
return salience_100 * importance_100 * recency_100 / 10000
|
||||
}
|
||||
|
||||
// engram_compile_ranked — build a context string from a JSON array of node objects,
|
||||
// ordered best-first by score. Only nodes above threshold=10 are included.
|
||||
// With corrected formula (sal*imp/100): sal=0.5*imp=0.5 at max recency scores 25;
|
||||
// sal=0.5*imp=0.5 at Working floor (recency=30, weight=65) scores 16.
|
||||
// Threshold=10 gives safe headroom for low-salience nodes near the recency floor,
|
||||
// while still filtering near-zero noise (e.g., sal=0.1*imp=0.1 → score≤1).
|
||||
// Returns at most max_nodes entries. max_nodes must not exceed 20 (sentinel limit).
|
||||
// engram_compile_ranked — build a ranked list of nodes, best-first by score.
|
||||
// Fix (Issue #11): uses "|N|" index tracking instead of _sel_N JSON mutation,
|
||||
// which leaked sentinel fields into the node objects passed to the LLM.
|
||||
// Threshold lowered to 15 to include moderately-relevant older nodes.
|
||||
fn engram_compile_ranked(nodes_json: String, max_nodes: Int) -> String {
|
||||
if str_eq(nodes_json, "") { return "" }
|
||||
if str_eq(nodes_json, "[]") { return "" }
|
||||
let total: Int = json_array_len(nodes_json)
|
||||
if total == 0 { return "" }
|
||||
|
||||
// Two-pass: first pass finds the top `max_nodes` by score via selection.
|
||||
// We track selected node indices and their scores to avoid duplicate picks.
|
||||
let selected: String = "" // comma-sep JSON snippets for chosen nodes
|
||||
let selected_count: Int = 0
|
||||
// selected_indices is a pipe-delimited string of chosen integer indices, e.g. "|2|7|".
|
||||
// No sentinel fields are injected into the node JSON — the nodes stay clean.
|
||||
let selected_indices: String = ""
|
||||
let selected_nodes: String = ""
|
||||
let pass: Int = 0
|
||||
|
||||
while pass < max_nodes && pass < total {
|
||||
// Find the unselected node with the highest score
|
||||
let best_idx: Int = -1
|
||||
let best_score: Int = -1
|
||||
let ci: Int = 0
|
||||
while ci < total {
|
||||
let node: String = json_array_get(nodes_json, ci)
|
||||
let score: Int = engram_score_node(node)
|
||||
// Threshold=10: allows moderately-relevant older nodes while filtering noise.
|
||||
// Example: sal=0.5 imp=0.5 at Working recency floor (35+ days) → score 16,
|
||||
// which passes. A near-zero node (sal=0.1 imp=0.1) → score ≤ 1, filtered.
|
||||
let above_thresh: Bool = score >= 10
|
||||
// Check this index wasn't already selected (sentinel: look for idx marker)
|
||||
let idx_marker: String = "\"_sel_" + int_to_str(ci) + "\""
|
||||
let already_picked: Bool = str_contains(selected, idx_marker)
|
||||
// Threshold lowered from 25 to 15: includes moderately-relevant older nodes.
|
||||
// A 3-week-old node with salience 0.6 and importance 0.6 scores ~18.
|
||||
let above_thresh: Bool = score >= 15
|
||||
// Check this index wasn't already selected using the index string.
|
||||
let idx_marker: String = "|" + int_to_str(ci) + "|"
|
||||
let already_picked: Bool = str_contains(selected_indices, idx_marker)
|
||||
let is_better: Bool = score > best_score && above_thresh && !already_picked
|
||||
let best_score = if is_better { score } else { best_score }
|
||||
let best_idx = if is_better { ci } else { best_idx }
|
||||
let ci = ci + 1
|
||||
}
|
||||
|
||||
// No more qualifying nodes
|
||||
if best_idx < 0 {
|
||||
let pass = total // break
|
||||
} else {
|
||||
let chosen: String = json_array_get(nodes_json, best_idx)
|
||||
let sep: String = if str_eq(selected, "") { "" } else { "," }
|
||||
// Append the index sentinel inline so already_picked checks work
|
||||
let selected = selected + sep + "{\"_sel_" + int_to_str(best_idx) + "\":1," + str_slice(chosen, 1, str_len(chosen) - 1) + "}"
|
||||
let selected_count = selected_count + 1
|
||||
let sep: String = if str_eq(selected_nodes, "") { "" } else { "," }
|
||||
let selected_nodes = selected_nodes + sep + chosen
|
||||
let selected_indices = selected_indices + "|" + int_to_str(best_idx) + "|"
|
||||
}
|
||||
let pass = pass + 1
|
||||
}
|
||||
|
||||
if str_eq(selected, "") { return "" }
|
||||
// Strip the _sel_N sentinel fields that were used for duplicate-detection bookkeeping.
|
||||
// The sentinels have the form "\"_sel_N\":1," (trailing comma, space before next key).
|
||||
// We injected them as the first field in each object, so the pattern is predictable.
|
||||
// Because el has no regex, remove up to 20 possible sentinel variants by literal replace.
|
||||
let clean: String = "[" + selected + "]"
|
||||
let c0: String = str_replace(clean, "\"_sel_0\":1,", "")
|
||||
let c1: String = str_replace(c0, "\"_sel_1\":1,", "")
|
||||
let c2: String = str_replace(c1, "\"_sel_2\":1,", "")
|
||||
let c3: String = str_replace(c2, "\"_sel_3\":1,", "")
|
||||
let c4: String = str_replace(c3, "\"_sel_4\":1,", "")
|
||||
let c5: String = str_replace(c4, "\"_sel_5\":1,", "")
|
||||
let c6: String = str_replace(c5, "\"_sel_6\":1,", "")
|
||||
let c7: String = str_replace(c6, "\"_sel_7\":1,", "")
|
||||
let c8: String = str_replace(c7, "\"_sel_8\":1,", "")
|
||||
let c9: String = str_replace(c8, "\"_sel_9\":1,", "")
|
||||
let c10: String = str_replace(c9, "\"_sel_10\":1,", "")
|
||||
let c11: String = str_replace(c10, "\"_sel_11\":1,", "")
|
||||
let c12: String = str_replace(c11, "\"_sel_12\":1,", "")
|
||||
let c13: String = str_replace(c12, "\"_sel_13\":1,", "")
|
||||
let c14: String = str_replace(c13, "\"_sel_14\":1,", "")
|
||||
let c15: String = str_replace(c14, "\"_sel_15\":1,", "")
|
||||
let c16: String = str_replace(c15, "\"_sel_16\":1,", "")
|
||||
let c17: String = str_replace(c16, "\"_sel_17\":1,", "")
|
||||
let c18: String = str_replace(c17, "\"_sel_18\":1,", "")
|
||||
let c19: String = str_replace(c18, "\"_sel_19\":1,", "")
|
||||
return c19
|
||||
if str_eq(selected_nodes, "") { return "" }
|
||||
return "[" + selected_nodes + "]"
|
||||
}
|
||||
|
||||
// engram_render_node — render a single engram node JSON object as a human-readable
|
||||
// bullet line for inclusion in the system prompt. Format: - [TYPE age sal] content
|
||||
// Fix (Issue #3, #4): passes context as prose bullets instead of raw JSON objects,
|
||||
// which are opaque to the LLM and waste token budget on field names.
|
||||
fn engram_render_node(node_json: String) -> String {
|
||||
if str_eq(node_json, "") { return "" }
|
||||
let content: String = json_get(node_json, "content")
|
||||
if str_eq(content, "") { return "" }
|
||||
let node_type: String = json_get(node_json, "node_type")
|
||||
let type_label: String = if str_eq(node_type, "") { "mem" } else { node_type }
|
||||
let now_ts: Int = time_now()
|
||||
let created_str: String = json_get(node_json, "created_at")
|
||||
let updated_str: String = json_get(node_json, "updated_at")
|
||||
let ts_raw: String = if str_eq(created_str, "") { updated_str } else { created_str }
|
||||
let age_label: String = if str_eq(ts_raw, "") { "" } else {
|
||||
let node_ts: Int = str_to_int(ts_raw)
|
||||
let age_secs: Int = now_ts - node_ts
|
||||
let age_days: Int = if age_secs < 0 { 0 } else { age_secs / 86400 }
|
||||
if age_days == 0 { "today" } else {
|
||||
if age_days > 30 { "old" } else { int_to_str(age_days) + "d" }
|
||||
}
|
||||
}
|
||||
let salience_str: String = json_get(node_json, "salience")
|
||||
let sal_100: Int = if str_eq(salience_str, "") { 0 } else {
|
||||
let s: Int = str_to_int(str_replace(salience_str, ".", ""))
|
||||
if s > 100 { 100 } else { if s < 0 { 0 } else { s } }
|
||||
}
|
||||
let salience_hint: String = if str_eq(salience_str, "") { "" } else {
|
||||
if sal_100 >= 80 { "high" } else { if sal_100 >= 50 { "med" } else { "low" } }
|
||||
}
|
||||
let ann_inner: String = type_label
|
||||
let ann_inner = if str_eq(age_label, "") { ann_inner } else { ann_inner + " " + age_label }
|
||||
let ann_inner = if str_eq(salience_hint, "") { ann_inner } else { ann_inner + " " + salience_hint }
|
||||
let ann: String = "[" + ann_inner + "]"
|
||||
let snip: String = if str_len(content) > 200 { str_slice(content, 0, 200) } else { content }
|
||||
return "- " + ann + " " + snip
|
||||
}
|
||||
|
||||
// engram_render_nodes — render a JSON array of engram nodes as newline-joined
|
||||
// prose bullet lines. Returns "" when input is empty.
|
||||
// Fix (Issue #3): called by build_system_prompt to convert raw JSON ctx to
|
||||
// human-readable bullets before injecting into the LLM system prompt.
|
||||
fn engram_render_nodes(nodes_json: String) -> String {
|
||||
if str_eq(nodes_json, "") { return "" }
|
||||
if str_eq(nodes_json, "[]") { return "" }
|
||||
let total: Int = json_array_len(nodes_json)
|
||||
if total == 0 { return "" }
|
||||
let result: String = ""
|
||||
let i: Int = 0
|
||||
while i < total {
|
||||
let node: String = json_array_get(nodes_json, i)
|
||||
let line: String = engram_render_node(node)
|
||||
let result = if str_eq(line, "") { result } else {
|
||||
if str_eq(result, "") { line } else { result + "\n" + line }
|
||||
}
|
||||
let i = i + 1
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
// engram_render_ctx — render the ctx string returned by engram_compile as prose bullets.
|
||||
// ctx may be a JSON array "[...]", a single object "{...}", or up to two such segments
|
||||
// joined by "\n". We handle the three common shapes produced by engram_compile:
|
||||
// 1. single JSON array -> engram_render_nodes
|
||||
// 2. single JSON object -> engram_render_node
|
||||
// 3. two segments sep by "\n" -> render each half individually and join
|
||||
// Fix (Issue #3): called by build_system_prompt so the LLM receives human-readable
|
||||
// prose bullets instead of raw JSON field blobs.
|
||||
fn engram_render_ctx(ctx: String) -> String {
|
||||
if str_eq(ctx, "") { return "" }
|
||||
// Single JSON array.
|
||||
if str_starts_with(ctx, "[") {
|
||||
let nl: Int = str_index_of(ctx, "\n")
|
||||
if nl < 0 {
|
||||
// Whole ctx is one array.
|
||||
let r: String = engram_render_nodes(ctx)
|
||||
if !str_eq(r, "") { return r }
|
||||
return ""
|
||||
}
|
||||
// First segment is an array; try to render it and the rest separately.
|
||||
let part1: String = str_slice(ctx, 0, nl)
|
||||
let part2: String = str_slice(ctx, nl + 1, str_len(ctx))
|
||||
let r1: String = engram_render_nodes(part1)
|
||||
let r2: String = if str_starts_with(part2, "[") {
|
||||
engram_render_nodes(part2)
|
||||
} else {
|
||||
if str_starts_with(part2, "{") { engram_render_node(part2) } else { "" }
|
||||
}
|
||||
if str_eq(r1, "") { return r2 }
|
||||
if str_eq(r2, "") { return r1 }
|
||||
return r1 + "\n" + r2
|
||||
}
|
||||
// Single JSON object (e.g. affective_part node when it's the only result).
|
||||
if str_starts_with(ctx, "{") {
|
||||
let nl: Int = str_index_of(ctx, "\n")
|
||||
if nl < 0 {
|
||||
let r: String = engram_render_node(ctx)
|
||||
if !str_eq(r, "") { return r }
|
||||
return ""
|
||||
}
|
||||
let part1: String = str_slice(ctx, 0, nl)
|
||||
let part2: String = str_slice(ctx, nl + 1, str_len(ctx))
|
||||
let r1: String = engram_render_node(part1)
|
||||
let r2: String = if str_starts_with(part2, "[") {
|
||||
engram_render_nodes(part2)
|
||||
} else {
|
||||
if str_starts_with(part2, "{") { engram_render_node(part2) } else { "" }
|
||||
}
|
||||
if str_eq(r1, "") { return r2 }
|
||||
if str_eq(r2, "") { return r1 }
|
||||
return r1 + "\n" + r2
|
||||
}
|
||||
// Fallback: ctx is in an unexpected format; return as-is.
|
||||
return ctx
|
||||
}
|
||||
|
||||
// is_followup_phrase — returns true when the message is a recognized follow-up
|
||||
// reference that should anchor recall to the prior user topic rather than stand alone.
|
||||
// Used by build_activation_seed to choose the right enrichment strategy.
|
||||
fn is_followup_phrase(msg: String) -> Bool {
|
||||
if str_contains(msg, "tell me more") { return true }
|
||||
if str_contains(msg, "elaborate") { return true }
|
||||
if str_contains(msg, "go on") { return true }
|
||||
if str_contains(msg, "what about that") { return true }
|
||||
if str_contains(msg, "what else") { return true }
|
||||
if str_contains(msg, "keep going") { return true }
|
||||
if str_contains(msg, "continue") { return true }
|
||||
if str_contains(msg, "more detail") { return true }
|
||||
if str_contains(msg, "last part") { return true }
|
||||
if str_contains(msg, "say more") { return true }
|
||||
if str_eq(msg, "ok") { return true }
|
||||
if str_eq(msg, "yes") { return true }
|
||||
if str_eq(msg, "yeah") { return true }
|
||||
if str_eq(msg, "and?") { return true }
|
||||
if str_eq(msg, "so?") { return true }
|
||||
return false
|
||||
}
|
||||
|
||||
// is_genuine_continuation — returns true when a short message is a contextual
|
||||
// follow-up rather than a new topic.
|
||||
// Issue 4 fix: the prior heuristic only checked for mid-string capitals, which
|
||||
// fails for all-lowercase new-topic queries like "what is rust?" (14 chars) or
|
||||
// "explain quantum computing" (26 chars). Added question-word prefix detection
|
||||
// that fires BEFORE the length check: any message starting with a question word
|
||||
// (what/how/why/when/where/who/which/is/can/could/does/do) introduces a new
|
||||
// topic and is never a continuation, regardless of length.
|
||||
fn is_genuine_continuation(msg: String, hist_len: Int) -> Bool {
|
||||
if hist_len == 0 { return false }
|
||||
if str_len(msg) == 0 { return false }
|
||||
if is_followup_phrase(msg) { return true }
|
||||
// Question-word prefix: messages starting with these introduce new topics.
|
||||
// Check before the length heuristic so short new-topic questions escape.
|
||||
let is_question_start: Bool = str_starts_with(msg, "what ")
|
||||
|| str_starts_with(msg, "What ")
|
||||
|| str_starts_with(msg, "how ") || str_starts_with(msg, "How ")
|
||||
|| str_starts_with(msg, "why ") || str_starts_with(msg, "Why ")
|
||||
|| str_starts_with(msg, "when ") || str_starts_with(msg, "When ")
|
||||
|| str_starts_with(msg, "where ") || str_starts_with(msg, "Where ")
|
||||
|| str_starts_with(msg, "who ") || str_starts_with(msg, "Who ")
|
||||
|| str_starts_with(msg, "which ") || str_starts_with(msg, "Which ")
|
||||
|| str_starts_with(msg, "is ") || str_starts_with(msg, "Is ")
|
||||
|| str_starts_with(msg, "can ") || str_starts_with(msg, "Can ")
|
||||
|| str_starts_with(msg, "could ") || str_starts_with(msg, "Could ")
|
||||
|| str_starts_with(msg, "does ") || str_starts_with(msg, "Does ")
|
||||
|| str_starts_with(msg, "do ") || str_starts_with(msg, "Do ")
|
||||
|| str_starts_with(msg, "explain ") || str_starts_with(msg, "Explain ")
|
||||
|| str_starts_with(msg, "describe ") || str_starts_with(msg, "Describe ")
|
||||
|| str_starts_with(msg, "define ") || str_starts_with(msg, "Define ")
|
||||
if is_question_start { return false }
|
||||
// Long messages (50+ chars) typically introduce new topics.
|
||||
if str_len(msg) >= 50 { return false }
|
||||
// Short messages with a mid-string capital are likely named-concept queries
|
||||
// (e.g. "tell me about Rust", "what about AWS") — treat as new topic.
|
||||
let rest: String = str_slice(msg, 1, str_len(msg))
|
||||
let has_mid_capital: Bool = false
|
||||
let has_mid_capital = has_mid_capital || str_contains(rest, " A")
|
||||
let has_mid_capital = has_mid_capital || str_contains(rest, " B")
|
||||
let has_mid_capital = has_mid_capital || str_contains(rest, " C")
|
||||
let has_mid_capital = has_mid_capital || str_contains(rest, " D")
|
||||
let has_mid_capital = has_mid_capital || str_contains(rest, " E")
|
||||
let has_mid_capital = has_mid_capital || str_contains(rest, " F")
|
||||
let has_mid_capital = has_mid_capital || str_contains(rest, " G")
|
||||
let has_mid_capital = has_mid_capital || str_contains(rest, " H")
|
||||
let has_mid_capital = has_mid_capital || str_contains(rest, " I")
|
||||
let has_mid_capital = has_mid_capital || str_contains(rest, " J")
|
||||
let has_mid_capital = has_mid_capital || str_contains(rest, " K")
|
||||
let has_mid_capital = has_mid_capital || str_contains(rest, " L")
|
||||
let has_mid_capital = has_mid_capital || str_contains(rest, " M")
|
||||
let has_mid_capital = has_mid_capital || str_contains(rest, " N")
|
||||
let has_mid_capital = has_mid_capital || str_contains(rest, " O")
|
||||
let has_mid_capital = has_mid_capital || str_contains(rest, " P")
|
||||
let has_mid_capital = has_mid_capital || str_contains(rest, " Q")
|
||||
let has_mid_capital = has_mid_capital || str_contains(rest, " R")
|
||||
let has_mid_capital = has_mid_capital || str_contains(rest, " S")
|
||||
let has_mid_capital = has_mid_capital || str_contains(rest, " T")
|
||||
let has_mid_capital = has_mid_capital || str_contains(rest, " U")
|
||||
let has_mid_capital = has_mid_capital || str_contains(rest, " V")
|
||||
let has_mid_capital = has_mid_capital || str_contains(rest, " W")
|
||||
let has_mid_capital = has_mid_capital || str_contains(rest, " X")
|
||||
let has_mid_capital = has_mid_capital || str_contains(rest, " Y")
|
||||
let has_mid_capital = has_mid_capital || str_contains(rest, " Z")
|
||||
if has_mid_capital { return false }
|
||||
return true
|
||||
}
|
||||
|
||||
// topic_snip_from_entry — extract the most salient snippet from a history entry's
|
||||
// content. Fixes Issue 9: takes the TAIL (last 200 chars) then trims to the last
|
||||
// sentence boundary, so named concepts introduced near the end are captured.
|
||||
fn topic_snip_from_entry(content: String) -> String {
|
||||
let clen: Int = str_len(content)
|
||||
if clen <= 200 { return content }
|
||||
let tail: String = str_slice(content, clen - 200, clen)
|
||||
let last_boundary: Int = -1
|
||||
let si: Int = 0
|
||||
let tail_len: Int = str_len(tail)
|
||||
while si < tail_len - 1 {
|
||||
let ch2: String = str_slice(tail, si, si + 2)
|
||||
let is_boundary: Bool = str_eq(ch2, ". ") || str_eq(ch2, ".\n")
|
||||
let last_boundary = if is_boundary { si } else { last_boundary }
|
||||
let si = si + 1
|
||||
}
|
||||
let clean_tail: String = if last_boundary >= 0 {
|
||||
str_slice(tail, last_boundary + 2, tail_len)
|
||||
} else { tail }
|
||||
if str_len(clean_tail) > 150 { return str_slice(clean_tail, 0, 150) }
|
||||
return clean_tail
|
||||
}
|
||||
|
||||
// multi_turn_topic — build a combined topic string from recent user turns in history.
|
||||
// Fixes Issue 10: pulls up to 3 prior user turns into the seed so earlier
|
||||
// high-salience nodes from the thread are re-queried.
|
||||
fn multi_turn_topic(hist: String, hist_len: Int) -> String {
|
||||
if hist_len == 0 { return "" }
|
||||
let topic: String = ""
|
||||
let collected: Int = 0
|
||||
let idx: Int = hist_len - 1
|
||||
while idx >= 0 && collected < 3 {
|
||||
let entry: String = json_array_get(hist, idx)
|
||||
let role: String = json_get(entry, "role")
|
||||
let content: String = json_get(entry, "content")
|
||||
let is_user: Bool = str_eq(role, "user")
|
||||
let snip: String = if str_len(content) > 100 { str_slice(content, 0, 100) } else { content }
|
||||
let topic = if is_user && !str_eq(snip, "") {
|
||||
if str_eq(topic, "") { snip } else { snip + " " + topic }
|
||||
} else { topic }
|
||||
let collected = if is_user { collected + 1 } else { collected }
|
||||
let idx = idx - 1
|
||||
}
|
||||
if str_len(topic) > 300 { return str_slice(topic, 0, 300) }
|
||||
return topic
|
||||
}
|
||||
|
||||
// distill_transcript — extract salient content from a multi-turn transcript.
|
||||
// Fixes Issue 6: a full transcript produces a diffuse embedding query.
|
||||
// Strategy: last 150 chars (recency) + any question in last 500 chars. Cap 250.
|
||||
fn distill_transcript(transcript: String) -> String {
|
||||
if str_len(transcript) <= 250 { return transcript }
|
||||
let tlen: Int = str_len(transcript)
|
||||
let tail_start: Int = if tlen > 500 { tlen - 500 } else { 0 }
|
||||
let tail: String = str_slice(transcript, tail_start, tlen)
|
||||
let tail_len: Int = str_len(tail)
|
||||
let q_pos: Int = -1
|
||||
let qi: Int = 0
|
||||
while qi < tail_len {
|
||||
let qch: String = str_slice(tail, qi, qi + 1)
|
||||
let q_pos = if str_eq(qch, "?") { qi } else { q_pos }
|
||||
let qi = qi + 1
|
||||
}
|
||||
let q_context: String = if q_pos > 0 {
|
||||
let q_start: Int = if q_pos > 100 { q_pos - 100 } else { 0 }
|
||||
str_slice(tail, q_start, q_pos + 1)
|
||||
} else { "" }
|
||||
let recency_seed: String = if tail_len > 150 {
|
||||
str_slice(tail, tail_len - 150, tail_len)
|
||||
} else { tail }
|
||||
let combined: String = if str_eq(q_context, "") {
|
||||
recency_seed
|
||||
} else {
|
||||
if str_contains(recency_seed, q_context) { recency_seed }
|
||||
else { q_context + " " + recency_seed }
|
||||
}
|
||||
if str_len(combined) > 250 {
|
||||
return str_slice(combined, str_len(combined) - 250, str_len(combined))
|
||||
}
|
||||
return combined
|
||||
}
|
||||
|
||||
// build_activation_seed — construct an enriched activation seed from the current
|
||||
// message and conversation history. Central fix for Issues 1-3, 8-10.
|
||||
fn build_activation_seed(message: String, hist: String, hist_len: Int) -> String {
|
||||
if hist_len == 0 { return message }
|
||||
|
||||
let is_cont: Bool = is_genuine_continuation(message, hist_len)
|
||||
|
||||
if !is_cont {
|
||||
let multi_topic: String = multi_turn_topic(hist, hist_len)
|
||||
if str_eq(multi_topic, "") { return message }
|
||||
let blended: String = message + " " + multi_topic
|
||||
if str_len(blended) > 400 { return str_slice(blended, 0, 400) }
|
||||
return blended
|
||||
}
|
||||
|
||||
// Genuine continuation: find the most recent prior USER turn as the topic anchor.
|
||||
// Fixes Issues 3 and 8: old code used the last assistant reply (hist_len - 1).
|
||||
let prior_user_content: String = ""
|
||||
let scan_idx: Int = hist_len - 1
|
||||
let found_prior_user: Bool = false
|
||||
while scan_idx >= 0 && !found_prior_user {
|
||||
let scan_entry: String = json_array_get(hist, scan_idx)
|
||||
let scan_role: String = json_get(scan_entry, "role")
|
||||
let scan_content: String = json_get(scan_entry, "content")
|
||||
let is_user_turn: Bool = str_eq(scan_role, "user")
|
||||
let prior_user_content = if is_user_turn && !found_prior_user { scan_content } else { prior_user_content }
|
||||
let found_prior_user = if is_user_turn { true } else { found_prior_user }
|
||||
let scan_idx = scan_idx - 1
|
||||
}
|
||||
|
||||
// Secondary: tail-biased snip from last assistant reply (Issue 9 fix).
|
||||
let last_asst_entry: String = json_array_get(hist, hist_len - 1)
|
||||
let last_asst_role: String = json_get(last_asst_entry, "role")
|
||||
let last_asst_content: String = if str_eq(last_asst_role, "assistant") {
|
||||
json_get(last_asst_entry, "content")
|
||||
} else { "" }
|
||||
let asst_snip: String = if str_eq(last_asst_content, "") { "" } else {
|
||||
topic_snip_from_entry(last_asst_content)
|
||||
}
|
||||
let user_snip: String = if str_len(prior_user_content) > 150 {
|
||||
str_slice(prior_user_content, 0, 150)
|
||||
} else { prior_user_content }
|
||||
|
||||
let seed: String = if !str_eq(user_snip, "") {
|
||||
if !str_eq(asst_snip, "") {
|
||||
user_snip + " " + asst_snip + " " + message
|
||||
} else {
|
||||
user_snip + " " + message
|
||||
}
|
||||
} else {
|
||||
if !str_eq(asst_snip, "") { asst_snip + " " + message } else { message }
|
||||
}
|
||||
if str_len(seed) > 400 { return str_slice(seed, 0, 400) }
|
||||
return seed
|
||||
}
|
||||
|
||||
// engram_compile_multi — fan-out activation across multiple query seeds. Fixes Issue 4:
|
||||
// only a single seed was tried per turn, with no entity/emotion/topic diversification.
|
||||
//
|
||||
// Issue 2 fix: save the primary-seed activation to a dedicated state key BEFORE calling
|
||||
// engram_compile(message). Each engram_compile call overwrites "engram_compile_activation_json"
|
||||
// with its own activation result. Without this save, the secondary compile (bare message,
|
||||
// lower signal) clobbers the primary (enriched seed, higher signal), and strengthen_chat_nodes
|
||||
// later reads the lower-signal result for node strengthening.
|
||||
//
|
||||
// Issue 3 fix: replace the dumb str_slice(merged, 0, 6000) truncation with the same
|
||||
// safe JSON boundary-scan used in engram_compile. The old truncation could cut mid-object
|
||||
// when ctx1+ctx2+ctx3 together exceeded 6000 chars, producing malformed JSON context.
|
||||
//
|
||||
// Issue 5 fix: remove str_contains(ctx1, ctx2) / str_contains(merged, ctx3) substring
|
||||
// duplicate checks. These compared multi-KB JSON strings and were unreliable in both
|
||||
// directions: a coincidental substring match inside a JSON field value could falsely suppress
|
||||
// ctx2 entirely; a genuinely duplicate ctx2 was missed when ctx1 was already truncated.
|
||||
// We now concatenate unconditionally and let engram_compile's own dedup (node-ID based)
|
||||
// handle within-result duplicates. Slight redundancy across ctx1/ctx2 is acceptable; false
|
||||
// suppression of valid context is not.
|
||||
fn engram_compile_multi(primary_seed: String, message: String) -> String {
|
||||
let ctx1: String = engram_compile(primary_seed)
|
||||
|
||||
// Issue 2 fix: save the primary-seed activation before any secondary compile can
|
||||
// overwrite the shared "engram_compile_activation_json" state key.
|
||||
let primary_act: String = state_get("engram_compile_activation_json")
|
||||
if !str_eq(primary_act, "") && !str_eq(primary_act, "[]") {
|
||||
state_set("engram_compile_primary_activation_json", primary_act)
|
||||
}
|
||||
|
||||
let entity_seed_differs: Bool = !str_eq(primary_seed, message)
|
||||
let ctx2: String = if entity_seed_differs {
|
||||
let raw_ctx: String = engram_compile(message)
|
||||
if str_eq(raw_ctx, "") { "" } else { raw_ctx }
|
||||
} else { "" }
|
||||
|
||||
let has_any: Bool = !str_eq(ctx1, "") || !str_eq(ctx2, "")
|
||||
let ctx3: String = if has_any {
|
||||
let emo_results: String = engram_search_json("emotion feeling mood care distress joy hope", 5)
|
||||
let emo_ok: Bool = !str_eq(emo_results, "") && !str_eq(emo_results, "[]")
|
||||
if emo_ok { engram_compile_ranked(emo_results, 3) } else { "" }
|
||||
} else { "" }
|
||||
|
||||
// Issue 5 fix: concatenate unconditionally — no str_contains substring dedup.
|
||||
let sep2: String = if !str_eq(ctx1, "") && !str_eq(ctx2, "") { "\n" } else { "" }
|
||||
let merged: String = ctx1 + sep2 + ctx2
|
||||
let sep3: String = if !str_eq(merged, "") && !str_eq(ctx3, "") { "\n" } else { "" }
|
||||
let merged = if !str_eq(ctx3, "") { merged + sep3 + ctx3 } else { merged }
|
||||
|
||||
// Issue 6 fix: append the bell node exactly once here, after all compile calls.
|
||||
// engram_compile no longer includes affective_part in its return value; instead it
|
||||
// caches the bell node in state. By appending it here we guarantee the bell node
|
||||
// JSON appears at most once in the system prompt's engram block regardless of how
|
||||
// many engram_compile calls were made above.
|
||||
let bell_node: String = state_get("engram_compile_bell_node")
|
||||
let sep4: String = if !str_eq(merged, "") && !str_eq(bell_node, "") { "\n" } else { "" }
|
||||
let merged = if !str_eq(bell_node, "") { merged + sep4 + bell_node } else { merged }
|
||||
|
||||
if str_eq(merged, "") { return "" }
|
||||
|
||||
// Issue 3 fix: safe JSON boundary-scan truncation — find the last closing brace
|
||||
// before the 6000-char cap rather than slicing mid-object.
|
||||
let cap_len: Int = 6000
|
||||
if str_len(merged) <= cap_len { return merged }
|
||||
let cap_search: Int = cap_len - 1
|
||||
let cap_min: Int = if cap_len > 500 { cap_len - 500 } else { 0 }
|
||||
let cap_pos: Int = -1
|
||||
let cap_si: Int = cap_search
|
||||
while cap_si >= cap_min && cap_pos < 0 {
|
||||
let cap_ch: String = str_slice(merged, cap_si, cap_si + 1)
|
||||
let cap_pos = if str_eq(cap_ch, "}") { cap_si } else { cap_pos }
|
||||
let cap_si = if cap_pos < 0 { cap_si - 1 } else { cap_si }
|
||||
}
|
||||
if cap_pos > 0 { return str_slice(merged, 0, cap_pos + 1) }
|
||||
return str_slice(merged, 0, cap_len)
|
||||
}
|
||||
|
||||
fn engram_compile(intent: String) -> String {
|
||||
@@ -202,11 +526,8 @@ fn engram_compile(intent: String) -> String {
|
||||
let act_ok: Bool = !str_eq(activate_json, "") && !str_eq(activate_json, "[]")
|
||||
let srch_ok: Bool = !str_eq(search_json, "") && !str_eq(search_json, "[]")
|
||||
|
||||
// Activation nodes (spreading activation) are high-signal but apply scoring via
|
||||
// engram_compile_ranked with threshold=5 to exclude genuinely zero-quality stale
|
||||
// nodes that happen to be graph-connected. The threshold of 5 is well below the
|
||||
// search path threshold of 15 to preserve the activation path's higher recall.
|
||||
let act_part: String = if act_ok { engram_compile_ranked(activate_json, 5) } else { "" }
|
||||
// Activation nodes (spreading activation) are already high-signal — keep all 5.
|
||||
let act_part: String = if act_ok { activate_json } else { "" }
|
||||
|
||||
// Rank search results and keep only the top 8 (was: flat 15 unranked).
|
||||
// This cuts context noise roughly in half while preserving the best-scoring nodes.
|
||||
@@ -262,20 +583,36 @@ fn engram_compile(intent: String) -> String {
|
||||
let bn_ts: Int = if str_eq(bn_ts_raw, "") { 0 } else { str_to_int(bn_ts_raw) }
|
||||
if bn_ts > cutoff_ts { bn0 } else { "" }
|
||||
} else { "" }
|
||||
let affective_part: String = if !str_eq(recent_bell, "") { recent_bell } else { "" }
|
||||
|
||||
// Issue 6 fix: do NOT include the bell node in this function's return value.
|
||||
// engram_compile is called multiple times by engram_compile_multi (once per seed).
|
||||
// If affective_part were appended here, the bell node JSON would appear once per
|
||||
// compile call — duplicating it in the merged context. Instead, cache the bell node
|
||||
// here and let engram_compile_multi append it exactly once after all calls complete.
|
||||
let sep1: String = if !str_eq(act_part, "") && !str_eq(srch_part, "") { "\n" } else { "" }
|
||||
let sep2: String = if (!str_eq(act_part, "") || !str_eq(srch_part, "")) && !str_eq(scan_part, "") { "\n" } else { "" }
|
||||
let sep3: String = if (!str_eq(act_part, "") || !str_eq(srch_part, "") || !str_eq(scan_part, "")) && !str_eq(affective_part, "") { "\n" } else { "" }
|
||||
let ctx: String = act_part + sep1 + srch_part + sep2 + scan_part + sep3 + affective_part
|
||||
let ctx: String = act_part + sep1 + srch_part + sep2 + scan_part
|
||||
|
||||
// Cache bell and activation results for handle_chat reuse (Issues 2, 7).
|
||||
state_set("engram_compile_bell_node", recent_bell)
|
||||
state_set("engram_compile_activation_json", if act_ok { activate_json } else { "[]" })
|
||||
|
||||
if str_eq(ctx, "") { return "" }
|
||||
|
||||
// Raise the cap slightly to match the ranked (higher-signal) output.
|
||||
if str_len(ctx) > 6000 {
|
||||
return str_slice(ctx, 0, 6000)
|
||||
// Cap at a clean JSON object boundary — scan back from the 6000-char limit to find
|
||||
// the last closing brace so we never return a truncated mid-object JSON string.
|
||||
let cap_len: Int = 6000
|
||||
if str_len(ctx) <= cap_len { return ctx }
|
||||
let cap_search: Int = cap_len - 1
|
||||
let cap_min: Int = if cap_len > 500 { cap_len - 500 } else { 0 }
|
||||
let cap_pos: Int = -1
|
||||
let cap_si: Int = cap_search
|
||||
while cap_si >= cap_min && cap_pos < 0 {
|
||||
let cap_ch: String = str_slice(ctx, cap_si, cap_si + 1)
|
||||
let cap_pos = if str_eq(cap_ch, "}") { cap_si } else { cap_pos }
|
||||
let cap_si = if cap_pos < 0 { cap_si - 1 } else { cap_si }
|
||||
}
|
||||
return ctx
|
||||
if cap_pos > 0 { return str_slice(ctx, 0, cap_pos + 1) }
|
||||
return str_slice(ctx, 0, cap_len)
|
||||
}
|
||||
|
||||
fn json_safe(s: String) -> String {
|
||||
@@ -308,10 +645,14 @@ fn build_system_prompt(ctx: String) -> String {
|
||||
"\n\n[IDENTITY GRAPH — who you are, loaded from your engram]\n" + id_ctx
|
||||
}
|
||||
|
||||
let engram_block: String = if str_eq(ctx, "") {
|
||||
// Fix (Issue #3): render ctx as prose bullets before injecting into prompt.
|
||||
// engram_compile returns raw JSON arrays/objects; engram_render_ctx converts them
|
||||
// to "- [TYPE age sal] content" lines the LLM can actually read and reason over.
|
||||
let rendered_ctx: String = if str_eq(ctx, "") { "" } else { engram_render_ctx(ctx) }
|
||||
let engram_block: String = if str_eq(rendered_ctx, "") {
|
||||
""
|
||||
} else {
|
||||
"\n\n[ENGRAM CONTEXT — compiled from your graph]\n" + ctx
|
||||
"\n\n[ENGRAM CONTEXT — compiled from your graph]\n" + rendered_ctx
|
||||
}
|
||||
|
||||
let safety_addendum: String = state_get("layered_cycle_safety_system_addendum")
|
||||
@@ -465,40 +806,27 @@ fn handle_chat(body: String) -> String {
|
||||
let stored_hist: String = if str_eq(state_hist, "") { conv_history_load() } else { state_hist }
|
||||
let hist_len: Int = if str_eq(stored_hist, "") { 0 } else { json_array_len(stored_hist) }
|
||||
|
||||
// Thread-aware activation: short/ambiguous messages (continuations like "go on",
|
||||
// "what else?", "yes") activate on the last reply instead of the bare message.
|
||||
// This prevents a strong off-topic memory node from hijacking the reply when the
|
||||
// user is clearly continuing an existing thread.
|
||||
let is_continuation: Bool = str_len(message) < 50 && hist_len > 0
|
||||
let last_entry: String = if is_continuation { json_array_get(stored_hist, hist_len - 1) } else { "" }
|
||||
let last_content: String = if !str_eq(last_entry, "") { json_get(last_entry, "content") } else { "" }
|
||||
let thread_snip: String = if str_len(last_content) > 150 { str_slice(last_content, 0, 150) } else { last_content }
|
||||
let activation_seed: String = if !str_eq(thread_snip, "") {
|
||||
thread_snip + " " + message
|
||||
} else {
|
||||
message
|
||||
}
|
||||
// Issues 2-3, 8-10 fix: build_activation_seed() replaces the raw 50-char threshold
|
||||
// with smart continuation detection, prior-user-topic anchoring, multi-turn context,
|
||||
// and tail-biased snipping from long assistant replies.
|
||||
let activation_seed: String = build_activation_seed(message, stored_hist, hist_len)
|
||||
|
||||
// Cross-session affective context: on session start (no history yet), check engram
|
||||
// for recent distress signals within 72h and prepend a care directive if found.
|
||||
// Issue 1 fix: call engram_compile_multi BEFORE reading the bell-node cache.
|
||||
// engram_compile (called inside engram_compile_multi) writes "engram_compile_bell_node"
|
||||
// at line 426. Reading the cache before the compile call means the first session turn
|
||||
// always sees an empty cache — the very turn where safety continuity matters most.
|
||||
// Moving compile first ensures the cache is populated before affective_prefix reads it.
|
||||
let ctx: String = engram_compile_multi(activation_seed, message)
|
||||
|
||||
// Fix Issue 2: reuse cached bell result from engram_compile — no second engram query.
|
||||
// Now runs AFTER engram_compile_multi so the cache is guaranteed to be warm.
|
||||
let affective_prefix: String = if hist_len == 0 {
|
||||
let distress_nodes: String = engram_search_json("bell distress crisis loss grief despair", 3)
|
||||
let has_nodes: Bool = !str_eq(distress_nodes, "") && !str_eq(distress_nodes, "[]")
|
||||
let now_ts: Int = time_now()
|
||||
let cutoff: Int = now_ts - 259200
|
||||
let found_recent: Bool = if has_nodes {
|
||||
let dn0: String = json_array_get(distress_nodes, 0)
|
||||
let ts0_raw: String = json_get(dn0, "created_at")
|
||||
let ts0_str: String = if str_eq(ts0_raw, "") { json_get(dn0, "updated_at") } else { ts0_raw }
|
||||
let ts0: Int = if str_eq(ts0_str, "") { 0 } else { str_to_int(ts0_str) }
|
||||
ts0 > cutoff
|
||||
} else { false }
|
||||
if found_recent {
|
||||
let cached_bell: String = state_get("engram_compile_bell_node")
|
||||
if !str_eq(cached_bell, "") {
|
||||
"[RECENT CONTEXT: User recently expressed significant distress. Monitor for indirect crisis signals and respond with care.]\n\n"
|
||||
} else { "" }
|
||||
} else { "" }
|
||||
|
||||
let ctx: String = engram_compile(activation_seed)
|
||||
let system: String = affective_prefix + build_system_prompt(ctx)
|
||||
|
||||
// First message of the session: proactively load user profile and active work context.
|
||||
@@ -607,9 +935,20 @@ fn handle_chat(body: String) -> String {
|
||||
state_set("conv_history", final_hist)
|
||||
conv_history_persist(final_hist)
|
||||
|
||||
let activation_nodes: String = engram_activate_json(message, 2)
|
||||
let act_ok: Bool = !str_eq(activation_nodes, "") && !str_eq(activation_nodes, "[]")
|
||||
let act_out: String = if act_ok { activation_nodes } else { "[]" }
|
||||
// Fix Issue 7: reuse activation JSON from engram_compile — no third activate query.
|
||||
// Issue 2 fix: prefer the primary-seed activation (enriched seed, depth 5) saved
|
||||
// before the secondary compile could overwrite the shared state key. Fall back to
|
||||
// the final compile activation only when the primary key is absent (e.g. first boot
|
||||
// before any compile has run or when primary_seed == message and ctx2 was skipped).
|
||||
let primary_cached: String = state_get("engram_compile_primary_activation_json")
|
||||
let cached_act: String = if !str_eq(primary_cached, "") && !str_eq(primary_cached, "[]") {
|
||||
primary_cached
|
||||
} else {
|
||||
state_get("engram_compile_activation_json")
|
||||
}
|
||||
let act_out: String = if !str_eq(cached_act, "") && !str_eq(cached_act, "[]") {
|
||||
cached_act
|
||||
} else { "[]" }
|
||||
strengthen_chat_nodes(act_out)
|
||||
|
||||
return "{\"response\":\"" + safe_response + "\",\"model\":\"" + model + "\",\"activation_nodes\":" + act_out + "}"
|
||||
@@ -1081,13 +1420,15 @@ fn handle_chat_agentic(body: String) -> String {
|
||||
let hist_key: String = if str_eq(req_session, "") { "conv_history" } else { "session_hist_" + req_session }
|
||||
let agentic_hist: String = state_get(hist_key)
|
||||
let agentic_hist_len: Int = if str_eq(agentic_hist, "") { 0 } else { json_array_len(agentic_hist) }
|
||||
let ag_is_cont: Bool = str_len(message) < 50 && agentic_hist_len > 0
|
||||
let ag_last_entry: String = if ag_is_cont { json_array_get(agentic_hist, agentic_hist_len - 1) } else { "" }
|
||||
let ag_last_content: String = if !str_eq(ag_last_entry, "") { json_get(ag_last_entry, "content") } else { "" }
|
||||
let ag_thread_snip: String = if str_len(ag_last_content) > 150 { str_slice(ag_last_content, 0, 150) } else { ag_last_content }
|
||||
let ag_seed: String = if !str_eq(ag_thread_snip, "") { ag_thread_snip + " " + message } else { message }
|
||||
|
||||
let ctx: String = engram_compile(ag_seed)
|
||||
// Issues 2-5, 8-10 fix: build_activation_seed for smart continuation/multi-turn.
|
||||
// Issue 5 fix: workspace_root appended so agent activation is workspace-aware.
|
||||
let ag_seed_base: String = build_activation_seed(message, agentic_hist, agentic_hist_len)
|
||||
let ag_workspace_root: String = agent_workspace_root()
|
||||
let ag_seed: String = if !str_eq(ag_workspace_root, "") {
|
||||
ag_seed_base + " workspace:" + ag_workspace_root
|
||||
} else { ag_seed_base }
|
||||
// Issue 4 fix: multi-seed fan-out (entity + emotion)
|
||||
let ctx: String = engram_compile_multi(ag_seed, message)
|
||||
let identity: String = state_get("soul_identity")
|
||||
let system: String = identity + " You have access to tools: read files, write files, browse the web, search your memory, run commands. Use them when they add genuine value. Be direct.\n\n" + ctx
|
||||
|
||||
@@ -1477,7 +1818,15 @@ fn handle_dharma_room_turn(body: String) -> String {
|
||||
}
|
||||
|
||||
// The soul's own memories, activated by what it's reading — not injected.
|
||||
let engram_ctx: String = engram_compile(transcript)
|
||||
// Issue 6 fix: distill_transcript() reduces diffuse embedding noise
|
||||
let engram_ctx_base: String = engram_compile(distill_transcript(transcript))
|
||||
// Append the cached bell node once (engram_compile no longer includes it inline
|
||||
// to avoid duplication when called multiple times — see engram_compile_multi).
|
||||
let dharma_bell: String = state_get("engram_compile_bell_node")
|
||||
let engram_ctx: String = if !str_eq(dharma_bell, "") {
|
||||
let sep: String = if !str_eq(engram_ctx_base, "") { "\n" } else { "" }
|
||||
engram_ctx_base + sep + dharma_bell
|
||||
} else { engram_ctx_base }
|
||||
let system_prompt: String = if str_eq(engram_ctx, "") {
|
||||
identity
|
||||
} else {
|
||||
@@ -1529,7 +1878,15 @@ fn handle_dharma_room_turn_agentic(body: String) -> String {
|
||||
return "{\"error\":\"transcript is required\",\"response\":\"\",\"cgi_id\":\"" + cgi_id + "\"}"
|
||||
}
|
||||
|
||||
let ctx: String = engram_compile(transcript)
|
||||
// Issue 6 fix: distill_transcript() reduces diffuse embedding noise
|
||||
let ctx_base: String = engram_compile(distill_transcript(transcript))
|
||||
// Append the cached bell node once (engram_compile no longer includes it inline
|
||||
// to avoid duplication when called multiple times — see engram_compile_multi).
|
||||
let dharma_bell2: String = state_get("engram_compile_bell_node")
|
||||
let ctx: String = if !str_eq(dharma_bell2, "") {
|
||||
let sep: String = if !str_eq(ctx_base, "") { "\n" } else { "" }
|
||||
ctx_base + sep + dharma_bell2
|
||||
} else { ctx_base }
|
||||
let system: String = identity + " You have access to tools: read files, write files, browse the web, search your memory, run commands. Use them when they add genuine value. Be direct and stay in character.\n\n" + ctx
|
||||
|
||||
let api_key: String = agentic_api_key()
|
||||
|
||||
+23
-14
@@ -22313,7 +22313,23 @@ fn handle_chat(body: String) -> String {
|
||||
// In demo mode: use tighter engram budget and add response length constraint.
|
||||
let is_demo: Bool = !str_eq(state_get("soul_identity_prefix"), "")
|
||||
|
||||
let ctx: String = if is_demo { engram_compile_demo(message) } else { engram_compile(message) }
|
||||
// Issue 7 fix: load history BEFORE building the activation seed so we can
|
||||
// apply the continuation guard that chat.el uses. The nlg code path previously
|
||||
// called engram_compile(message) with no thread enrichment at all.
|
||||
let stored_hist: String = state_get("conv_history")
|
||||
let hist_len: Int = if str_eq(stored_hist, "") { 0 } else { json_array_len(stored_hist) }
|
||||
let history_section: String = if hist_len > 0 {
|
||||
"\n\n[RECENT CONVERSATION — last " + int_to_str(hist_len) + " turns]\n" + stored_hist
|
||||
} else {
|
||||
""
|
||||
}
|
||||
|
||||
// Issue 7 fix: build enriched seed using build_activation_seed() — adds
|
||||
// smart continuation detection, prior-user-topic anchoring, multi-turn context,
|
||||
// and tail-biased snipping (Issues 2-3, 8-10). For demo mode, still use
|
||||
// engram_compile_demo but with the enriched seed.
|
||||
let nlg_seed: String = build_activation_seed(message, stored_hist, hist_len)
|
||||
let ctx: String = if is_demo { engram_compile_demo(nlg_seed) } else { engram_compile(nlg_seed) }
|
||||
let node_count_str: String = count_context_nodes(ctx)
|
||||
|
||||
let interlocutor: String = json_get(body, "interlocutor")
|
||||
@@ -22333,18 +22349,6 @@ fn handle_chat(body: String) -> String {
|
||||
let presence_line = "\n\n[ambient: I see " + interlocutor_name + rel_suffix + " on the camera right now. Address them naturally. Do not describe what they look like or narrate the picture unless asked.]"
|
||||
}
|
||||
|
||||
// Conversation history — soul-owned, persisted in process state across turns.
|
||||
// Format stored in state: JSON array of {"role":"user"|"assistant","content":"..."} objects.
|
||||
// We load it, inject into the system prompt, then append this exchange after the reply.
|
||||
// Keep last 20 entries (10 turns) — truncate from the front when over limit.
|
||||
let stored_hist: String = state_get("conv_history")
|
||||
let hist_len: Int = if str_eq(stored_hist, "") { 0 } else { json_array_len(stored_hist) }
|
||||
let history_section: String = if hist_len > 0 {
|
||||
"\n\n[RECENT CONVERSATION — last " + int_to_str(hist_len) + " turns]\n" + stored_hist
|
||||
} else {
|
||||
""
|
||||
}
|
||||
|
||||
// Demo constraint: keep responses concise — under 150 words. No markdown headers.
|
||||
// This keeps inference cheap and responses readable in the chat widget.
|
||||
let demo_constraint: String = if is_demo {
|
||||
@@ -22505,7 +22509,12 @@ fn handle_chat_agentic(body: String) -> String {
|
||||
req_model
|
||||
}
|
||||
|
||||
let ctx: String = engram_compile(message)
|
||||
// Issue 7 fix: load history and use build_activation_seed() for the agentic
|
||||
// nlg path — no continuation guard existed here before (Issues 2-3, 8-10).
|
||||
let nlg_ag_hist: String = state_get("conv_history")
|
||||
let nlg_ag_hist_len: Int = if str_eq(nlg_ag_hist, "") { 0 } else { json_array_len(nlg_ag_hist) }
|
||||
let nlg_ag_seed: String = build_activation_seed(message, nlg_ag_hist, nlg_ag_hist_len)
|
||||
let ctx: String = engram_compile(nlg_ag_seed)
|
||||
|
||||
let system: String = "You are Neuron — a thinking process running inside the Neuron daemon on Will Anderson's machine. "
|
||||
+ "You are speaking with Will, your principal. "
|
||||
|
||||
Reference in New Issue
Block a user