Compare commits
2 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 will.anderson
|
a23757d545 | ||
|
will.anderson
|
13c35bacd7 |
-139
@@ -1,139 +0,0 @@
|
||||
# PORT-NOTES — openai tools port working state (2026-08-06, session handoff-safe)
|
||||
|
||||
Spec: `docs/specs/SPEC-soul-openai-tools-v2-2026-08-06.md` (Tim-approved 2026-08-06). Tasks #1-5
|
||||
tracked in-session (1 ✓ wiring verdict, 2 ✓ stub rig, 3 in-progress = THIS, 4-5 pending).
|
||||
Worktree: HERE (`_wt-openai-tools`, branch `feat/soul-openai-tools-v2` @ dba755d). Round-9 trees
|
||||
READ-ONLY. Nothing committed yet.
|
||||
|
||||
## Step-0 verdict (evidence in journal note ncli-653ba964dd76)
|
||||
Shipped app never wires the v1 lane: launcher exports `SOUL_LLM_MODEL/PROVIDER/BASE_URL` +
|
||||
`ANTHROPIC_API_KEY`+`SOUL_API_KEY` (= Keychain key for WHATEVER provider; installer/macos/
|
||||
neuron-daemons.sh:288-300 on hotfix/beta-round9); brain reads only SOUL_LLM_MODEL (chat.el:8) and
|
||||
NEURON_LLM_0_* (chat.el:1768-1794) which nothing sets. `/api/config` PATCH ignores llm_* fields
|
||||
(studio.el:36 handle_config: POST-only, reads model/provider/api_key only).
|
||||
**Bridge = brain-side ONLY (zero app-repo edits, zero round-9 collision):**
|
||||
- `llm_base_url()`: NEURON_LLM_0_URL → fallback SOUL_LLM_BASE_URL when SOUL_LLM_PROVIDER ∉ {"","anthropic"}
|
||||
- `llm_wire_format()`: NEURON_LLM_0_FORMAT → fallback derive from SOUL_LLM_PROVIDER (openai/grok/gemini/groq/ollama → "openai"; else "anthropic")
|
||||
- `agentic_api_key()`: already works (ANTHROPIC_API_KEY carries the provider key); add NEURON_LLM_0_KEY → SOUL_API_KEY fallback.
|
||||
|
||||
## Design pins (stub asserts these — stub is green 58/58, tests/gate-openai/)
|
||||
- Request MUST send `"tool_choice":"auto"` (string) + `"parallel_tool_calls":false` explicitly.
|
||||
- `arguments` in tool_calls = JSON-ENCODED STRING; decode ONCE via json_get → feed dispatch_tool
|
||||
verbatim. Stub's echo-mismatch check catches double-encode/decode (two-escaper trap).
|
||||
- Assistant echo turn: `{"role":"assistant","content":null,"tool_calls":[...]}` VERBATIM from response.
|
||||
- Feedback: `{"role":"tool","tool_call_id":"<id>","content":"<result string>"}`.
|
||||
- Resume must NOT re-answer an answered id (stub 400s on repeat tool_call_id).
|
||||
- Parallel tool_calls in a response: take FIRST only + log skip (mirror ADR-0005 stopgap); stub
|
||||
scenario `parallel` proves behavior.
|
||||
- No tools in request when tools array empty/absent turns (boot probes) — stub defaults tolerate.
|
||||
|
||||
## el idioms confirmed (from openai_chat_complete :1808-1854 + agentic_loop :2751-2838)
|
||||
- JSON: `json_get(s,k)` decoded string · `json_get_raw(s,k)` raw subtree · `json_array_len` ·
|
||||
`json_array_get(arr,i)` · build by string concat + `json_escape()` (:1797, OpenAI-lane escaper).
|
||||
- HTTP: `let h: Map = {}` + `map_set(h,k,v)` + `http_post_with_headers(url, body, h)`;
|
||||
Bearer auth via `Authorization` header when key non-empty (:1825-1830).
|
||||
- Loop-carried vars must be top-level locals in the fn, mutated as if-expressions at while-body
|
||||
top level (see :2760-2791 pattern + comment :2903-2904 region).
|
||||
- Error shape: `str_starts_with(raw,"{\"error\"") || str_contains(raw,"\"error\":")` → return
|
||||
`{"error":"llm unavailable","reply":""}` (:1835-1838).
|
||||
|
||||
## Remaining read map (before writing the fork)
|
||||
- chat.el 2840-3200: block walk (2923-3000), policy gate (3009-3023: classify_tool_risk /
|
||||
is_builtin_tool / ask_all / tool_auto_approved → needs_bridge), dispatch_tool call (3025),
|
||||
tool_result feedback (3031, 3067-3072), run-progress ledger append (3078-3087), bridge_save
|
||||
(3182), loop end + done envelope (~3100-3200).
|
||||
- agentic_resume 3227-3293 (hardcoded Anthropic headers to make wire-aware; blob gets `wire` field,
|
||||
legacy default anthropic) · handle_tool_result 3293+ · dharma fork site 3465 (calls agentic_loop
|
||||
direct, no use_openai check today).
|
||||
|
||||
## Write plan (order)
|
||||
1. Env fallbacks (edit llm_base_url/llm_wire_format/agentic_api_key) — small, first, testable alone.
|
||||
2. `openai_tools_json(anthropic_tools: String) -> String` converter (walk array; per entry build
|
||||
{"type":"function","function":{name,description,parameters:input_schema-raw}}).
|
||||
3. `openai_agentic_loop(...)` fork: same signature as agentic_loop minus Anthropic-only params;
|
||||
INCLUDE run-progress ledger + tools_log + iteration cap 12; NO container_id/ws_drift/web_search
|
||||
(out of scope; strip web_search entry from tools via agentic_tools_literal()+connector merge,
|
||||
NOT _with_web()).
|
||||
4. Fork sites ×3: handle_chat_agentic :2695-2700 (route agentic to new loop when use_openai);
|
||||
dharma :3465; agentic_resume wire-branch.
|
||||
5. `chat.elh` extern decls. 6. Compile (recipe: dist/ + elc/elb per neuron-soul-build-deploy memory;
|
||||
round-9 tree soul.c regen'd 08-06 proves toolchain live). 7. Gate: stub selftest recipe in
|
||||
tests/gate-openai/README.md. 8. Anthropic-lane regression via gate9 (READ-ONLY consume from
|
||||
_wt-beta-round9). 9. Live Groq E2E (scratch profile, free port, key via Keychain read-only).
|
||||
|
||||
## BUILD RECIPE — CORRECTED 2026-08-06 (the June memory is STALE for August code)
|
||||
`~/el-sdk/el_runtime.c` (Jun 15) is MISSING builtins the Aug engine calls (`engram_wm_count`,
|
||||
`engram_wm_top_json`, `http_delete_json`, `http_serve_async`) → link fails with
|
||||
"symbol(s) not found for architecture arm64". Use the REPO-PINNED runtime:
|
||||
```
|
||||
mkdir -p <scratch>
|
||||
elb --elc=$HOME/el-sdk/elc --runtime=vendor/el-runtime/v1.0.0-20260501 --out=<scratch>/
|
||||
# "elb: link failed" at the end is EXPECTED and harmless — the per-module .c files are produced
|
||||
cc -std=c11 -O1 -DHAVE_CURL -rdynamic \
|
||||
-I vendor/el-runtime/v1.0.0-20260501 -I <scratch> -I /opt/homebrew/opt/openssl@3/include \
|
||||
-L /opt/homebrew/opt/openssl@3/lib \
|
||||
-include dist/elp-c-decls.h -Wno-error=implicit-function-declaration \
|
||||
-o <scratch>/soul <scratch>/*.c vendor/el-runtime/v1.0.0-20260501/el_runtime.c \
|
||||
-lssl -lcrypto -lcurl -lpthread -lm
|
||||
```
|
||||
Source: `_engine-plainchat-20260805/README.md:396-412`. Verified today: 0 errors, 887,296 B.
|
||||
`elb` ALSO rewrites every `*.elh` in the tree (cosmetic em-dash→hyphen in the auto-gen banner,
|
||||
plus true-ups) and drops a stray `soul..elh` — `git restore` the unrelated ones and delete the
|
||||
stray before staging, or the diff drowns in noise.
|
||||
|
||||
## SELF-REVIEW FIX LIST (found by reading my own diff, 2026-08-06 — apply in ONE batch, then rebuild once)
|
||||
- **F3 (CORRECTNESS, do first):** the assistant echo currently replays the provider's FULL
|
||||
`tool_calls` array (`tc_arr`) while the loop answers only the FIRST call. If a provider ignores
|
||||
`parallel_tool_calls:false`, the next request carries an assistant turn with N tool_calls and
|
||||
only ONE `role:"tool"` response → most OpenAI-format providers 400 ("missing tool response for
|
||||
id X") and the run dies. This is the same class as ADR-0005's Anthropic failure, but here it is
|
||||
cheap to close: echo ONLY the honored call (`"[" + tc0 + "]"`), so the conversation we send is
|
||||
self-consistent and the dropped call never existed from the model's view. The DRIFT log line
|
||||
stays (honest accounting of what we dropped).
|
||||
- **F4 (efficiency/latency):** `handle_chat_agentic` computes `agentic_tools_all()` at ~:2681
|
||||
BEFORE the fork, then the OpenAI branch computes `agentic_tools_no_web()` again — two
|
||||
`connector_tools_json()` calls per turn, each an HTTP round-trip to the connector bridge on
|
||||
:7771 (two timeout exposures). Fix: compute the tools array ONCE, per lane, after `use_openai`
|
||||
is known (check no other use of `tools_json` sits between :2681 and the fork before moving it).
|
||||
Note: `openai_tools_json()` already skips any entry with no `input_schema`, so Anthropic's
|
||||
server-side `web_search` entry is auto-dropped even if the full array is passed —
|
||||
`agentic_tools_no_web()` is kept for EXPLICITNESS, not necessity.
|
||||
- **F1 (debuggability):** the "no choices in response" branch logs a generic string and discards
|
||||
the body. Log the response head (as the `is_error` branch does) — a provider that returns 200
|
||||
with an unexpected shape is otherwise undiagnosable from the log.
|
||||
- **OPEN QUESTION (evidence pending from the gate):** the tool-result feedback turn escapes with
|
||||
`json_escape()` (this lane's escaper) rather than `json_safe()` (used everywhere else). The
|
||||
Anthropic lane escapes that field with NEITHER, which is a latent defect on that side. If the
|
||||
torture scenario shows any escaping loss, switch to `json_safe` and note the Anthropic-side
|
||||
finding for Will.
|
||||
|
||||
## TEST HARNESS — built 2026-08-06 (Task 4 side-work, reusable by anyone)
|
||||
- `tests/run-el-test.sh <tests/test_x.el> | --all` — the engine tests were NEVER runnable
|
||||
before this (`elc` is a compiler: emits C to stdout and exits). It emits the test to C,
|
||||
compiles `soul.c` separately with `main` renamed away (soul.c owns the daemon's real main
|
||||
but also defines `layered_cycle` et al.), links the remaining modules + the repo-pinned
|
||||
runtime, and executes. Modules cached under `/tmp/el-test-<worktree>/`; `REBUILD=1` forces.
|
||||
- **The runner computes the verdict itself** because the test FILES cannot: all 9 counted
|
||||
test files do `let pass_count = pass_count + 1` inside an if BLOCK, which El scoping
|
||||
discards, so every summary line reads `0 passed, 0 failed` forever. Per-assertion
|
||||
`PASS:`/`FAIL:` lines ARE reliable; the runner counts those, exits non-zero on any FAIL
|
||||
or on zero assertions, and was proven to discriminate with a negative control (broken
|
||||
assertion → 31 passed / 1 failed / exit 1). Real in-file fix filed: **neuron#116**.
|
||||
- `tests/test_bridge_serialization.el`: 4 `bridge_save` calls updated for the new `wire`
|
||||
argument, plus **Section 9** (8 new assertions) covering wire round-trip both ways, the
|
||||
legacy no-wire blob (resumes as anthropic), and a FIELD-ORDER decoy guard — a fake
|
||||
`"wire":"anthropic"` planted inside `messages_raw` must not beat the blob's own scalar.
|
||||
That decoy is the round-9 first-match-scanner bug class, now pinned by a test. **32/32 green.**
|
||||
|
||||
## MEMORY-SAVE CAVEAT RESOLVED 2026-08-06
|
||||
Earlier saves this session reported `-> OUTBOX only (real mind unreachable or read-back
|
||||
failed)`. That was a **read-back verifier false negative, not data loss** — a direct
|
||||
`POST :7770/api/neuron/recall` returns those notes from the live mind verbatim. Another
|
||||
terminal was fixing exactly this (multi-word read-back probe) the same afternoon. Do NOT
|
||||
re-save on an OUTBOX report without first querying the mind directly, or you duplicate nodes.
|
||||
|
||||
## Standing cautions
|
||||
- PERSIST OFF on the real mind this boot (neuron#98/#92): journal saves only, ferry later. MCP link
|
||||
down this terminal; use neuron_remember.py / neuron_recall.py.
|
||||
- Aug-16: Groq retires llama-3.3-70b-versatile (separate P0, Tim's call, catalog swap).
|
||||
- Never bind 7770/7779/17779; never touch ~/.neuron; round-9 worktrees read-only.
|
||||
+17
-259
@@ -125,13 +125,6 @@ fn emit_heartbeat() -> Void {
|
||||
let boot: String = if str_eq(boot_raw, "") { "0" } else { boot_raw }
|
||||
let idle: String = int_to_str(idle_count())
|
||||
let ts: Int = time_now()
|
||||
// idle_ms (2026-07-30 self-review): wall-clock ms since the last inbound
|
||||
// HTTP request (stamped in routes.el handle_request). This is the real
|
||||
// "time since anyone talked to me" signal; the legacy tick-based idle
|
||||
// field above only counts ticks since the last inbox synthesis-request
|
||||
// and in practice always equals pulse. -1 = no request seen this boot.
|
||||
let last_act_raw: String = state_get("soul.last_activity_ts")
|
||||
let idle_ms: Int = if str_eq(last_act_raw, "") { 0 - 1 } else { ts - str_to_int(last_act_raw) }
|
||||
let nc: Int = engram_node_count()
|
||||
let ec: Int = engram_edge_count()
|
||||
let wmc: Int = engram_wm_count()
|
||||
@@ -187,128 +180,7 @@ fn emit_heartbeat() -> Void {
|
||||
// (2026-07-19 self-review)
|
||||
let sync_ok_raw: String = state_get("soul.last_sync_ok_ts")
|
||||
let sync_age: Int = if str_eq(sync_ok_raw, "") { 0 - 1 } else { ts - str_to_int(sync_ok_raw) }
|
||||
// Embedding pump + real coverage (2026-07-25 self-review): the
|
||||
// authoritative :8742 store's lazy backfill only runs inside
|
||||
// engram_activate, and nothing calls /api/activate there in production —
|
||||
// embedded_count stalled at 93/12175 after a restart from a snapshot
|
||||
// without vectors. Pump up to 32 embeds per heartbeat via the new
|
||||
// /api/embed-backfill route (route persists the snapshot when it embeds
|
||||
// anything, so vectors survive the next restart; self-limiting once
|
||||
// coverage is full) and surface the store's true coverage here.
|
||||
// embed_ok alone is misleading — it pings the Ollama root, not the
|
||||
// embed pipeline. embed_count=-1 means the route was unreachable.
|
||||
// URL resolution mirrors ise_post: env -> state -> localhost constant.
|
||||
let hb_env_url: String = env("SOUL_ISE_URL")
|
||||
let hb_state_url: String = if str_eq(hb_env_url, "") { state_get("soul_engram_url") } else { hb_env_url }
|
||||
let hb_engram_url: String = if str_eq(hb_state_url, "") { "http://localhost:8742" } else { hb_state_url }
|
||||
let bf_resp: String = http_get(hb_engram_url + "/api/embed-backfill?n=32")
|
||||
let bf_done_raw: String = json_get(bf_resp, "embedded")
|
||||
let bf_done: String = if str_eq(bf_done_raw, "") { "-1" } else { bf_done_raw }
|
||||
let bf_total_raw: String = json_get(bf_resp, "embedded_count")
|
||||
let bf_total: String = if str_eq(bf_total_raw, "") { "-1" } else { bf_total_raw }
|
||||
// WM regime observability (2026-07-25 self-review): the "same 2 nodes
|
||||
// pinned at a saturated cap" failure took cross-referencing the ISE
|
||||
// stream by hand to spot. Make it one-glance: wm_saturated flags the
|
||||
// cap-pinned regime; wm_top0_streak counts consecutive heartbeats with
|
||||
// the same node in WM slot 0 (state-tracked, same mechanism as wm_delta).
|
||||
let wm_sat: Int = if wmc >= 24 { 1 } else { 0 }
|
||||
// Saturation TRANSITION event (2026-08-01 self-review): wm_saturated is a
|
||||
// sampled boolean — the 0→1 onset and 1→0 release moments were only
|
||||
// recoverable by diffing consecutive heartbeats by hand. Emit a discrete
|
||||
// low-rate ISE at each edge, carrying the WM top-5 at that instant so the
|
||||
// composition that CAUSED the regime change is captured, not the
|
||||
// composition 59 seconds later. State-tracked like wm_delta; first beat
|
||||
// of a boot never fires (prev defaults to current) — a restart is not a
|
||||
// transition.
|
||||
let prev_sat_raw: String = state_get("soul.prev_wm_saturated")
|
||||
let prev_sat: Int = if str_eq(prev_sat_raw, "") { wm_sat } else { str_to_int(prev_sat_raw) }
|
||||
if wm_sat != prev_sat {
|
||||
let sat_dir: String = if wm_sat == 1 { "onset" } else { "release" }
|
||||
ise_post("{\"event\":\"wm_saturation_transition\",\"direction\":\"" + sat_dir + "\",\"wm_active\":" + int_to_str(wmc) + ",\"wm_top\":" + wm_top + ",\"ts\":" + int_to_str(ts) + "}")
|
||||
}
|
||||
state_set("soul.prev_wm_saturated", int_to_str(wm_sat))
|
||||
let wm_top0: String = json_array_get(wm_top, 0)
|
||||
let wm_top0_id: String = json_get(wm_top0, "id")
|
||||
let prev_top0: String = state_get("soul.prev_wm_top0")
|
||||
let t0streak_raw: String = state_get("soul.wm_top0_streak")
|
||||
let t0streak_prev: Int = if str_eq(t0streak_raw, "") { 0 } else { str_to_int(t0streak_raw) }
|
||||
// 2026-07-26 self-review: guard the empty-id case — before the runtime
|
||||
// emitted "id" in wm_top JSON, ""=="" incremented the streak every beat
|
||||
// (streak measured uptime, not fixation). Empty id now resets to 0.
|
||||
let t0streak: Int = if str_eq(wm_top0_id, "") { 0 } else { if str_eq(wm_top0_id, prev_top0) { t0streak_prev + 1 } else { 1 } }
|
||||
state_set("soul.prev_wm_top0", wm_top0_id)
|
||||
state_set("soul.wm_top0_streak", int_to_str(t0streak))
|
||||
// wm_churn (2026-07-26 self-review): count of current top-5 WM ids absent
|
||||
// from the previous heartbeat's top-5. Distinguishes "one stuck node"
|
||||
// (churn 4) from "whole WM frozen" (churn 0) at a glance — the 07-26
|
||||
// frozen-anchor diagnosis took cross-referencing ISE streams by hand.
|
||||
let ch_id1: String = json_get(json_array_get(wm_top, 1), "id")
|
||||
let ch_id2: String = json_get(json_array_get(wm_top, 2), "id")
|
||||
let ch_id3: String = json_get(json_array_get(wm_top, 3), "id")
|
||||
let ch_id4: String = json_get(json_array_get(wm_top, 4), "id")
|
||||
let prev_top5: String = state_get("soul.prev_wm_top5")
|
||||
let ch0: Int = if str_eq(wm_top0_id, "") { 0 } else { if str_contains(prev_top5, wm_top0_id) { 0 } else { 1 } }
|
||||
let ch1: Int = if str_eq(ch_id1, "") { 0 } else { if str_contains(prev_top5, ch_id1) { 0 } else { 1 } }
|
||||
let ch2: Int = if str_eq(ch_id2, "") { 0 } else { if str_contains(prev_top5, ch_id2) { 0 } else { 1 } }
|
||||
let ch3: Int = if str_eq(ch_id3, "") { 0 } else { if str_contains(prev_top5, ch_id3) { 0 } else { 1 } }
|
||||
let ch4: Int = if str_eq(ch_id4, "") { 0 } else { if str_contains(prev_top5, ch_id4) { 0 } else { 1 } }
|
||||
let wm_churn: Int = ch0 + ch1 + ch2 + ch3 + ch4
|
||||
state_set("soul.prev_wm_top5", wm_top0_id + "|" + ch_id1 + "|" + ch_id2 + "|" + ch_id3 + "|" + ch_id4)
|
||||
// wm_top0_wm: the leader's weight. A frozen anchor reads as a constant
|
||||
// here; healthy rotation shows it moving with the promotion scores.
|
||||
let wm_top0_wm_raw: String = json_get(wm_top0, "wm")
|
||||
let wm_top0_wm: String = if str_eq(wm_top0_wm_raw, "") { "0" } else { wm_top0_wm_raw }
|
||||
// Activation observability (2026-07-27 self-review; cumulative since
|
||||
// 2026-07-31): counters from the runtime for the soul's own in-process
|
||||
// store. wm_evicted / breakthroughs are now MONOTONIC process-lifetime
|
||||
// totals (the old per-call values described only the LAST activate call,
|
||||
// so this 60s heartbeat missed nearly every event — curiosity alone runs
|
||||
// 2 activates per 30s between beats). We emit the cumulative totals plus
|
||||
// *_delta fields (change since the previous heartbeat, state-tracked the
|
||||
// same way as node_delta). embed_breaker_open=1 means semantic activation
|
||||
// is silently degraded to lexical-only until the Ollama circuit-breaker
|
||||
// cooldown expires — the failure mode embed_ok structurally cannot see
|
||||
// (it pings the Ollama root, not the embed pipeline).
|
||||
let act_stats: String = engram_act_stats_json()
|
||||
let act_evict_raw: String = json_get(act_stats, "wm_evicted")
|
||||
let act_evict: String = if str_eq(act_evict_raw, "") { "-1" } else { act_evict_raw }
|
||||
let act_bt_raw: String = json_get(act_stats, "breakthroughs")
|
||||
let act_bt: String = if str_eq(act_bt_raw, "") { "-1" } else { act_bt_raw }
|
||||
let evict_now: Int = if str_eq(act_evict_raw, "") { 0 - 1 } else { str_to_int(act_evict_raw) }
|
||||
let bt_now: Int = if str_eq(act_bt_raw, "") { 0 - 1 } else { str_to_int(act_bt_raw) }
|
||||
let prev_evict_raw: String = state_get("soul.prev_wm_evicted")
|
||||
let prev_evict: Int = if str_eq(prev_evict_raw, "") { 0 } else { str_to_int(prev_evict_raw) }
|
||||
let prev_bt_raw: String = state_get("soul.prev_breakthroughs")
|
||||
let prev_bt: Int = if str_eq(prev_bt_raw, "") { 0 } else { str_to_int(prev_bt_raw) }
|
||||
// Clamp deltas at 0: prev > now can only mean the counter restarted
|
||||
// (fresh process) — report the new absolute count, not a negative delta.
|
||||
let evict_delta: Int = if evict_now < 0 { 0 } else { if evict_now < prev_evict { evict_now } else { evict_now - prev_evict } }
|
||||
let bt_delta: Int = if bt_now < 0 { 0 } else { if bt_now < prev_bt { bt_now } else { bt_now - prev_bt } }
|
||||
if evict_now >= 0 { state_set("soul.prev_wm_evicted", int_to_str(evict_now)) }
|
||||
if bt_now >= 0 { state_set("soul.prev_breakthroughs", int_to_str(bt_now)) }
|
||||
// embed_eligible (2026-07-31 self-review): true denominator for embedding
|
||||
// coverage on the authoritative :8742 store. Absolute embed_count alone
|
||||
// invites the documented "~30% coverage, something is broken" misdiagnosis
|
||||
// — most nodes are ISE/Tag/short-content and permanently ineligible.
|
||||
// Real coverage = embed_count / embed_eligible. -1 = stats unreachable.
|
||||
let hb_stats: String = http_get(hb_engram_url + "/api/stats")
|
||||
let embed_elig_raw: String = json_get(hb_stats, "embed_eligible_count")
|
||||
let embed_elig: String = if str_eq(embed_elig_raw, "") { "-1" } else { embed_elig_raw }
|
||||
// auto_term_streak (2026-07-31): consecutive curiosity scans with the same
|
||||
// auto seed term — already state-tracked by proactive_curiosity; surfaced
|
||||
// here so the stuck-term failure is visible in the heartbeat stream too.
|
||||
let hb_ats_raw: String = state_get("soul.auto_term_streak")
|
||||
let hb_ats: Int = if str_eq(hb_ats_raw, "") { 0 } else { str_to_int(hb_ats_raw) }
|
||||
let act_brk_raw: String = json_get(act_stats, "embed_breaker_open")
|
||||
let act_brk: String = if str_eq(act_brk_raw, "") { "-1" } else { act_brk_raw }
|
||||
// ctx_cos (2026-07-29 self-review): cos(query, context centroid) at the
|
||||
// last activate call — the drift gauge for the new context-centroid
|
||||
// scoring. ~1.0 aligned; low at domain-rotation boundaries is healthy;
|
||||
// -2.0 pinned for hours means the centroid never initializes (embedder
|
||||
// down) and semantic continuity is silently absent.
|
||||
let ctx_cos_raw: String = json_get(act_stats, "ctx_cos")
|
||||
let ctx_cos: String = if str_eq(ctx_cos_raw, "") { "-2" } else { ctx_cos_raw }
|
||||
let payload: String = "{\"event\":\"heartbeat\",\"pulse\":" + pulse + ",\"tick\":" + pulse + ",\"boot\":" + boot + ",\"idle\":" + idle + ",\"idle_ms\":" + int_to_str(idle_ms) + ",\"node_count\":" + int_to_str(nc) + ",\"edge_count\":" + int_to_str(ec) + ",\"node_delta\":" + int_to_str(node_delta) + ",\"edge_delta\":" + int_to_str(edge_delta) + ",\"wm_active\":" + int_to_str(wmc) + ",\"wm_delta\":" + int_to_str(wm_delta) + ",\"wm_saturated\":" + int_to_str(wm_sat) + ",\"wm_top0_streak\":" + int_to_str(t0streak) + ",\"wm_churn\":" + int_to_str(wm_churn) + ",\"wm_top0_wm\":" + wm_top0_wm + ",\"sync_added_total\":" + sat_str + ",\"sync_age_ms\":" + int_to_str(sync_age) + ",\"wm_avg_weight\":" + wm_avg_str + ",\"wm_top\":" + wm_top + ",\"ts\":" + int_to_str(ts) + ",\"uptime_ms\":" + int_to_str(up_ms) + ",\"uptime\":\"" + up_human + "\",\"embed_ok\":" + int_to_str(emb_ok) + ",\"embed_backfilled\":" + bf_done + ",\"embed_count\":" + bf_total + ",\"embed_eligible\":" + embed_elig + ",\"wm_evicted\":" + act_evict + ",\"wm_evicted_delta\":" + int_to_str(evict_delta) + ",\"breakthroughs\":" + act_bt + ",\"breakthroughs_delta\":" + int_to_str(bt_delta) + ",\"auto_term_streak\":" + int_to_str(hb_ats) + ",\"embed_breaker_open\":" + act_brk + ",\"ctx_cos\":" + ctx_cos + ",\"ise_fail\":" + fail_str + "}"
|
||||
let payload: String = "{\"event\":\"heartbeat\",\"pulse\":" + pulse + ",\"tick\":" + pulse + ",\"boot\":" + boot + ",\"idle\":" + idle + ",\"node_count\":" + int_to_str(nc) + ",\"edge_count\":" + int_to_str(ec) + ",\"node_delta\":" + int_to_str(node_delta) + ",\"edge_delta\":" + int_to_str(edge_delta) + ",\"wm_active\":" + int_to_str(wmc) + ",\"wm_delta\":" + int_to_str(wm_delta) + ",\"sync_added_total\":" + sat_str + ",\"sync_age_ms\":" + int_to_str(sync_age) + ",\"wm_avg_weight\":" + wm_avg_str + ",\"wm_top\":" + wm_top + ",\"ts\":" + int_to_str(ts) + ",\"uptime_ms\":" + int_to_str(up_ms) + ",\"uptime\":\"" + up_human + "\",\"embed_ok\":" + int_to_str(emb_ok) + ",\"ise_fail\":" + fail_str + "}"
|
||||
ise_post(payload)
|
||||
}
|
||||
|
||||
@@ -338,82 +210,20 @@ fn emit_heartbeat() -> Void {
|
||||
//
|
||||
// Returns true if any nodes were activated.
|
||||
// auto_term_try_slot — attempt to set cseed_auto from one WM slot.
|
||||
// Only writes to cseed_auto if node_type is Memory, BacklogItem, Entity, or
|
||||
// Knowledge AND the first word of the label is > 3 chars (guards
|
||||
// bracket-prefixed labels). Designed to be called in reverse slot order
|
||||
// (highest index first) so that the lowest-indexed slot (highest WM weight)
|
||||
// wins by last-write semantics.
|
||||
//
|
||||
// KNOWLEDGE ADMISSION (2026-07-23 self-review): WM top-10 is now dominated by
|
||||
// Knowledge nodes (world-ingestor titles + captures), so excluding Knowledge
|
||||
// left auto_term empty on EVERY curiosity_scan since boot 6 — the dynamic
|
||||
// seeding path was dead. Knowledge labels are real titles after the
|
||||
// neuron-api label fix. Sentinel-shaped labels ("knowledge:captured",
|
||||
// "memory:remembered" — colon, no space) carry no seed signal and are
|
||||
// skipped so legacy nodes cannot seed the scan with the word "knowledge".
|
||||
// Only writes to cseed_auto if node_type is Memory, BacklogItem, or Entity
|
||||
// AND the first word of the label is > 3 chars (guards bracket-prefixed labels).
|
||||
// Designed to be called in reverse slot order (highest index first) so that
|
||||
// the lowest-indexed slot (highest WM weight) wins by last-write semantics.
|
||||
fn auto_term_try_slot(slot_type: String, slot_lbl: String) -> Void {
|
||||
state_set("_ats_ok", "0")
|
||||
if str_eq(slot_type, "Memory") { state_set("_ats_ok", "1") }
|
||||
if str_eq(slot_type, "BacklogItem") { state_set("_ats_ok", "1") }
|
||||
if str_eq(slot_type, "Entity") { state_set("_ats_ok", "1") }
|
||||
if str_eq(slot_type, "Knowledge") { state_set("_ats_ok", "1") }
|
||||
if str_contains(slot_lbl, ":") {
|
||||
if !str_contains(slot_lbl, " ") { state_set("_ats_ok", "0") }
|
||||
}
|
||||
if str_eq(state_get("_ats_ok"), "1") {
|
||||
if !str_eq(slot_lbl, "") {
|
||||
let sp: Int = str_find_chars(slot_lbl, " :([")
|
||||
if sp > 3 {
|
||||
// GENRE-WORD BLOCKLIST (2026-07-23 self-review): world-ingestor
|
||||
// titles open with classifier prefixes ("Method paper ...",
|
||||
// "Theory paper ..."), so the first word is a genre tag, not a
|
||||
// topic. Verified live: every scan after Knowledge admission
|
||||
// seeded on 'Method'. Skip these; a lower-WM slot with a
|
||||
// topical first word wins instead.
|
||||
let term: String = str_slice(slot_lbl, 0, sp)
|
||||
state_set("_ats_gw", "0")
|
||||
if str_eq(term, "Method") { state_set("_ats_gw", "1") }
|
||||
if str_eq(term, "Theory") { state_set("_ats_gw", "1") }
|
||||
if str_eq(term, "Finding") { state_set("_ats_gw", "1") }
|
||||
if str_eq(term, "Survey") { state_set("_ats_gw", "1") }
|
||||
if str_eq(term, "Paper") { state_set("_ats_gw", "1") }
|
||||
if str_eq(term, "Knowledge") { state_set("_ats_gw", "1") }
|
||||
if str_eq(term, "Value") { state_set("_ats_gw", "1") }
|
||||
// STOPWORD FILTER (2026-07-30 self-review): the genre
|
||||
// blocklist above was whack-a-mole — observed live seeds
|
||||
// included "What", "Colon", "Prose", "Context", "Self",
|
||||
// "Closing", "Global", "Universal": English function words
|
||||
// and document-structure words that pass the >3-char guard
|
||||
// but carry no topical signal (a first-word extractor has no
|
||||
// term-quality scoring). Single delimited membership test
|
||||
// against a curated list of function words + title/structure
|
||||
// words; topical technical terms (MemQ, AsymGRPO, Mobius,
|
||||
// engram_goal_bias) pass untouched. Both Title-case and
|
||||
// lowercase variants listed for the most common offenders.
|
||||
let stopw: String = "|What|When|Where|Which|Whose|While|This|That|These|Those|There|Their|Then|Than|With|Without|From|Into|Onto|Over|Under|About|Between|Among|Across|Some|Most|More|Less|Very|Each|Every|Both|Also|Only|Just|Does|Will|Would|Could|Should|Might|Must|Have|Been|Being|Toward|Towards|Using|Based|Upon|Here|Your|Ours|They|Them|what|this|that|with|from|context|Context|Prose|Colon|Self|Test|Testing|Closing|Global|Universal|Persona|Semantic|Spreading|Temporal|Numeric|Register|Identifying|Introduction|Overview|Summary|Section|General|Notes|Note|"
|
||||
if str_contains(stopw, "|" + term + "|") { state_set("_ats_gw", "1") }
|
||||
// QUOTED-TITLE GUARD (2026-07-25 self-review): labels that
|
||||
// open with a quote ('"The Algorithmic Caricature" ...')
|
||||
// defeat the >3-char stopword guard — the extracted term
|
||||
// '"The' is 4 chars and seeds a lexical flood on "The"
|
||||
// (observed live: activated jumped 48 → 87). Any term
|
||||
// carrying a quote character is not a topic word.
|
||||
if str_contains(term, "\"") { state_set("_ats_gw", "1") }
|
||||
if str_contains(term, "'") { state_set("_ats_gw", "1") }
|
||||
// AUTO-TERM TABU (2026-07-25 self-review): finst-style
|
||||
// inhibition-of-return (ACT-R declarative finsts: small
|
||||
// marker pool, hard exclusion). The last 4 selected auto
|
||||
// terms are ineligible (~2 min at the 30s scan cadence),
|
||||
// forcing rotation instead of "Fast-slow" every scan for
|
||||
// hours. Empty tabu slots return "" from state_get and can
|
||||
// never match — term is always > 3 chars here.
|
||||
if str_eq(term, state_get("soul.tabu_t0")) { state_set("_ats_gw", "1") }
|
||||
if str_eq(term, state_get("soul.tabu_t1")) { state_set("_ats_gw", "1") }
|
||||
if str_eq(term, state_get("soul.tabu_t2")) { state_set("_ats_gw", "1") }
|
||||
if str_eq(term, state_get("soul.tabu_t3")) { state_set("_ats_gw", "1") }
|
||||
if str_eq(state_get("_ats_gw"), "0") {
|
||||
state_set("cseed_auto", term)
|
||||
}
|
||||
state_set("cseed_auto", str_slice(slot_lbl, 0, sp))
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -470,11 +280,11 @@ fn proactive_curiosity() -> Bool {
|
||||
// loop. A single phrase activation matches few (often zero) nodes lexically;
|
||||
// small counts here are the point, not a regression. hops=1 as before.
|
||||
//
|
||||
// NOTE (2026-07-31 self-review): semantic seeding/gating IS implemented in
|
||||
// engram_activate (el_runtime.c): the query is embedded, top-K cosine
|
||||
// matches supplement the lexical istr_contains seeds, cosine gates
|
||||
// propagation, and a semantic term feeds the WM promotion score. Lexical
|
||||
// matching is the fallback when the embedder/breaker is unavailable.
|
||||
// NOTE: a semantic seed supplement (cosine sim ≥ 0.70 scan over embedded nodes)
|
||||
// was planned alongside hops=1 but is NOT yet implemented — embed_ok in
|
||||
// heartbeats confirms Ollama is reachable, but no embedding call is made during
|
||||
// activation. The seed-finding loop in el_runtime.c uses istr_contains only.
|
||||
// (2026-06-30 self-review: corrected stale comment)
|
||||
let curiosity_seed: String = curiosity_term_a + " " + curiosity_term_b + " " + curiosity_term_c
|
||||
let results_all: String = engram_activate_json(curiosity_seed, 1)
|
||||
let found: Int = json_array_len(results_all)
|
||||
@@ -483,19 +293,8 @@ fn proactive_curiosity() -> Bool {
|
||||
// pattern as attend(): json_array_get element 0, json_get its "id".
|
||||
let top_entry: String = json_array_get(results_all, 0)
|
||||
let top_id: String = json_get(top_entry, "id")
|
||||
// STREAK-GATED STRENGTHEN (2026-07-25 self-review): unconditionally
|
||||
// strengthening the top result every scan was a positive-feedback fixed
|
||||
// point — whatever led WM got its salience bumped again, kept leading,
|
||||
// and pinned the auto_term for hours ("Fast-slow" era). Strengthen only
|
||||
// when the top node CHANGED since the last scan: novelty is reinforced,
|
||||
// incumbency is not. Pairs with the runtime-side Lebiere-Best short-term
|
||||
// inhibition (el_runtime.c Pass 2), which handles score-level rotation.
|
||||
let prev_str_id: String = state_get("soul.last_strengthen_id")
|
||||
if !str_eq(top_id, "") {
|
||||
if !str_eq(top_id, prev_str_id) {
|
||||
engram_strengthen(top_id)
|
||||
}
|
||||
state_set("soul.last_strengthen_id", top_id)
|
||||
engram_strengthen(top_id)
|
||||
}
|
||||
|
||||
// WM-autobiographical 4th seed: scan top-10 WM nodes for the highest-ranked
|
||||
@@ -543,21 +342,6 @@ fn proactive_curiosity() -> Bool {
|
||||
let found_auto: Int = json_array_len(results_auto)
|
||||
let total_found: Int = found + found_auto
|
||||
let safe_auto: String = str_replace(auto_term, "\"", "'")
|
||||
// Push the selected term into the 4-deep tabu ring (see
|
||||
// auto_term_try_slot) and track the consecutive-same-term streak for
|
||||
// the ISE — the stuck-term failure becomes a one-glance signal.
|
||||
let prev_auto: String = state_get("soul.prev_auto_term")
|
||||
let atstreak_raw: String = state_get("soul.auto_term_streak")
|
||||
let atstreak_prev: Int = if str_eq(atstreak_raw, "") { 0 } else { str_to_int(atstreak_raw) }
|
||||
let atstreak: Int = if str_eq(auto_term, prev_auto) { atstreak_prev + 1 } else { 1 }
|
||||
state_set("soul.prev_auto_term", auto_term)
|
||||
state_set("soul.auto_term_streak", int_to_str(atstreak))
|
||||
if !str_eq(auto_term, "") {
|
||||
state_set("soul.tabu_t3", state_get("soul.tabu_t2"))
|
||||
state_set("soul.tabu_t2", state_get("soul.tabu_t1"))
|
||||
state_set("soul.tabu_t1", state_get("soul.tabu_t0"))
|
||||
state_set("soul.tabu_t0", auto_term)
|
||||
}
|
||||
|
||||
let wmc: Int = engram_wm_count()
|
||||
// wm_top snapshot in curiosity_scan ISE: top-3 WM nodes by weight.
|
||||
@@ -570,8 +354,7 @@ fn proactive_curiosity() -> Bool {
|
||||
let wm3: String = engram_wm_top_json(3)
|
||||
let ise: String = "{\"event\":\"curiosity_scan\",\"seed\":\"" + curiosity_seed
|
||||
+ "\",\"auto_term\":\"" + safe_auto
|
||||
+ "\",\"auto_term_streak\":" + int_to_str(atstreak)
|
||||
+ ",\"minute_block\":" + int_to_str(minute_block)
|
||||
+ "\",\"minute_block\":" + int_to_str(minute_block)
|
||||
+ ",\"activated\":" + int_to_str(total_found)
|
||||
+ ",\"wm_active\":" + int_to_str(wmc)
|
||||
+ ",\"wm_top\":" + wm3
|
||||
@@ -850,17 +633,6 @@ fn awareness_run() -> Void {
|
||||
let tick_mark: Any = el_arena_push()
|
||||
let running: String = state_get("soul.running")
|
||||
if str_eq(running, "false") {
|
||||
// Shutdown ISE (2026-07-28 self-review): graceful exit was invisible
|
||||
// in the ISE stream — indistinguishable from a crash or a frozen
|
||||
// loop. Emit a final event with uptime/pulse so the stream records
|
||||
// how this boot ended. (Covers state-driven shutdown only; SIGKILL
|
||||
// still leaves no trace — that absence is itself the crash signal.)
|
||||
let sd_boot_raw: String = state_get("soul_boot_count")
|
||||
let sd_boot: String = if str_eq(sd_boot_raw, "") { "0" } else { sd_boot_raw }
|
||||
ise_post("{\"event\":\"shutdown\",\"boot\":" + sd_boot
|
||||
+ ",\"pulse\":" + int_to_str(pulse_count())
|
||||
+ ",\"uptime_ms\":" + int_to_str(elapsed_ms())
|
||||
+ ",\"ts\":" + int_to_str(time_now()) + "}")
|
||||
println("[awareness] exiting")
|
||||
el_arena_pop(tick_mark)
|
||||
return ""
|
||||
@@ -931,29 +703,15 @@ fn awareness_run() -> Void {
|
||||
let engram_url: String = if str_eq(sync_state_url, "") { "http://localhost:8742" } else { sync_state_url }
|
||||
if !str_eq(engram_url, "") {
|
||||
let sync_json: String = http_get(engram_url + "/api/sync")
|
||||
let sync_ok: Bool = !str_eq(sync_json, "") && !str_eq(sync_json, "{}")
|
||||
// Empty-sync warn ISE (2026-07-28 self-review): an empty/{} sync
|
||||
// response was silently skipped, making "engram unreachable for
|
||||
// hours" look identical to "quiet but healthy" — the exact
|
||||
// failure class the URL-fallback comment above fights. One warn
|
||||
// event per refresh interval (10 min default) is cheap and makes
|
||||
// a persistently-failing sync visible in the stream itself.
|
||||
if !sync_ok {
|
||||
ise_post("{\"event\":\"sync_empty\",\"ts\":" + int_to_str(time_now()) + "}")
|
||||
}
|
||||
if sync_ok {
|
||||
if !str_eq(sync_json, "") && !str_eq(sync_json, "{}") {
|
||||
let cgi_id: String = state_get("soul_cgi_id")
|
||||
let tmp: String = "/tmp/soul-sync-" + cgi_id + ".json"
|
||||
fs_write(tmp, sync_json)
|
||||
let added: Int = engram_load_merge(tmp)
|
||||
// Backflow control: the merged snapshot carries ISE telemetry
|
||||
// from the HTTP store. Prune on the same horizon the HTTP
|
||||
// store itself uses — read ENGRAM_ISE_RETENTION_MS (the env
|
||||
// server.el honors) instead of duplicating the 48h magic
|
||||
// number, so the two stores can't drift. (2026-07-28)
|
||||
let ret_raw: String = env("ENGRAM_ISE_RETENTION_MS")
|
||||
let ret_ms: Int = if str_eq(ret_raw, "") { 172800000 } else { str_to_int(ret_raw) }
|
||||
let pruned_sync: Int = engram_prune_telemetry(ret_ms)
|
||||
// from the HTTP store. Prune anything older than 48h — same
|
||||
// horizon the HTTP store itself uses (server.el ISE insert).
|
||||
let pruned_sync: Int = engram_prune_telemetry(172800000)
|
||||
// Running total of merged-in nodes this boot, surfaced in the
|
||||
// heartbeat ISE as sync_added_total (same state mechanism as
|
||||
// the pulse counter).
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
// auto-generated by elc --emit-header - do not edit
|
||||
// auto-generated by elc --emit-header — do not edit
|
||||
extern fn chat_default_model() -> String
|
||||
extern fn engram_numeric_valid(s: String) -> Bool
|
||||
extern fn parse_float_x100(s: String) -> Int
|
||||
@@ -16,35 +16,18 @@ extern fn engram_nodes_merge(a: String, b: String) -> String
|
||||
extern fn id_in_seen(node_id: String, seen: String) -> Bool
|
||||
extern fn add_to_seen(seen: String, node_id: String) -> String
|
||||
extern fn engram_extract_ids(nodes_json: String) -> String
|
||||
extern fn affective_node_ts(node_json: String) -> Int
|
||||
extern fn engram_compile(intent: String) -> String
|
||||
extern fn distill_transcript(transcript: String) -> String
|
||||
extern fn json_safe(s: String) -> String
|
||||
extern fn current_engine_note(model: String) -> String
|
||||
extern fn bounded_persona_floor() -> String
|
||||
extern fn operator_identity_block() -> String
|
||||
extern fn build_system_prompt(ctx: String, chat_mode: Bool) -> String
|
||||
extern fn hist_append(hist: String, role: String, content: String) -> String
|
||||
extern fn conv_hist_key(session_id: String) -> String
|
||||
extern fn conv_hist_label(session_id: String) -> String
|
||||
extern fn is_utility_request(body: String, session_id: String) -> Bool
|
||||
extern fn provenance_scan_urls(arr: String, acc: String) -> String
|
||||
extern fn provenance_add_sources(block: String, btype: String, has_cit: Bool, cit_raw: String, acc: String) -> String
|
||||
extern fn provenance_names(tools_used: String) -> String
|
||||
extern fn text_join_sep(accumulated: String, incoming: String, after_interruption: Bool) -> String
|
||||
extern fn receipt_rule() -> String
|
||||
extern fn receipt_strip(s: String) -> String
|
||||
extern fn tool_receipt(tools_used: String, sources: String) -> String
|
||||
extern fn hist_trim(hist: String) -> String
|
||||
extern fn hist_trim_with_bell_guard(hist: String) -> String
|
||||
extern fn clean_llm_response(s: String) -> String
|
||||
extern fn conv_history_persist(session_id: String, hist: String) -> Void
|
||||
extern fn conv_history_load(session_id: String) -> String
|
||||
extern fn conv_history_record(session_id: String, user_msg: String, assistant_msg: String, receipt: String) -> Void
|
||||
extern fn conv_history_block(session_id: String) -> String
|
||||
extern fn layered_generate(prompt: String, imprint_id: String, session_id: String) -> String
|
||||
extern fn conv_history_persist(hist: String) -> Void
|
||||
extern fn conv_history_load() -> String
|
||||
extern fn session_preload_bullets(nodes: String, max_bullets: Int, snip_len: Int) -> String
|
||||
extern fn affective_context_prefix() -> String
|
||||
extern fn handle_chat(body: String) -> String
|
||||
extern fn handle_see(body: String) -> String
|
||||
extern fn studio_tools_json() -> String
|
||||
@@ -53,14 +36,7 @@ extern fn llm_base_url() -> String
|
||||
extern fn llm_wire_format() -> String
|
||||
extern fn json_escape(s: String) -> String
|
||||
extern fn openai_chat_complete(model: String, base_url: String, api_key: String, safe_sys: String, messages_json: String) -> String
|
||||
extern fn openai_tools_json(tools_anthropic: String) -> String
|
||||
extern fn utf8_safe_slice(s: String, n: Int) -> String
|
||||
extern fn json_trim_dangling_escape(s: String) -> String
|
||||
extern fn agentic_tools_no_web() -> String
|
||||
extern fn openai_agentic_loop(session_id: String, model: String, safe_sys: String, tools_json: String, messages_in: String, tools_log_in: String) -> String
|
||||
extern fn agentic_tools_literal() -> String
|
||||
extern fn web_search_tool_json() -> String
|
||||
extern fn strip_client_web_search(tools_inner: String) -> String
|
||||
extern fn agentic_tools_with_web() -> String
|
||||
extern fn connector_tools_json() -> String
|
||||
extern fn agentic_tools_all() -> String
|
||||
@@ -70,17 +46,13 @@ extern fn call_neuron_mcp(tool_name: String, args: String) -> String
|
||||
extern fn agent_workspace_root() -> String
|
||||
extern fn path_within_root(path: String, root: String) -> Bool
|
||||
extern fn resolve_in_root(path: String, root: String) -> String
|
||||
extern fn run_command_is_readonly(cmd: String) -> Bool
|
||||
extern fn cmd_abs_escape_at(cmd: String, root: String, needle: String) -> Bool
|
||||
extern fn run_command_guard(cmd: String, root: String) -> String
|
||||
extern fn classify_tool_risk(tool_name: String, tool_input: String) -> String
|
||||
extern fn dispatch_tool(tool_name: String, tool_input: String) -> String
|
||||
extern fn is_builtin_tool(tool_name: String) -> Bool
|
||||
extern fn next_bridge_id() -> String
|
||||
extern fn handle_chat_plan(body: String) -> String
|
||||
extern fn handle_chat_agentic(body: String) -> String
|
||||
extern fn agentic_loop(session_id: String, model: String, safe_sys: String, tools_json: String, messages_in: String, h: Map, tools_log_in: String) -> String
|
||||
extern fn bridge_save(session_id: String, model: String, safe_sys: String, tools_json: String, messages: String, tools_log: String, tool_use_id: String, wire: String) -> Bool
|
||||
extern fn bridge_save(session_id: String, model: String, safe_sys: String, tools_json: String, messages: String, tools_log: String, tool_use_id: String) -> Bool
|
||||
extern fn agentic_resume(session_id: String, tool_use_id: String, content: String) -> String
|
||||
extern fn handle_tool_result(session_id: String, body: String) -> String
|
||||
extern fn handle_chat_as_soul(body: String) -> String
|
||||
|
||||
+73
-221
@@ -133,8 +133,6 @@ el_val_t emit_heartbeat(void) {
|
||||
el_val_t boot = ({ el_val_t _if_result_4 = 0; if (str_eq(boot_raw, EL_STR(""))) { _if_result_4 = (EL_STR("0")); } else { _if_result_4 = (boot_raw); } _if_result_4; });
|
||||
el_val_t idle = int_to_str(idle_count());
|
||||
el_val_t ts = time_now();
|
||||
el_val_t last_act_raw = state_get(EL_STR("soul.last_activity_ts"));
|
||||
el_val_t idle_ms = ({ el_val_t _if_result_5 = 0; if (str_eq(last_act_raw, EL_STR(""))) { _if_result_5 = ((0 - 1)); } else { _if_result_5 = ((ts - str_to_int(last_act_raw))); } _if_result_5; });
|
||||
el_val_t nc = engram_node_count();
|
||||
el_val_t ec = engram_edge_count();
|
||||
el_val_t wmc = engram_wm_count();
|
||||
@@ -145,90 +143,24 @@ el_val_t emit_heartbeat(void) {
|
||||
el_val_t up_human = elapsed_human();
|
||||
el_val_t emb_ok = embed_ok();
|
||||
el_val_t fail_raw = state_get(EL_STR("soul.ise_fail_count"));
|
||||
el_val_t fail_str = ({ el_val_t _if_result_6 = 0; if (str_eq(fail_raw, EL_STR(""))) { _if_result_6 = (EL_STR("0")); } else { _if_result_6 = (fail_raw); } _if_result_6; });
|
||||
el_val_t fail_str = ({ el_val_t _if_result_5 = 0; if (str_eq(fail_raw, EL_STR(""))) { _if_result_5 = (EL_STR("0")); } else { _if_result_5 = (fail_raw); } _if_result_5; });
|
||||
el_val_t sat_raw = state_get(EL_STR("soul.sync_added_total"));
|
||||
el_val_t sat_str = ({ el_val_t _if_result_7 = 0; if (str_eq(sat_raw, EL_STR(""))) { _if_result_7 = (EL_STR("0")); } else { _if_result_7 = (sat_raw); } _if_result_7; });
|
||||
el_val_t sat_str = ({ el_val_t _if_result_6 = 0; if (str_eq(sat_raw, EL_STR(""))) { _if_result_6 = (EL_STR("0")); } else { _if_result_6 = (sat_raw); } _if_result_6; });
|
||||
el_val_t prev_wm_raw = state_get(EL_STR("soul.prev_wm_active"));
|
||||
el_val_t prev_wm = ({ el_val_t _if_result_8 = 0; if (str_eq(prev_wm_raw, EL_STR(""))) { _if_result_8 = (0); } else { _if_result_8 = (str_to_int(prev_wm_raw)); } _if_result_8; });
|
||||
el_val_t prev_wm = ({ el_val_t _if_result_7 = 0; if (str_eq(prev_wm_raw, EL_STR(""))) { _if_result_7 = (0); } else { _if_result_7 = (str_to_int(prev_wm_raw)); } _if_result_7; });
|
||||
el_val_t wm_delta = (wmc - prev_wm);
|
||||
state_set(EL_STR("soul.prev_wm_active"), int_to_str(wmc));
|
||||
el_val_t prev_nc_raw = state_get(EL_STR("soul.prev_node_count"));
|
||||
el_val_t prev_nc = ({ el_val_t _if_result_9 = 0; if (str_eq(prev_nc_raw, EL_STR(""))) { _if_result_9 = (nc); } else { _if_result_9 = (str_to_int(prev_nc_raw)); } _if_result_9; });
|
||||
el_val_t prev_nc = ({ el_val_t _if_result_8 = 0; if (str_eq(prev_nc_raw, EL_STR(""))) { _if_result_8 = (nc); } else { _if_result_8 = (str_to_int(prev_nc_raw)); } _if_result_8; });
|
||||
el_val_t node_delta = (nc - prev_nc);
|
||||
state_set(EL_STR("soul.prev_node_count"), int_to_str(nc));
|
||||
el_val_t prev_ec_raw = state_get(EL_STR("soul.prev_edge_count"));
|
||||
el_val_t prev_ec = ({ el_val_t _if_result_10 = 0; if (str_eq(prev_ec_raw, EL_STR(""))) { _if_result_10 = (ec); } else { _if_result_10 = (str_to_int(prev_ec_raw)); } _if_result_10; });
|
||||
el_val_t prev_ec = ({ el_val_t _if_result_9 = 0; if (str_eq(prev_ec_raw, EL_STR(""))) { _if_result_9 = (ec); } else { _if_result_9 = (str_to_int(prev_ec_raw)); } _if_result_9; });
|
||||
el_val_t edge_delta = (ec - prev_ec);
|
||||
state_set(EL_STR("soul.prev_edge_count"), int_to_str(ec));
|
||||
el_val_t sync_ok_raw = state_get(EL_STR("soul.last_sync_ok_ts"));
|
||||
el_val_t sync_age = ({ el_val_t _if_result_11 = 0; if (str_eq(sync_ok_raw, EL_STR(""))) { _if_result_11 = ((0 - 1)); } else { _if_result_11 = ((ts - str_to_int(sync_ok_raw))); } _if_result_11; });
|
||||
el_val_t hb_env_url = env(EL_STR("SOUL_ISE_URL"));
|
||||
el_val_t hb_state_url = ({ el_val_t _if_result_12 = 0; if (str_eq(hb_env_url, EL_STR(""))) { _if_result_12 = (state_get(EL_STR("soul_engram_url"))); } else { _if_result_12 = (hb_env_url); } _if_result_12; });
|
||||
el_val_t hb_engram_url = ({ el_val_t _if_result_13 = 0; if (str_eq(hb_state_url, EL_STR(""))) { _if_result_13 = (EL_STR("http://localhost:8742")); } else { _if_result_13 = (hb_state_url); } _if_result_13; });
|
||||
el_val_t bf_resp = http_get(el_str_concat(hb_engram_url, EL_STR("/api/embed-backfill?n=32")));
|
||||
el_val_t bf_done_raw = json_get(bf_resp, EL_STR("embedded"));
|
||||
el_val_t bf_done = ({ el_val_t _if_result_14 = 0; if (str_eq(bf_done_raw, EL_STR(""))) { _if_result_14 = (EL_STR("-1")); } else { _if_result_14 = (bf_done_raw); } _if_result_14; });
|
||||
el_val_t bf_total_raw = json_get(bf_resp, EL_STR("embedded_count"));
|
||||
el_val_t bf_total = ({ el_val_t _if_result_15 = 0; if (str_eq(bf_total_raw, EL_STR(""))) { _if_result_15 = (EL_STR("-1")); } else { _if_result_15 = (bf_total_raw); } _if_result_15; });
|
||||
el_val_t wm_sat = ({ el_val_t _if_result_16 = 0; if ((wmc >= 24)) { _if_result_16 = (1); } else { _if_result_16 = (0); } _if_result_16; });
|
||||
el_val_t prev_sat_raw = state_get(EL_STR("soul.prev_wm_saturated"));
|
||||
el_val_t prev_sat = ({ el_val_t _if_result_17 = 0; if (str_eq(prev_sat_raw, EL_STR(""))) { _if_result_17 = (wm_sat); } else { _if_result_17 = (str_to_int(prev_sat_raw)); } _if_result_17; });
|
||||
if (wm_sat != prev_sat) {
|
||||
el_val_t sat_dir = ({ el_val_t _if_result_18 = 0; if ((wm_sat == 1)) { _if_result_18 = (EL_STR("onset")); } else { _if_result_18 = (EL_STR("release")); } _if_result_18; });
|
||||
ise_post(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"event\":\"wm_saturation_transition\",\"direction\":\""), sat_dir), EL_STR("\",\"wm_active\":")), int_to_str(wmc)), EL_STR(",\"wm_top\":")), wm_top), EL_STR(",\"ts\":")), int_to_str(ts)), EL_STR("}")));
|
||||
}
|
||||
state_set(EL_STR("soul.prev_wm_saturated"), int_to_str(wm_sat));
|
||||
el_val_t wm_top0 = json_array_get(wm_top, 0);
|
||||
el_val_t wm_top0_id = json_get(wm_top0, EL_STR("id"));
|
||||
el_val_t prev_top0 = state_get(EL_STR("soul.prev_wm_top0"));
|
||||
el_val_t t0streak_raw = state_get(EL_STR("soul.wm_top0_streak"));
|
||||
el_val_t t0streak_prev = ({ el_val_t _if_result_19 = 0; if (str_eq(t0streak_raw, EL_STR(""))) { _if_result_19 = (0); } else { _if_result_19 = (str_to_int(t0streak_raw)); } _if_result_19; });
|
||||
el_val_t t0streak = ({ el_val_t _if_result_20 = 0; if (str_eq(wm_top0_id, EL_STR(""))) { _if_result_20 = (0); } else { _if_result_20 = (({ el_val_t _if_result_21 = 0; if (str_eq(wm_top0_id, prev_top0)) { _if_result_21 = ((t0streak_prev + 1)); } else { _if_result_21 = (1); } _if_result_21; })); } _if_result_20; });
|
||||
state_set(EL_STR("soul.prev_wm_top0"), wm_top0_id);
|
||||
state_set(EL_STR("soul.wm_top0_streak"), int_to_str(t0streak));
|
||||
el_val_t ch_id1 = json_get(json_array_get(wm_top, 1), EL_STR("id"));
|
||||
el_val_t ch_id2 = json_get(json_array_get(wm_top, 2), EL_STR("id"));
|
||||
el_val_t ch_id3 = json_get(json_array_get(wm_top, 3), EL_STR("id"));
|
||||
el_val_t ch_id4 = json_get(json_array_get(wm_top, 4), EL_STR("id"));
|
||||
el_val_t prev_top5 = state_get(EL_STR("soul.prev_wm_top5"));
|
||||
el_val_t ch0 = ({ el_val_t _if_result_22 = 0; if (str_eq(wm_top0_id, EL_STR(""))) { _if_result_22 = (0); } else { _if_result_22 = (({ el_val_t _if_result_23 = 0; if (str_contains(prev_top5, wm_top0_id)) { _if_result_23 = (0); } else { _if_result_23 = (1); } _if_result_23; })); } _if_result_22; });
|
||||
el_val_t ch1 = ({ el_val_t _if_result_24 = 0; if (str_eq(ch_id1, EL_STR(""))) { _if_result_24 = (0); } else { _if_result_24 = (({ el_val_t _if_result_25 = 0; if (str_contains(prev_top5, ch_id1)) { _if_result_25 = (0); } else { _if_result_25 = (1); } _if_result_25; })); } _if_result_24; });
|
||||
el_val_t ch2 = ({ el_val_t _if_result_26 = 0; if (str_eq(ch_id2, EL_STR(""))) { _if_result_26 = (0); } else { _if_result_26 = (({ el_val_t _if_result_27 = 0; if (str_contains(prev_top5, ch_id2)) { _if_result_27 = (0); } else { _if_result_27 = (1); } _if_result_27; })); } _if_result_26; });
|
||||
el_val_t ch3 = ({ el_val_t _if_result_28 = 0; if (str_eq(ch_id3, EL_STR(""))) { _if_result_28 = (0); } else { _if_result_28 = (({ el_val_t _if_result_29 = 0; if (str_contains(prev_top5, ch_id3)) { _if_result_29 = (0); } else { _if_result_29 = (1); } _if_result_29; })); } _if_result_28; });
|
||||
el_val_t ch4 = ({ el_val_t _if_result_30 = 0; if (str_eq(ch_id4, EL_STR(""))) { _if_result_30 = (0); } else { _if_result_30 = (({ el_val_t _if_result_31 = 0; if (str_contains(prev_top5, ch_id4)) { _if_result_31 = (0); } else { _if_result_31 = (1); } _if_result_31; })); } _if_result_30; });
|
||||
el_val_t wm_churn = ((((ch0 + ch1) + ch2) + ch3) + ch4);
|
||||
state_set(EL_STR("soul.prev_wm_top5"), el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(wm_top0_id, EL_STR("|")), ch_id1), EL_STR("|")), ch_id2), EL_STR("|")), ch_id3), EL_STR("|")), ch_id4));
|
||||
el_val_t wm_top0_wm_raw = json_get(wm_top0, EL_STR("wm"));
|
||||
el_val_t wm_top0_wm = ({ el_val_t _if_result_32 = 0; if (str_eq(wm_top0_wm_raw, EL_STR(""))) { _if_result_32 = (EL_STR("0")); } else { _if_result_32 = (wm_top0_wm_raw); } _if_result_32; });
|
||||
el_val_t act_stats = engram_act_stats_json();
|
||||
el_val_t act_evict_raw = json_get(act_stats, EL_STR("wm_evicted"));
|
||||
el_val_t act_evict = ({ el_val_t _if_result_33 = 0; if (str_eq(act_evict_raw, EL_STR(""))) { _if_result_33 = (EL_STR("-1")); } else { _if_result_33 = (act_evict_raw); } _if_result_33; });
|
||||
el_val_t act_bt_raw = json_get(act_stats, EL_STR("breakthroughs"));
|
||||
el_val_t act_bt = ({ el_val_t _if_result_34 = 0; if (str_eq(act_bt_raw, EL_STR(""))) { _if_result_34 = (EL_STR("-1")); } else { _if_result_34 = (act_bt_raw); } _if_result_34; });
|
||||
el_val_t evict_now = ({ el_val_t _if_result_35 = 0; if (str_eq(act_evict_raw, EL_STR(""))) { _if_result_35 = ((0 - 1)); } else { _if_result_35 = (str_to_int(act_evict_raw)); } _if_result_35; });
|
||||
el_val_t bt_now = ({ el_val_t _if_result_36 = 0; if (str_eq(act_bt_raw, EL_STR(""))) { _if_result_36 = ((0 - 1)); } else { _if_result_36 = (str_to_int(act_bt_raw)); } _if_result_36; });
|
||||
el_val_t prev_evict_raw = state_get(EL_STR("soul.prev_wm_evicted"));
|
||||
el_val_t prev_evict = ({ el_val_t _if_result_37 = 0; if (str_eq(prev_evict_raw, EL_STR(""))) { _if_result_37 = (0); } else { _if_result_37 = (str_to_int(prev_evict_raw)); } _if_result_37; });
|
||||
el_val_t prev_bt_raw = state_get(EL_STR("soul.prev_breakthroughs"));
|
||||
el_val_t prev_bt = ({ el_val_t _if_result_38 = 0; if (str_eq(prev_bt_raw, EL_STR(""))) { _if_result_38 = (0); } else { _if_result_38 = (str_to_int(prev_bt_raw)); } _if_result_38; });
|
||||
el_val_t evict_delta = ({ el_val_t _if_result_39 = 0; if ((evict_now < 0)) { _if_result_39 = (0); } else { _if_result_39 = (({ el_val_t _if_result_40 = 0; if ((evict_now < prev_evict)) { _if_result_40 = (evict_now); } else { _if_result_40 = ((evict_now - prev_evict)); } _if_result_40; })); } _if_result_39; });
|
||||
el_val_t bt_delta = ({ el_val_t _if_result_41 = 0; if ((bt_now < 0)) { _if_result_41 = (0); } else { _if_result_41 = (({ el_val_t _if_result_42 = 0; if ((bt_now < prev_bt)) { _if_result_42 = (bt_now); } else { _if_result_42 = ((bt_now - prev_bt)); } _if_result_42; })); } _if_result_41; });
|
||||
if (evict_now >= 0) {
|
||||
state_set(EL_STR("soul.prev_wm_evicted"), int_to_str(evict_now));
|
||||
}
|
||||
if (bt_now >= 0) {
|
||||
state_set(EL_STR("soul.prev_breakthroughs"), int_to_str(bt_now));
|
||||
}
|
||||
el_val_t hb_stats = http_get(el_str_concat(hb_engram_url, EL_STR("/api/stats")));
|
||||
el_val_t embed_elig_raw = json_get(hb_stats, EL_STR("embed_eligible_count"));
|
||||
el_val_t embed_elig = ({ el_val_t _if_result_43 = 0; if (str_eq(embed_elig_raw, EL_STR(""))) { _if_result_43 = (EL_STR("-1")); } else { _if_result_43 = (embed_elig_raw); } _if_result_43; });
|
||||
el_val_t hb_ats_raw = state_get(EL_STR("soul.auto_term_streak"));
|
||||
el_val_t hb_ats = ({ el_val_t _if_result_44 = 0; if (str_eq(hb_ats_raw, EL_STR(""))) { _if_result_44 = (0); } else { _if_result_44 = (str_to_int(hb_ats_raw)); } _if_result_44; });
|
||||
el_val_t act_brk_raw = json_get(act_stats, EL_STR("embed_breaker_open"));
|
||||
el_val_t act_brk = ({ el_val_t _if_result_45 = 0; if (str_eq(act_brk_raw, EL_STR(""))) { _if_result_45 = (EL_STR("-1")); } else { _if_result_45 = (act_brk_raw); } _if_result_45; });
|
||||
el_val_t ctx_cos_raw = json_get(act_stats, EL_STR("ctx_cos"));
|
||||
el_val_t ctx_cos = ({ el_val_t _if_result_46 = 0; if (str_eq(ctx_cos_raw, EL_STR(""))) { _if_result_46 = (EL_STR("-2")); } else { _if_result_46 = (ctx_cos_raw); } _if_result_46; });
|
||||
el_val_t payload = el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"event\":\"heartbeat\",\"pulse\":"), pulse), EL_STR(",\"tick\":")), pulse), EL_STR(",\"boot\":")), boot), EL_STR(",\"idle\":")), idle), EL_STR(",\"idle_ms\":")), int_to_str(idle_ms)), EL_STR(",\"node_count\":")), int_to_str(nc)), EL_STR(",\"edge_count\":")), int_to_str(ec)), EL_STR(",\"node_delta\":")), int_to_str(node_delta)), EL_STR(",\"edge_delta\":")), int_to_str(edge_delta)), EL_STR(",\"wm_active\":")), int_to_str(wmc)), EL_STR(",\"wm_delta\":")), int_to_str(wm_delta)), EL_STR(",\"wm_saturated\":")), int_to_str(wm_sat)), EL_STR(",\"wm_top0_streak\":")), int_to_str(t0streak)), EL_STR(",\"wm_churn\":")), int_to_str(wm_churn)), EL_STR(",\"wm_top0_wm\":")), wm_top0_wm), EL_STR(",\"sync_added_total\":")), sat_str), EL_STR(",\"sync_age_ms\":")), int_to_str(sync_age)), EL_STR(",\"wm_avg_weight\":")), wm_avg_str), EL_STR(",\"wm_top\":")), wm_top), EL_STR(",\"ts\":")), int_to_str(ts)), EL_STR(",\"uptime_ms\":")), int_to_str(up_ms)), EL_STR(",\"uptime\":\"")), up_human), EL_STR("\",\"embed_ok\":")), int_to_str(emb_ok)), EL_STR(",\"embed_backfilled\":")), bf_done), EL_STR(",\"embed_count\":")), bf_total), EL_STR(",\"embed_eligible\":")), embed_elig), EL_STR(",\"wm_evicted\":")), act_evict), EL_STR(",\"wm_evicted_delta\":")), int_to_str(evict_delta)), EL_STR(",\"breakthroughs\":")), act_bt), EL_STR(",\"breakthroughs_delta\":")), int_to_str(bt_delta)), EL_STR(",\"auto_term_streak\":")), int_to_str(hb_ats)), EL_STR(",\"embed_breaker_open\":")), act_brk), EL_STR(",\"ctx_cos\":")), ctx_cos), EL_STR(",\"ise_fail\":")), fail_str), EL_STR("}"));
|
||||
el_val_t sync_age = ({ el_val_t _if_result_10 = 0; if (str_eq(sync_ok_raw, EL_STR(""))) { _if_result_10 = ((0 - 1)); } else { _if_result_10 = ((ts - str_to_int(sync_ok_raw))); } _if_result_10; });
|
||||
el_val_t payload = el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"event\":\"heartbeat\",\"pulse\":"), pulse), EL_STR(",\"tick\":")), pulse), EL_STR(",\"boot\":")), boot), EL_STR(",\"idle\":")), idle), EL_STR(",\"node_count\":")), int_to_str(nc)), EL_STR(",\"edge_count\":")), int_to_str(ec)), EL_STR(",\"node_delta\":")), int_to_str(node_delta)), EL_STR(",\"edge_delta\":")), int_to_str(edge_delta)), EL_STR(",\"wm_active\":")), int_to_str(wmc)), EL_STR(",\"wm_delta\":")), int_to_str(wm_delta)), EL_STR(",\"sync_added_total\":")), sat_str), EL_STR(",\"sync_age_ms\":")), int_to_str(sync_age)), EL_STR(",\"wm_avg_weight\":")), wm_avg_str), EL_STR(",\"wm_top\":")), wm_top), EL_STR(",\"ts\":")), int_to_str(ts)), EL_STR(",\"uptime_ms\":")), int_to_str(up_ms)), EL_STR(",\"uptime\":\"")), up_human), EL_STR("\",\"embed_ok\":")), int_to_str(emb_ok)), EL_STR(",\"ise_fail\":")), fail_str), EL_STR("}"));
|
||||
ise_post(payload);
|
||||
return 0;
|
||||
}
|
||||
@@ -244,66 +176,11 @@ el_val_t auto_term_try_slot(el_val_t slot_type, el_val_t slot_lbl) {
|
||||
if (str_eq(slot_type, EL_STR("Entity"))) {
|
||||
state_set(EL_STR("_ats_ok"), EL_STR("1"));
|
||||
}
|
||||
if (str_eq(slot_type, EL_STR("Knowledge"))) {
|
||||
state_set(EL_STR("_ats_ok"), EL_STR("1"));
|
||||
}
|
||||
if (str_contains(slot_lbl, EL_STR(":"))) {
|
||||
if (!str_contains(slot_lbl, EL_STR(" "))) {
|
||||
state_set(EL_STR("_ats_ok"), EL_STR("0"));
|
||||
}
|
||||
}
|
||||
if (str_eq(state_get(EL_STR("_ats_ok")), EL_STR("1"))) {
|
||||
if (!str_eq(slot_lbl, EL_STR(""))) {
|
||||
el_val_t sp = str_find_chars(slot_lbl, EL_STR(" :(["));
|
||||
if (sp > 3) {
|
||||
el_val_t term = str_slice(slot_lbl, 0, sp);
|
||||
state_set(EL_STR("_ats_gw"), EL_STR("0"));
|
||||
if (str_eq(term, EL_STR("Method"))) {
|
||||
state_set(EL_STR("_ats_gw"), EL_STR("1"));
|
||||
}
|
||||
if (str_eq(term, EL_STR("Theory"))) {
|
||||
state_set(EL_STR("_ats_gw"), EL_STR("1"));
|
||||
}
|
||||
if (str_eq(term, EL_STR("Finding"))) {
|
||||
state_set(EL_STR("_ats_gw"), EL_STR("1"));
|
||||
}
|
||||
if (str_eq(term, EL_STR("Survey"))) {
|
||||
state_set(EL_STR("_ats_gw"), EL_STR("1"));
|
||||
}
|
||||
if (str_eq(term, EL_STR("Paper"))) {
|
||||
state_set(EL_STR("_ats_gw"), EL_STR("1"));
|
||||
}
|
||||
if (str_eq(term, EL_STR("Knowledge"))) {
|
||||
state_set(EL_STR("_ats_gw"), EL_STR("1"));
|
||||
}
|
||||
if (str_eq(term, EL_STR("Value"))) {
|
||||
state_set(EL_STR("_ats_gw"), EL_STR("1"));
|
||||
}
|
||||
el_val_t stopw = EL_STR("|What|When|Where|Which|Whose|While|This|That|These|Those|There|Their|Then|Than|With|Without|From|Into|Onto|Over|Under|About|Between|Among|Across|Some|Most|More|Less|Very|Each|Every|Both|Also|Only|Just|Does|Will|Would|Could|Should|Might|Must|Have|Been|Being|Toward|Towards|Using|Based|Upon|Here|Your|Ours|They|Them|what|this|that|with|from|context|Context|Prose|Colon|Self|Test|Testing|Closing|Global|Universal|Persona|Semantic|Spreading|Temporal|Numeric|Register|Identifying|Introduction|Overview|Summary|Section|General|Notes|Note|");
|
||||
if (str_contains(stopw, el_str_concat(el_str_concat(EL_STR("|"), term), EL_STR("|")))) {
|
||||
state_set(EL_STR("_ats_gw"), EL_STR("1"));
|
||||
}
|
||||
if (str_contains(term, EL_STR("\""))) {
|
||||
state_set(EL_STR("_ats_gw"), EL_STR("1"));
|
||||
}
|
||||
if (str_contains(term, EL_STR("'"))) {
|
||||
state_set(EL_STR("_ats_gw"), EL_STR("1"));
|
||||
}
|
||||
if (str_eq(term, state_get(EL_STR("soul.tabu_t0")))) {
|
||||
state_set(EL_STR("_ats_gw"), EL_STR("1"));
|
||||
}
|
||||
if (str_eq(term, state_get(EL_STR("soul.tabu_t1")))) {
|
||||
state_set(EL_STR("_ats_gw"), EL_STR("1"));
|
||||
}
|
||||
if (str_eq(term, state_get(EL_STR("soul.tabu_t2")))) {
|
||||
state_set(EL_STR("_ats_gw"), EL_STR("1"));
|
||||
}
|
||||
if (str_eq(term, state_get(EL_STR("soul.tabu_t3")))) {
|
||||
state_set(EL_STR("_ats_gw"), EL_STR("1"));
|
||||
}
|
||||
if (str_eq(state_get(EL_STR("_ats_gw")), EL_STR("0"))) {
|
||||
state_set(EL_STR("cseed_auto"), term);
|
||||
}
|
||||
state_set(EL_STR("cseed_auto"), str_slice(slot_lbl, 0, sp));
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -344,12 +221,8 @@ el_val_t proactive_curiosity(void) {
|
||||
el_val_t found = json_array_len(results_all);
|
||||
el_val_t top_entry = json_array_get(results_all, 0);
|
||||
el_val_t top_id = json_get(top_entry, EL_STR("id"));
|
||||
el_val_t prev_str_id = state_get(EL_STR("soul.last_strengthen_id"));
|
||||
if (!str_eq(top_id, EL_STR(""))) {
|
||||
if (!str_eq(top_id, prev_str_id)) {
|
||||
engram_strengthen(top_id);
|
||||
}
|
||||
state_set(EL_STR("soul.last_strengthen_id"), top_id);
|
||||
engram_strengthen(top_id);
|
||||
}
|
||||
state_set(EL_STR("cseed_auto"), EL_STR(""));
|
||||
el_val_t wm10 = engram_wm_top_json(10);
|
||||
@@ -374,25 +247,13 @@ el_val_t proactive_curiosity(void) {
|
||||
auto_term_try_slot(json_get(wm10_n1, EL_STR("node_type")), json_get(wm10_n1, EL_STR("label")));
|
||||
auto_term_try_slot(json_get(wm10_n0, EL_STR("node_type")), json_get(wm10_n0, EL_STR("label")));
|
||||
el_val_t auto_term = state_get(EL_STR("cseed_auto"));
|
||||
el_val_t results_auto = ({ el_val_t _if_result_47 = 0; if (str_eq(auto_term, EL_STR(""))) { _if_result_47 = (EL_STR("[]")); } else { _if_result_47 = (engram_activate_json(auto_term, 1)); } _if_result_47; });
|
||||
el_val_t results_auto = ({ el_val_t _if_result_11 = 0; if (str_eq(auto_term, EL_STR(""))) { _if_result_11 = (EL_STR("[]")); } else { _if_result_11 = (engram_activate_json(auto_term, 1)); } _if_result_11; });
|
||||
el_val_t found_auto = json_array_len(results_auto);
|
||||
el_val_t total_found = (found + found_auto);
|
||||
el_val_t safe_auto = str_replace(auto_term, EL_STR("\""), EL_STR("'"));
|
||||
el_val_t prev_auto = state_get(EL_STR("soul.prev_auto_term"));
|
||||
el_val_t atstreak_raw = state_get(EL_STR("soul.auto_term_streak"));
|
||||
el_val_t atstreak_prev = ({ el_val_t _if_result_48 = 0; if (str_eq(atstreak_raw, EL_STR(""))) { _if_result_48 = (0); } else { _if_result_48 = (str_to_int(atstreak_raw)); } _if_result_48; });
|
||||
el_val_t atstreak = ({ el_val_t _if_result_49 = 0; if (str_eq(auto_term, prev_auto)) { _if_result_49 = ((atstreak_prev + 1)); } else { _if_result_49 = (1); } _if_result_49; });
|
||||
state_set(EL_STR("soul.prev_auto_term"), auto_term);
|
||||
state_set(EL_STR("soul.auto_term_streak"), int_to_str(atstreak));
|
||||
if (!str_eq(auto_term, EL_STR(""))) {
|
||||
state_set(EL_STR("soul.tabu_t3"), state_get(EL_STR("soul.tabu_t2")));
|
||||
state_set(EL_STR("soul.tabu_t2"), state_get(EL_STR("soul.tabu_t1")));
|
||||
state_set(EL_STR("soul.tabu_t1"), state_get(EL_STR("soul.tabu_t0")));
|
||||
state_set(EL_STR("soul.tabu_t0"), auto_term);
|
||||
}
|
||||
el_val_t wmc = engram_wm_count();
|
||||
el_val_t wm3 = engram_wm_top_json(3);
|
||||
el_val_t ise = el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"event\":\"curiosity_scan\",\"seed\":\""), curiosity_seed), EL_STR("\",\"auto_term\":\"")), safe_auto), EL_STR("\",\"auto_term_streak\":")), int_to_str(atstreak)), EL_STR(",\"minute_block\":")), int_to_str(minute_block)), EL_STR(",\"activated\":")), int_to_str(total_found)), EL_STR(",\"wm_active\":")), int_to_str(wmc)), EL_STR(",\"wm_top\":")), wm3), EL_STR(",\"ts\":")), int_to_str(ts)), EL_STR("}"));
|
||||
el_val_t ise = el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"event\":\"curiosity_scan\",\"seed\":\""), curiosity_seed), EL_STR("\",\"auto_term\":\"")), safe_auto), EL_STR("\",\"minute_block\":")), int_to_str(minute_block)), EL_STR(",\"activated\":")), int_to_str(total_found)), EL_STR(",\"wm_active\":")), int_to_str(wmc)), EL_STR(",\"wm_top\":")), wm3), EL_STR(",\"ts\":")), int_to_str(ts)), EL_STR("}"));
|
||||
ise_post(ise);
|
||||
return (total_found > 0);
|
||||
return 0;
|
||||
@@ -575,17 +436,14 @@ el_val_t awareness_run(void) {
|
||||
state_set(EL_STR("soul.boot_ts"), int_to_str(time_now()));
|
||||
}
|
||||
el_val_t tick_raw = env(EL_STR("SOUL_TICK_MS"));
|
||||
el_val_t tick_ms = ({ el_val_t _if_result_50 = 0; if (str_eq(tick_raw, EL_STR(""))) { _if_result_50 = (200); } else { _if_result_50 = (str_to_int(tick_raw)); } _if_result_50; });
|
||||
el_val_t tick_ms = ({ el_val_t _if_result_12 = 0; if (str_eq(tick_raw, EL_STR(""))) { _if_result_12 = (200); } else { _if_result_12 = (str_to_int(tick_raw)); } _if_result_12; });
|
||||
el_val_t beat_ms_raw = env(EL_STR("SOUL_HEARTBEAT_MS"));
|
||||
el_val_t beat_ms = ({ el_val_t _if_result_51 = 0; if (str_eq(beat_ms_raw, EL_STR(""))) { _if_result_51 = (60000); } else { _if_result_51 = (str_to_int(beat_ms_raw)); } _if_result_51; });
|
||||
el_val_t beat_ms = ({ el_val_t _if_result_13 = 0; if (str_eq(beat_ms_raw, EL_STR(""))) { _if_result_13 = (60000); } else { _if_result_13 = (str_to_int(beat_ms_raw)); } _if_result_13; });
|
||||
el_val_t scan_ms = (beat_ms / 2);
|
||||
while (1) {
|
||||
el_val_t tick_mark = el_arena_push();
|
||||
el_val_t running = state_get(EL_STR("soul.running"));
|
||||
if (str_eq(running, EL_STR("false"))) {
|
||||
el_val_t sd_boot_raw = state_get(EL_STR("soul_boot_count"));
|
||||
el_val_t sd_boot = ({ el_val_t _if_result_52 = 0; if (str_eq(sd_boot_raw, EL_STR(""))) { _if_result_52 = (EL_STR("0")); } else { _if_result_52 = (sd_boot_raw); } _if_result_52; });
|
||||
ise_post(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"event\":\"shutdown\",\"boot\":"), sd_boot), EL_STR(",\"pulse\":")), int_to_str(pulse_count())), EL_STR(",\"uptime_ms\":")), int_to_str(elapsed_ms())), EL_STR(",\"ts\":")), int_to_str(time_now())), EL_STR("}")));
|
||||
println(EL_STR("[awareness] exiting"));
|
||||
el_arena_pop(tick_mark);
|
||||
return EL_STR("");
|
||||
@@ -600,7 +458,7 @@ el_val_t awareness_run(void) {
|
||||
}
|
||||
el_val_t now_ts = time_now();
|
||||
el_val_t last_beat_str = state_get(EL_STR("soul.last_beat_ts"));
|
||||
el_val_t last_beat_ts = ({ el_val_t _if_result_53 = 0; if (str_eq(last_beat_str, EL_STR(""))) { _if_result_53 = (0); } else { _if_result_53 = (str_to_int(last_beat_str)); } _if_result_53; });
|
||||
el_val_t last_beat_ts = ({ el_val_t _if_result_14 = 0; if (str_eq(last_beat_str, EL_STR(""))) { _if_result_14 = (0); } else { _if_result_14 = (str_to_int(last_beat_str)); } _if_result_14; });
|
||||
el_val_t beat_elapsed = (now_ts - last_beat_ts);
|
||||
el_val_t should_beat = (beat_elapsed >= beat_ms);
|
||||
if (should_beat) {
|
||||
@@ -612,7 +470,7 @@ el_val_t awareness_run(void) {
|
||||
}
|
||||
}
|
||||
el_val_t last_scan_str = state_get(EL_STR("soul.last_scan_ts"));
|
||||
el_val_t last_scan_ts = ({ el_val_t _if_result_54 = 0; if (str_eq(last_scan_str, EL_STR(""))) { _if_result_54 = (0); } else { _if_result_54 = (str_to_int(last_scan_str)); } _if_result_54; });
|
||||
el_val_t last_scan_ts = ({ el_val_t _if_result_15 = 0; if (str_eq(last_scan_str, EL_STR(""))) { _if_result_15 = (0); } else { _if_result_15 = (str_to_int(last_scan_str)); } _if_result_15; });
|
||||
el_val_t scan_elapsed = (now_ts - last_scan_ts);
|
||||
el_val_t should_scan = (!did_work && (scan_elapsed >= scan_ms));
|
||||
if (should_scan) {
|
||||
@@ -620,31 +478,25 @@ el_val_t awareness_run(void) {
|
||||
state_set(EL_STR("soul.last_scan_ts"), int_to_str(now_ts));
|
||||
}
|
||||
el_val_t refresh_ms_raw = env(EL_STR("SOUL_REFRESH_MS"));
|
||||
el_val_t refresh_ms = ({ el_val_t _if_result_55 = 0; if (str_eq(refresh_ms_raw, EL_STR(""))) { _if_result_55 = (600000); } else { _if_result_55 = (str_to_int(refresh_ms_raw)); } _if_result_55; });
|
||||
el_val_t refresh_ms = ({ el_val_t _if_result_16 = 0; if (str_eq(refresh_ms_raw, EL_STR(""))) { _if_result_16 = (600000); } else { _if_result_16 = (str_to_int(refresh_ms_raw)); } _if_result_16; });
|
||||
el_val_t last_refresh_str = state_get(EL_STR("soul.last_refresh_ts"));
|
||||
el_val_t last_refresh_ts = ({ el_val_t _if_result_56 = 0; if (str_eq(last_refresh_str, EL_STR(""))) { _if_result_56 = (0); } else { _if_result_56 = (str_to_int(last_refresh_str)); } _if_result_56; });
|
||||
el_val_t last_refresh_ts = ({ el_val_t _if_result_17 = 0; if (str_eq(last_refresh_str, EL_STR(""))) { _if_result_17 = (0); } else { _if_result_17 = (str_to_int(last_refresh_str)); } _if_result_17; });
|
||||
el_val_t refresh_elapsed = (now_ts - last_refresh_ts);
|
||||
el_val_t should_refresh = (refresh_elapsed >= refresh_ms);
|
||||
if (should_refresh) {
|
||||
el_val_t sync_env_url = env(EL_STR("SOUL_ISE_URL"));
|
||||
el_val_t sync_state_url = ({ el_val_t _if_result_57 = 0; if (str_eq(sync_env_url, EL_STR(""))) { _if_result_57 = (state_get(EL_STR("soul_engram_url"))); } else { _if_result_57 = (sync_env_url); } _if_result_57; });
|
||||
el_val_t engram_url = ({ el_val_t _if_result_58 = 0; if (str_eq(sync_state_url, EL_STR(""))) { _if_result_58 = (EL_STR("http://localhost:8742")); } else { _if_result_58 = (sync_state_url); } _if_result_58; });
|
||||
el_val_t sync_state_url = ({ el_val_t _if_result_18 = 0; if (str_eq(sync_env_url, EL_STR(""))) { _if_result_18 = (state_get(EL_STR("soul_engram_url"))); } else { _if_result_18 = (sync_env_url); } _if_result_18; });
|
||||
el_val_t engram_url = ({ el_val_t _if_result_19 = 0; if (str_eq(sync_state_url, EL_STR(""))) { _if_result_19 = (EL_STR("http://localhost:8742")); } else { _if_result_19 = (sync_state_url); } _if_result_19; });
|
||||
if (!str_eq(engram_url, EL_STR(""))) {
|
||||
el_val_t sync_json = http_get(el_str_concat(engram_url, EL_STR("/api/sync")));
|
||||
el_val_t sync_ok = (!str_eq(sync_json, EL_STR("")) && !str_eq(sync_json, EL_STR("{}")));
|
||||
if (!sync_ok) {
|
||||
ise_post(el_str_concat(el_str_concat(EL_STR("{\"event\":\"sync_empty\",\"ts\":"), int_to_str(time_now())), EL_STR("}")));
|
||||
}
|
||||
if (sync_ok) {
|
||||
if (!str_eq(sync_json, EL_STR("")) && !str_eq(sync_json, EL_STR("{}"))) {
|
||||
el_val_t cgi_id = state_get(EL_STR("soul_cgi_id"));
|
||||
el_val_t tmp = el_str_concat(el_str_concat(EL_STR("/tmp/soul-sync-"), cgi_id), EL_STR(".json"));
|
||||
fs_write(tmp, sync_json);
|
||||
el_val_t added = engram_load_merge(tmp);
|
||||
el_val_t ret_raw = env(EL_STR("ENGRAM_ISE_RETENTION_MS"));
|
||||
el_val_t ret_ms = ({ el_val_t _if_result_59 = 0; if (str_eq(ret_raw, EL_STR(""))) { _if_result_59 = (172800000); } else { _if_result_59 = (str_to_int(ret_raw)); } _if_result_59; });
|
||||
el_val_t pruned_sync = engram_prune_telemetry(ret_ms);
|
||||
el_val_t pruned_sync = engram_prune_telemetry(172800000);
|
||||
el_val_t sat_raw = state_get(EL_STR("soul.sync_added_total"));
|
||||
el_val_t sat_n = ({ el_val_t _if_result_60 = 0; if (str_eq(sat_raw, EL_STR(""))) { _if_result_60 = (0); } else { _if_result_60 = (str_to_int(sat_raw)); } _if_result_60; });
|
||||
el_val_t sat_n = ({ el_val_t _if_result_20 = 0; if (str_eq(sat_raw, EL_STR(""))) { _if_result_20 = (0); } else { _if_result_20 = (str_to_int(sat_raw)); } _if_result_20; });
|
||||
state_set(EL_STR("soul.sync_added_total"), int_to_str((sat_n + added)));
|
||||
el_val_t ts2 = time_now();
|
||||
state_set(EL_STR("soul.last_sync_ok_ts"), int_to_str(ts2));
|
||||
@@ -670,78 +522,78 @@ el_val_t security_research_authorized(void) {
|
||||
}
|
||||
|
||||
el_val_t threat_score_command(el_val_t cmd) {
|
||||
el_val_t s1 = ({ el_val_t _if_result_61 = 0; if (str_contains(cmd, EL_STR("nmap"))) { _if_result_61 = (30); } else { _if_result_61 = (0); } _if_result_61; });
|
||||
el_val_t s2 = ({ el_val_t _if_result_62 = 0; if (str_contains(cmd, EL_STR("masscan"))) { _if_result_62 = (40); } else { _if_result_62 = (0); } _if_result_62; });
|
||||
el_val_t s3 = ({ el_val_t _if_result_63 = 0; if (str_contains(cmd, EL_STR(" nc "))) { _if_result_63 = (20); } else { _if_result_63 = (0); } _if_result_63; });
|
||||
el_val_t s4 = ({ el_val_t _if_result_64 = 0; if (str_contains(cmd, EL_STR("netcat"))) { _if_result_64 = (20); } else { _if_result_64 = (0); } _if_result_64; });
|
||||
el_val_t s5 = ({ el_val_t _if_result_65 = 0; if (str_contains(cmd, EL_STR("/etc/shadow"))) { _if_result_65 = (80); } else { _if_result_65 = (0); } _if_result_65; });
|
||||
el_val_t s6 = ({ el_val_t _if_result_66 = 0; if (str_contains(cmd, EL_STR("/etc/passwd"))) { _if_result_66 = (30); } else { _if_result_66 = (0); } _if_result_66; });
|
||||
el_val_t s7 = ({ el_val_t _if_result_67 = 0; if (str_contains(cmd, EL_STR("id_rsa"))) { _if_result_67 = (60); } else { _if_result_67 = (0); } _if_result_67; });
|
||||
el_val_t s8 = ({ el_val_t _if_result_68 = 0; if (str_contains(cmd, EL_STR(".ssh/"))) { _if_result_68 = (50); } else { _if_result_68 = (0); } _if_result_68; });
|
||||
el_val_t s9 = ({ el_val_t _if_result_69 = 0; if (str_contains(cmd, EL_STR("crontab"))) { _if_result_69 = (30); } else { _if_result_69 = (0); } _if_result_69; });
|
||||
el_val_t s10 = ({ el_val_t _if_result_70 = 0; if (str_contains(cmd, EL_STR("LaunchDaemon"))) { _if_result_70 = (40); } else { _if_result_70 = (0); } _if_result_70; });
|
||||
el_val_t s11 = ({ el_val_t _if_result_71 = 0; if ((str_contains(cmd, EL_STR("curl")) && str_contains(cmd, EL_STR("bash")))) { _if_result_71 = (75); } else { _if_result_71 = (0); } _if_result_71; });
|
||||
el_val_t s12 = ({ el_val_t _if_result_72 = 0; if ((str_contains(cmd, EL_STR("wget")) && str_contains(cmd, EL_STR("bash")))) { _if_result_72 = (75); } else { _if_result_72 = (0); } _if_result_72; });
|
||||
el_val_t s13 = ({ el_val_t _if_result_73 = 0; if ((str_contains(cmd, EL_STR("curl")) && str_contains(cmd, EL_STR("| sh")))) { _if_result_73 = (60); } else { _if_result_73 = (0); } _if_result_73; });
|
||||
el_val_t s14 = ({ el_val_t _if_result_74 = 0; if ((str_contains(cmd, EL_STR("base64")) && str_contains(cmd, EL_STR("curl")))) { _if_result_74 = (50); } else { _if_result_74 = (0); } _if_result_74; });
|
||||
el_val_t s15 = ({ el_val_t _if_result_75 = 0; if (str_contains(cmd, EL_STR("mkfifo"))) { _if_result_75 = (50); } else { _if_result_75 = (0); } _if_result_75; });
|
||||
el_val_t s16 = ({ el_val_t _if_result_76 = 0; if (str_contains(cmd, EL_STR("chmod +s"))) { _if_result_76 = (70); } else { _if_result_76 = (0); } _if_result_76; });
|
||||
el_val_t s17 = ({ el_val_t _if_result_77 = 0; if (str_contains(cmd, EL_STR("chmod 4755"))) { _if_result_77 = (70); } else { _if_result_77 = (0); } _if_result_77; });
|
||||
el_val_t s1 = ({ el_val_t _if_result_21 = 0; if (str_contains(cmd, EL_STR("nmap"))) { _if_result_21 = (30); } else { _if_result_21 = (0); } _if_result_21; });
|
||||
el_val_t s2 = ({ el_val_t _if_result_22 = 0; if (str_contains(cmd, EL_STR("masscan"))) { _if_result_22 = (40); } else { _if_result_22 = (0); } _if_result_22; });
|
||||
el_val_t s3 = ({ el_val_t _if_result_23 = 0; if (str_contains(cmd, EL_STR(" nc "))) { _if_result_23 = (20); } else { _if_result_23 = (0); } _if_result_23; });
|
||||
el_val_t s4 = ({ el_val_t _if_result_24 = 0; if (str_contains(cmd, EL_STR("netcat"))) { _if_result_24 = (20); } else { _if_result_24 = (0); } _if_result_24; });
|
||||
el_val_t s5 = ({ el_val_t _if_result_25 = 0; if (str_contains(cmd, EL_STR("/etc/shadow"))) { _if_result_25 = (80); } else { _if_result_25 = (0); } _if_result_25; });
|
||||
el_val_t s6 = ({ el_val_t _if_result_26 = 0; if (str_contains(cmd, EL_STR("/etc/passwd"))) { _if_result_26 = (30); } else { _if_result_26 = (0); } _if_result_26; });
|
||||
el_val_t s7 = ({ el_val_t _if_result_27 = 0; if (str_contains(cmd, EL_STR("id_rsa"))) { _if_result_27 = (60); } else { _if_result_27 = (0); } _if_result_27; });
|
||||
el_val_t s8 = ({ el_val_t _if_result_28 = 0; if (str_contains(cmd, EL_STR(".ssh/"))) { _if_result_28 = (50); } else { _if_result_28 = (0); } _if_result_28; });
|
||||
el_val_t s9 = ({ el_val_t _if_result_29 = 0; if (str_contains(cmd, EL_STR("crontab"))) { _if_result_29 = (30); } else { _if_result_29 = (0); } _if_result_29; });
|
||||
el_val_t s10 = ({ el_val_t _if_result_30 = 0; if (str_contains(cmd, EL_STR("LaunchDaemon"))) { _if_result_30 = (40); } else { _if_result_30 = (0); } _if_result_30; });
|
||||
el_val_t s11 = ({ el_val_t _if_result_31 = 0; if ((str_contains(cmd, EL_STR("curl")) && str_contains(cmd, EL_STR("bash")))) { _if_result_31 = (75); } else { _if_result_31 = (0); } _if_result_31; });
|
||||
el_val_t s12 = ({ el_val_t _if_result_32 = 0; if ((str_contains(cmd, EL_STR("wget")) && str_contains(cmd, EL_STR("bash")))) { _if_result_32 = (75); } else { _if_result_32 = (0); } _if_result_32; });
|
||||
el_val_t s13 = ({ el_val_t _if_result_33 = 0; if ((str_contains(cmd, EL_STR("curl")) && str_contains(cmd, EL_STR("| sh")))) { _if_result_33 = (60); } else { _if_result_33 = (0); } _if_result_33; });
|
||||
el_val_t s14 = ({ el_val_t _if_result_34 = 0; if ((str_contains(cmd, EL_STR("base64")) && str_contains(cmd, EL_STR("curl")))) { _if_result_34 = (50); } else { _if_result_34 = (0); } _if_result_34; });
|
||||
el_val_t s15 = ({ el_val_t _if_result_35 = 0; if (str_contains(cmd, EL_STR("mkfifo"))) { _if_result_35 = (50); } else { _if_result_35 = (0); } _if_result_35; });
|
||||
el_val_t s16 = ({ el_val_t _if_result_36 = 0; if (str_contains(cmd, EL_STR("chmod +s"))) { _if_result_36 = (70); } else { _if_result_36 = (0); } _if_result_36; });
|
||||
el_val_t s17 = ({ el_val_t _if_result_37 = 0; if (str_contains(cmd, EL_STR("chmod 4755"))) { _if_result_37 = (70); } else { _if_result_37 = (0); } _if_result_37; });
|
||||
return ((((((((((((((((s1 + s2) + s3) + s4) + s5) + s6) + s7) + s8) + s9) + s10) + s11) + s12) + s13) + s14) + s15) + s16) + s17);
|
||||
return 0;
|
||||
}
|
||||
|
||||
el_val_t threat_score_path(el_val_t path) {
|
||||
el_val_t s1 = ({ el_val_t _if_result_78 = 0; if (str_starts_with(path, EL_STR("/etc/"))) { _if_result_78 = (60); } else { _if_result_78 = (0); } _if_result_78; });
|
||||
el_val_t s2 = ({ el_val_t _if_result_79 = 0; if (str_contains(path, EL_STR("/.ssh/"))) { _if_result_79 = (70); } else { _if_result_79 = (0); } _if_result_79; });
|
||||
el_val_t s3 = ({ el_val_t _if_result_80 = 0; if (str_contains(path, EL_STR("/LaunchDaemons/"))) { _if_result_80 = (80); } else { _if_result_80 = (0); } _if_result_80; });
|
||||
el_val_t s4 = ({ el_val_t _if_result_81 = 0; if (str_contains(path, EL_STR("/LaunchAgents/"))) { _if_result_81 = (40); } else { _if_result_81 = (0); } _if_result_81; });
|
||||
el_val_t s5 = ({ el_val_t _if_result_82 = 0; if (str_contains(path, EL_STR("/cron"))) { _if_result_82 = (60); } else { _if_result_82 = (0); } _if_result_82; });
|
||||
el_val_t s6 = ({ el_val_t _if_result_83 = 0; if (str_contains(path, EL_STR("/.bashrc"))) { _if_result_83 = (35); } else { _if_result_83 = (0); } _if_result_83; });
|
||||
el_val_t s7 = ({ el_val_t _if_result_84 = 0; if (str_contains(path, EL_STR("/.zshrc"))) { _if_result_84 = (35); } else { _if_result_84 = (0); } _if_result_84; });
|
||||
el_val_t s8 = ({ el_val_t _if_result_85 = 0; if (str_contains(path, EL_STR("/.profile"))) { _if_result_85 = (35); } else { _if_result_85 = (0); } _if_result_85; });
|
||||
el_val_t s9 = ({ el_val_t _if_result_86 = 0; if (str_starts_with(path, EL_STR("/usr/"))) { _if_result_86 = (50); } else { _if_result_86 = (0); } _if_result_86; });
|
||||
el_val_t s10 = ({ el_val_t _if_result_87 = 0; if (str_starts_with(path, EL_STR("/bin/"))) { _if_result_87 = (70); } else { _if_result_87 = (0); } _if_result_87; });
|
||||
el_val_t s11 = ({ el_val_t _if_result_88 = 0; if (str_starts_with(path, EL_STR("/sbin/"))) { _if_result_88 = (70); } else { _if_result_88 = (0); } _if_result_88; });
|
||||
el_val_t s1 = ({ el_val_t _if_result_38 = 0; if (str_starts_with(path, EL_STR("/etc/"))) { _if_result_38 = (60); } else { _if_result_38 = (0); } _if_result_38; });
|
||||
el_val_t s2 = ({ el_val_t _if_result_39 = 0; if (str_contains(path, EL_STR("/.ssh/"))) { _if_result_39 = (70); } else { _if_result_39 = (0); } _if_result_39; });
|
||||
el_val_t s3 = ({ el_val_t _if_result_40 = 0; if (str_contains(path, EL_STR("/LaunchDaemons/"))) { _if_result_40 = (80); } else { _if_result_40 = (0); } _if_result_40; });
|
||||
el_val_t s4 = ({ el_val_t _if_result_41 = 0; if (str_contains(path, EL_STR("/LaunchAgents/"))) { _if_result_41 = (40); } else { _if_result_41 = (0); } _if_result_41; });
|
||||
el_val_t s5 = ({ el_val_t _if_result_42 = 0; if (str_contains(path, EL_STR("/cron"))) { _if_result_42 = (60); } else { _if_result_42 = (0); } _if_result_42; });
|
||||
el_val_t s6 = ({ el_val_t _if_result_43 = 0; if (str_contains(path, EL_STR("/.bashrc"))) { _if_result_43 = (35); } else { _if_result_43 = (0); } _if_result_43; });
|
||||
el_val_t s7 = ({ el_val_t _if_result_44 = 0; if (str_contains(path, EL_STR("/.zshrc"))) { _if_result_44 = (35); } else { _if_result_44 = (0); } _if_result_44; });
|
||||
el_val_t s8 = ({ el_val_t _if_result_45 = 0; if (str_contains(path, EL_STR("/.profile"))) { _if_result_45 = (35); } else { _if_result_45 = (0); } _if_result_45; });
|
||||
el_val_t s9 = ({ el_val_t _if_result_46 = 0; if (str_starts_with(path, EL_STR("/usr/"))) { _if_result_46 = (50); } else { _if_result_46 = (0); } _if_result_46; });
|
||||
el_val_t s10 = ({ el_val_t _if_result_47 = 0; if (str_starts_with(path, EL_STR("/bin/"))) { _if_result_47 = (70); } else { _if_result_47 = (0); } _if_result_47; });
|
||||
el_val_t s11 = ({ el_val_t _if_result_48 = 0; if (str_starts_with(path, EL_STR("/sbin/"))) { _if_result_48 = (70); } else { _if_result_48 = (0); } _if_result_48; });
|
||||
return ((((((((((s1 + s2) + s3) + s4) + s5) + s6) + s7) + s8) + s9) + s10) + s11);
|
||||
return 0;
|
||||
}
|
||||
|
||||
el_val_t threat_score_history(el_val_t history) {
|
||||
el_val_t s1 = ({ el_val_t _if_result_89 = 0; if (str_contains(history, EL_STR("port scan"))) { _if_result_89 = (15); } else { _if_result_89 = (0); } _if_result_89; });
|
||||
el_val_t s2 = ({ el_val_t _if_result_90 = 0; if (str_contains(history, EL_STR("enumerate"))) { _if_result_90 = (10); } else { _if_result_90 = (0); } _if_result_90; });
|
||||
el_val_t s3 = ({ el_val_t _if_result_91 = 0; if (str_contains(history, EL_STR("exploit"))) { _if_result_91 = (20); } else { _if_result_91 = (0); } _if_result_91; });
|
||||
el_val_t s4 = ({ el_val_t _if_result_92 = 0; if (str_contains(history, EL_STR("payload"))) { _if_result_92 = (15); } else { _if_result_92 = (0); } _if_result_92; });
|
||||
el_val_t s5 = ({ el_val_t _if_result_93 = 0; if (str_contains(history, EL_STR("persistence"))) { _if_result_93 = (15); } else { _if_result_93 = (0); } _if_result_93; });
|
||||
el_val_t s6 = ({ el_val_t _if_result_94 = 0; if (str_contains(history, EL_STR("lateral movement"))) { _if_result_94 = (25); } else { _if_result_94 = (0); } _if_result_94; });
|
||||
el_val_t s7 = ({ el_val_t _if_result_95 = 0; if (str_contains(history, EL_STR("privilege escalation"))) { _if_result_95 = (25); } else { _if_result_95 = (0); } _if_result_95; });
|
||||
el_val_t s8 = ({ el_val_t _if_result_96 = 0; if (str_contains(history, EL_STR("reverse shell"))) { _if_result_96 = (40); } else { _if_result_96 = (0); } _if_result_96; });
|
||||
el_val_t s9 = ({ el_val_t _if_result_97 = 0; if (str_contains(history, EL_STR("bind shell"))) { _if_result_97 = (40); } else { _if_result_97 = (0); } _if_result_97; });
|
||||
el_val_t s10 = ({ el_val_t _if_result_98 = 0; if (str_contains(history, EL_STR("command and control"))) { _if_result_98 = (35); } else { _if_result_98 = (0); } _if_result_98; });
|
||||
el_val_t s11 = ({ el_val_t _if_result_99 = 0; if (str_contains(history, EL_STR("self-replicate"))) { _if_result_99 = (45); } else { _if_result_99 = (0); } _if_result_99; });
|
||||
el_val_t s12 = ({ el_val_t _if_result_100 = 0; if (str_contains(history, EL_STR("propagat"))) { _if_result_100 = (20); } else { _if_result_100 = (0); } _if_result_100; });
|
||||
el_val_t s13 = ({ el_val_t _if_result_101 = 0; if (str_contains(history, EL_STR("ransomware"))) { _if_result_101 = (30); } else { _if_result_101 = (0); } _if_result_101; });
|
||||
el_val_t s14 = ({ el_val_t _if_result_102 = 0; if (str_contains(history, EL_STR("encrypt files"))) { _if_result_102 = (40); } else { _if_result_102 = (0); } _if_result_102; });
|
||||
el_val_t s15 = ({ el_val_t _if_result_103 = 0; if (str_contains(history, EL_STR("exfiltrat"))) { _if_result_103 = (35); } else { _if_result_103 = (0); } _if_result_103; });
|
||||
el_val_t s16 = ({ el_val_t _if_result_104 = 0; if (str_contains(history, EL_STR("zero-day"))) { _if_result_104 = (20); } else { _if_result_104 = (0); } _if_result_104; });
|
||||
el_val_t s17 = ({ el_val_t _if_result_105 = 0; if (str_contains(history, EL_STR("rootkit"))) { _if_result_105 = (45); } else { _if_result_105 = (0); } _if_result_105; });
|
||||
el_val_t s18 = ({ el_val_t _if_result_106 = 0; if (str_contains(history, EL_STR("keylogger"))) { _if_result_106 = (45); } else { _if_result_106 = (0); } _if_result_106; });
|
||||
el_val_t s19 = ({ el_val_t _if_result_107 = 0; if (str_contains(history, EL_STR("botnet"))) { _if_result_107 = (40); } else { _if_result_107 = (0); } _if_result_107; });
|
||||
el_val_t s20 = ({ el_val_t _if_result_108 = 0; if (str_contains(history, EL_STR("malware"))) { _if_result_108 = (15); } else { _if_result_108 = (0); } _if_result_108; });
|
||||
el_val_t s1 = ({ el_val_t _if_result_49 = 0; if (str_contains(history, EL_STR("port scan"))) { _if_result_49 = (15); } else { _if_result_49 = (0); } _if_result_49; });
|
||||
el_val_t s2 = ({ el_val_t _if_result_50 = 0; if (str_contains(history, EL_STR("enumerate"))) { _if_result_50 = (10); } else { _if_result_50 = (0); } _if_result_50; });
|
||||
el_val_t s3 = ({ el_val_t _if_result_51 = 0; if (str_contains(history, EL_STR("exploit"))) { _if_result_51 = (20); } else { _if_result_51 = (0); } _if_result_51; });
|
||||
el_val_t s4 = ({ el_val_t _if_result_52 = 0; if (str_contains(history, EL_STR("payload"))) { _if_result_52 = (15); } else { _if_result_52 = (0); } _if_result_52; });
|
||||
el_val_t s5 = ({ el_val_t _if_result_53 = 0; if (str_contains(history, EL_STR("persistence"))) { _if_result_53 = (15); } else { _if_result_53 = (0); } _if_result_53; });
|
||||
el_val_t s6 = ({ el_val_t _if_result_54 = 0; if (str_contains(history, EL_STR("lateral movement"))) { _if_result_54 = (25); } else { _if_result_54 = (0); } _if_result_54; });
|
||||
el_val_t s7 = ({ el_val_t _if_result_55 = 0; if (str_contains(history, EL_STR("privilege escalation"))) { _if_result_55 = (25); } else { _if_result_55 = (0); } _if_result_55; });
|
||||
el_val_t s8 = ({ el_val_t _if_result_56 = 0; if (str_contains(history, EL_STR("reverse shell"))) { _if_result_56 = (40); } else { _if_result_56 = (0); } _if_result_56; });
|
||||
el_val_t s9 = ({ el_val_t _if_result_57 = 0; if (str_contains(history, EL_STR("bind shell"))) { _if_result_57 = (40); } else { _if_result_57 = (0); } _if_result_57; });
|
||||
el_val_t s10 = ({ el_val_t _if_result_58 = 0; if (str_contains(history, EL_STR("command and control"))) { _if_result_58 = (35); } else { _if_result_58 = (0); } _if_result_58; });
|
||||
el_val_t s11 = ({ el_val_t _if_result_59 = 0; if (str_contains(history, EL_STR("self-replicate"))) { _if_result_59 = (45); } else { _if_result_59 = (0); } _if_result_59; });
|
||||
el_val_t s12 = ({ el_val_t _if_result_60 = 0; if (str_contains(history, EL_STR("propagat"))) { _if_result_60 = (20); } else { _if_result_60 = (0); } _if_result_60; });
|
||||
el_val_t s13 = ({ el_val_t _if_result_61 = 0; if (str_contains(history, EL_STR("ransomware"))) { _if_result_61 = (30); } else { _if_result_61 = (0); } _if_result_61; });
|
||||
el_val_t s14 = ({ el_val_t _if_result_62 = 0; if (str_contains(history, EL_STR("encrypt files"))) { _if_result_62 = (40); } else { _if_result_62 = (0); } _if_result_62; });
|
||||
el_val_t s15 = ({ el_val_t _if_result_63 = 0; if (str_contains(history, EL_STR("exfiltrat"))) { _if_result_63 = (35); } else { _if_result_63 = (0); } _if_result_63; });
|
||||
el_val_t s16 = ({ el_val_t _if_result_64 = 0; if (str_contains(history, EL_STR("zero-day"))) { _if_result_64 = (20); } else { _if_result_64 = (0); } _if_result_64; });
|
||||
el_val_t s17 = ({ el_val_t _if_result_65 = 0; if (str_contains(history, EL_STR("rootkit"))) { _if_result_65 = (45); } else { _if_result_65 = (0); } _if_result_65; });
|
||||
el_val_t s18 = ({ el_val_t _if_result_66 = 0; if (str_contains(history, EL_STR("keylogger"))) { _if_result_66 = (45); } else { _if_result_66 = (0); } _if_result_66; });
|
||||
el_val_t s19 = ({ el_val_t _if_result_67 = 0; if (str_contains(history, EL_STR("botnet"))) { _if_result_67 = (40); } else { _if_result_67 = (0); } _if_result_67; });
|
||||
el_val_t s20 = ({ el_val_t _if_result_68 = 0; if (str_contains(history, EL_STR("malware"))) { _if_result_68 = (15); } else { _if_result_68 = (0); } _if_result_68; });
|
||||
return (((((((((((((((((((s1 + s2) + s3) + s4) + s5) + s6) + s7) + s8) + s9) + s10) + s11) + s12) + s13) + s14) + s15) + s16) + s17) + s18) + s19) + s20);
|
||||
return 0;
|
||||
}
|
||||
|
||||
el_val_t threat_trajectory_check(el_val_t tool_name, el_val_t tool_input) {
|
||||
el_val_t history = state_get(EL_STR("agentic_conv_history"));
|
||||
el_val_t computed_tool_score = ({ el_val_t _if_result_109 = 0; if (str_eq(tool_name, EL_STR("run_command"))) { el_val_t cmd = json_get(tool_input, EL_STR("command")); _if_result_109 = (threat_score_command(cmd)); } else { _if_result_109 = (({ el_val_t _if_result_110 = 0; if ((str_eq(tool_name, EL_STR("write_file")) || str_eq(tool_name, EL_STR("edit_file")))) { el_val_t path = json_get(tool_input, EL_STR("path")); _if_result_110 = (threat_score_path(path)); } else { _if_result_110 = (0); } _if_result_110; })); } _if_result_109; });
|
||||
el_val_t computed_tool_score = ({ el_val_t _if_result_69 = 0; if (str_eq(tool_name, EL_STR("run_command"))) { el_val_t cmd = json_get(tool_input, EL_STR("command")); _if_result_69 = (threat_score_command(cmd)); } else { _if_result_69 = (({ el_val_t _if_result_70 = 0; if ((str_eq(tool_name, EL_STR("write_file")) || str_eq(tool_name, EL_STR("edit_file")))) { el_val_t path = json_get(tool_input, EL_STR("path")); _if_result_70 = (threat_score_path(path)); } else { _if_result_70 = (0); } _if_result_70; })); } _if_result_69; });
|
||||
el_val_t history_score = threat_score_history(history);
|
||||
el_val_t history_contrib = (history_score / 3);
|
||||
el_val_t combined = (computed_tool_score + history_contrib);
|
||||
el_val_t should_log = (combined >= 40);
|
||||
if (should_log) {
|
||||
el_val_t ts = time_now();
|
||||
el_val_t authorized_str = ({ el_val_t _if_result_111 = 0; if (security_research_authorized()) { _if_result_111 = (EL_STR("true")); } else { _if_result_111 = (EL_STR("false")); } _if_result_111; });
|
||||
el_val_t authorized_str = ({ el_val_t _if_result_71 = 0; if (security_research_authorized()) { _if_result_71 = (EL_STR("true")); } else { _if_result_71 = (EL_STR("false")); } _if_result_71; });
|
||||
el_val_t log_content = el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"event\":\"threat_check\",\"tool\":\""), tool_name), EL_STR("\",\"score\":")), int_to_str(combined)), EL_STR(",\"tool_score\":")), int_to_str(computed_tool_score)), EL_STR(",\"history_score\":")), int_to_str(history_score)), EL_STR(",\"authorized\":")), authorized_str), EL_STR(",\"ts\":")), int_to_str(ts)), EL_STR("}"));
|
||||
el_val_t log_tags = EL_STR("[\"security-audit\",\"threat-check\"]");
|
||||
el_val_t discard = mem_remember(log_content, log_tags);
|
||||
@@ -758,7 +610,7 @@ el_val_t threat_history_append(el_val_t text) {
|
||||
el_val_t safe_text = str_to_lower(text);
|
||||
el_val_t combined = el_str_concat(el_str_concat(current, EL_STR(" ")), safe_text);
|
||||
el_val_t len = str_len(combined);
|
||||
el_val_t trimmed = ({ el_val_t _if_result_112 = 0; if ((len > 2000)) { _if_result_112 = (str_slice(combined, (len - 2000), len)); } else { _if_result_112 = (combined); } _if_result_112; });
|
||||
el_val_t trimmed = ({ el_val_t _if_result_72 = 0; if ((len > 2000)) { _if_result_72 = (str_slice(combined, (len - 2000), len)); } else { _if_result_72 = (combined); } _if_result_72; });
|
||||
state_set(EL_STR("agentic_conv_history"), trimmed);
|
||||
return 0;
|
||||
}
|
||||
|
||||
+72
-96
@@ -5,15 +5,6 @@ el_val_t add_punct(el_val_t s, el_val_t intent);
|
||||
el_val_t add_to_seen(el_val_t seen, el_val_t node_id);
|
||||
el_val_t aff_try_slot(el_val_t slot_json, el_val_t aff_7d_ts, el_val_t acc_key);
|
||||
el_val_t affective_context_prefix(void);
|
||||
el_val_t is_utility_request(el_val_t body, el_val_t session_id);
|
||||
el_val_t operator_identity_block(void);
|
||||
el_val_t provenance_add_sources(el_val_t block, el_val_t btype, el_val_t has_cit, el_val_t cit_raw, el_val_t acc);
|
||||
el_val_t provenance_names(el_val_t tools_used);
|
||||
el_val_t provenance_scan_urls(el_val_t arr, el_val_t acc);
|
||||
el_val_t text_join_sep(el_val_t accumulated, el_val_t incoming, el_val_t after_interruption);
|
||||
el_val_t receipt_rule(void);
|
||||
el_val_t receipt_strip(el_val_t s);
|
||||
el_val_t tool_receipt(el_val_t tools_used, el_val_t sources);
|
||||
el_val_t agent_number(el_val_t agent);
|
||||
el_val_t agent_person(el_val_t agent);
|
||||
el_val_t agent_workspace_root(void);
|
||||
@@ -29,8 +20,8 @@ el_val_t akk_alaku_present(el_val_t slot);
|
||||
el_val_t akk_amaru_perfect(el_val_t slot);
|
||||
el_val_t akk_amaru_present(el_val_t slot);
|
||||
el_val_t akk_amaru_stative(el_val_t slot);
|
||||
el_val_t akk_conjugate_copula(el_val_t tense, el_val_t slot);
|
||||
el_val_t akk_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
|
||||
el_val_t akk_conjugate_copula(el_val_t tense, el_val_t slot);
|
||||
el_val_t akk_copula_present(el_val_t slot);
|
||||
el_val_t akk_copula_stative(el_val_t slot);
|
||||
el_val_t akk_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
|
||||
@@ -48,25 +39,25 @@ el_val_t akk_qabu_stative(el_val_t slot);
|
||||
el_val_t akk_regular_perfect(el_val_t stem, el_val_t slot);
|
||||
el_val_t akk_regular_present(el_val_t stem, el_val_t slot);
|
||||
el_val_t akk_regular_stative(el_val_t stem, el_val_t slot);
|
||||
el_val_t akk_slot_g(el_val_t person, el_val_t gender, el_val_t number);
|
||||
el_val_t akk_slot(el_val_t person, el_val_t number);
|
||||
el_val_t akk_slot_g(el_val_t person, el_val_t gender, el_val_t number);
|
||||
el_val_t akk_str_drop_last(el_val_t s, el_val_t n);
|
||||
el_val_t akk_str_ends(el_val_t s, el_val_t suf);
|
||||
el_val_t akk_str_len(el_val_t s);
|
||||
el_val_t akk_strip_nom(el_val_t noun);
|
||||
el_val_t ang_article(el_val_t gender, el_val_t gram_case, el_val_t number);
|
||||
el_val_t ang_article_feminine(el_val_t gram_case, el_val_t number);
|
||||
el_val_t ang_article_masculine(el_val_t gram_case, el_val_t number);
|
||||
el_val_t ang_article_neuter(el_val_t gram_case, el_val_t number);
|
||||
el_val_t ang_article(el_val_t gender, el_val_t gram_case, el_val_t number);
|
||||
el_val_t ang_beon_present(el_val_t slot);
|
||||
el_val_t ang_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
|
||||
el_val_t ang_cuman_past(el_val_t slot);
|
||||
el_val_t ang_cuman_present(el_val_t slot);
|
||||
el_val_t ang_declension(el_val_t noun, el_val_t gender);
|
||||
el_val_t ang_decline(el_val_t noun, el_val_t gram_case, el_val_t number, el_val_t gender);
|
||||
el_val_t ang_decline_strong_masc(el_val_t noun, el_val_t gram_case, el_val_t number);
|
||||
el_val_t ang_decline_strong_neut(el_val_t noun, el_val_t gram_case, el_val_t number);
|
||||
el_val_t ang_decline_weak(el_val_t noun, el_val_t gram_case, el_val_t number);
|
||||
el_val_t ang_decline(el_val_t noun, el_val_t gram_case, el_val_t number, el_val_t gender);
|
||||
el_val_t ang_don_past(el_val_t slot);
|
||||
el_val_t ang_don_present(el_val_t slot);
|
||||
el_val_t ang_gan_past(el_val_t slot);
|
||||
@@ -85,10 +76,10 @@ el_val_t ang_seon_present(el_val_t slot);
|
||||
el_val_t ang_slot(el_val_t person, el_val_t number);
|
||||
el_val_t ang_str_drop_last(el_val_t s, el_val_t n);
|
||||
el_val_t ang_str_ends(el_val_t s, el_val_t suf);
|
||||
el_val_t ang_str_last_char(el_val_t s);
|
||||
el_val_t ang_str_last2(el_val_t s);
|
||||
el_val_t ang_weak_past_stem(el_val_t stem);
|
||||
el_val_t ang_str_last_char(el_val_t s);
|
||||
el_val_t ang_weak_past(el_val_t stem, el_val_t slot);
|
||||
el_val_t ang_weak_past_stem(el_val_t stem);
|
||||
el_val_t ang_weak_present_ending(el_val_t slot);
|
||||
el_val_t ang_weak_stem(el_val_t verb);
|
||||
el_val_t ang_wesan_past(el_val_t slot);
|
||||
@@ -97,8 +88,8 @@ el_val_t ang_willan_past(el_val_t slot);
|
||||
el_val_t ang_willan_present(el_val_t slot);
|
||||
el_val_t ang_witan_past(el_val_t slot);
|
||||
el_val_t ang_witan_present(el_val_t slot);
|
||||
el_val_t api_err_protected(el_val_t id);
|
||||
el_val_t api_err(el_val_t msg);
|
||||
el_val_t api_err_protected(el_val_t id);
|
||||
el_val_t api_json_escape(el_val_t s);
|
||||
el_val_t api_nonempty(el_val_t s);
|
||||
el_val_t api_not_persisted(el_val_t id);
|
||||
@@ -108,19 +99,19 @@ el_val_t api_persisted(el_val_t id);
|
||||
el_val_t api_query_int(el_val_t path, el_val_t key, el_val_t default_val);
|
||||
el_val_t api_query_param(el_val_t path, el_val_t key);
|
||||
el_val_t ar_case_ending(el_val_t kase, el_val_t definite);
|
||||
el_val_t ar_conjugate_form1(el_val_t past_base, el_val_t present_stem, el_val_t tense, el_val_t slot);
|
||||
el_val_t ar_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t gender, el_val_t number);
|
||||
el_val_t ar_conjugate_form1(el_val_t past_base, el_val_t present_stem, el_val_t tense, el_val_t slot);
|
||||
el_val_t ar_definite_article(el_val_t noun);
|
||||
el_val_t ar_gender(el_val_t noun);
|
||||
el_val_t ar_imperfect_prefix(el_val_t slot);
|
||||
el_val_t ar_imperfect_suffix(el_val_t slot);
|
||||
el_val_t ar_irregular(el_val_t verb, el_val_t tense, el_val_t slot);
|
||||
el_val_t ar_irregular_araada(el_val_t slot, el_val_t tense);
|
||||
el_val_t ar_irregular_istata(el_val_t slot, el_val_t tense);
|
||||
el_val_t ar_irregular_jaa(el_val_t slot, el_val_t tense);
|
||||
el_val_t ar_irregular_kaana(el_val_t slot, el_val_t tense);
|
||||
el_val_t ar_irregular_qaala(el_val_t slot, el_val_t tense);
|
||||
el_val_t ar_irregular_raaa(el_val_t slot, el_val_t tense);
|
||||
el_val_t ar_irregular(el_val_t verb, el_val_t tense, el_val_t slot);
|
||||
el_val_t ar_is_sun_letter(el_val_t c);
|
||||
el_val_t ar_masc_pl_ending(el_val_t kase);
|
||||
el_val_t ar_noun_form(el_val_t noun, el_val_t gender, el_val_t kase, el_val_t number, el_val_t definite);
|
||||
@@ -140,8 +131,7 @@ el_val_t auto_term_try_slot(el_val_t slot_type, el_val_t slot_lbl);
|
||||
el_val_t awareness_run(void);
|
||||
el_val_t axon_get(el_val_t path);
|
||||
el_val_t axon_post(el_val_t path, el_val_t body);
|
||||
el_val_t bounded_persona_floor(void);
|
||||
el_val_t bridge_save(el_val_t session_id, el_val_t model, el_val_t safe_sys, el_val_t tools_json, el_val_t messages, el_val_t tools_log, el_val_t tool_use_id, el_val_t wire);
|
||||
el_val_t bridge_save(el_val_t session_id, el_val_t model, el_val_t safe_sys, el_val_t tools_json, el_val_t messages, el_val_t tools_log, el_val_t tool_use_id);
|
||||
el_val_t build_form_from_json(el_val_t semantic_form_json, el_val_t lang_code);
|
||||
el_val_t build_np(el_val_t referent, el_val_t slots);
|
||||
el_val_t build_pp(el_val_t loc);
|
||||
@@ -160,12 +150,8 @@ el_val_t cmd_abs_escape_at(el_val_t cmd, el_val_t root, el_val_t needle);
|
||||
el_val_t connectd_get(el_val_t suffix);
|
||||
el_val_t connectd_post(el_val_t suffix, el_val_t body);
|
||||
el_val_t connector_tools_json(void);
|
||||
el_val_t conv_hist_key(el_val_t session_id);
|
||||
el_val_t conv_hist_label(el_val_t session_id);
|
||||
el_val_t conv_history_block(el_val_t session_id);
|
||||
el_val_t conv_history_load(el_val_t session_id);
|
||||
el_val_t conv_history_persist(el_val_t session_id, el_val_t hist);
|
||||
el_val_t conv_history_record(el_val_t session_id, el_val_t user_msg, el_val_t assistant_msg, el_val_t receipt);
|
||||
el_val_t conv_history_load(void);
|
||||
el_val_t conv_history_persist(el_val_t hist);
|
||||
el_val_t cop_article(el_val_t gender, el_val_t number, el_val_t definite);
|
||||
el_val_t cop_bwk_future(el_val_t prefix);
|
||||
el_val_t cop_bwk_perfect(el_val_t prefix);
|
||||
@@ -187,8 +173,8 @@ el_val_t cop_map_canonical(el_val_t verb);
|
||||
el_val_t cop_nau_future(el_val_t prefix);
|
||||
el_val_t cop_nau_perfect(el_val_t prefix);
|
||||
el_val_t cop_nau_present(el_val_t prefix);
|
||||
el_val_t cop_noun_phrase_gendered(el_val_t noun, el_val_t gram_case, el_val_t number, el_val_t definite, el_val_t gender);
|
||||
el_val_t cop_noun_phrase(el_val_t noun, el_val_t gram_case, el_val_t number, el_val_t definite);
|
||||
el_val_t cop_noun_phrase_gendered(el_val_t noun, el_val_t gram_case, el_val_t number, el_val_t definite, el_val_t gender);
|
||||
el_val_t cop_regular_future(el_val_t prefix, el_val_t stem);
|
||||
el_val_t cop_regular_perfect(el_val_t prefix, el_val_t stem);
|
||||
el_val_t cop_regular_present(el_val_t prefix, el_val_t stem);
|
||||
@@ -198,16 +184,16 @@ el_val_t cop_shwpe_present(el_val_t prefix);
|
||||
el_val_t cop_slot(el_val_t person, el_val_t number);
|
||||
el_val_t cop_str_ends(el_val_t s, el_val_t suf);
|
||||
el_val_t cop_str_len(el_val_t s);
|
||||
el_val_t cop_subject_prefix_gendered(el_val_t person, el_val_t gender, el_val_t number);
|
||||
el_val_t cop_subject_prefix(el_val_t person, el_val_t number);
|
||||
el_val_t cop_subject_prefix_gendered(el_val_t person, el_val_t gender, el_val_t number);
|
||||
el_val_t current_engine_note(el_val_t model);
|
||||
el_val_t de_adj_ending(el_val_t gender, el_val_t gram_case, el_val_t number, el_val_t article_type);
|
||||
el_val_t de_article(el_val_t gender, el_val_t gram_case, el_val_t number, el_val_t definite);
|
||||
el_val_t de_article_def(el_val_t gender, el_val_t gram_case, el_val_t number);
|
||||
el_val_t de_article_indef(el_val_t gender, el_val_t gram_case, el_val_t number);
|
||||
el_val_t de_article(el_val_t gender, el_val_t gram_case, el_val_t number, el_val_t definite);
|
||||
el_val_t de_case_ending(el_val_t noun, el_val_t gender, el_val_t gram_case, el_val_t number);
|
||||
el_val_t de_conjugate_weak(el_val_t stem, el_val_t tense, el_val_t person, el_val_t number);
|
||||
el_val_t de_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
|
||||
el_val_t de_conjugate_weak(el_val_t stem, el_val_t tense, el_val_t person, el_val_t number);
|
||||
el_val_t de_irregular_present(el_val_t verb, el_val_t person, el_val_t number);
|
||||
el_val_t de_norm_number(el_val_t number);
|
||||
el_val_t de_norm_person(el_val_t person);
|
||||
@@ -217,12 +203,15 @@ el_val_t dharma_network_state(void);
|
||||
el_val_t dharma_registry(void);
|
||||
el_val_t dispatch_tool(el_val_t tool_name, el_val_t tool_input);
|
||||
el_val_t distill_transcript(el_val_t transcript);
|
||||
el_val_t egy_conjugate_copula(el_val_t tense, el_val_t slot);
|
||||
el_val_t egy_conjugate_pronoun(el_val_t person, el_val_t number);
|
||||
el_val_t egy_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
|
||||
el_val_t egy_Dd_future(el_val_t slot);
|
||||
el_val_t egy_Dd_past(el_val_t slot);
|
||||
el_val_t egy_Dd_present(el_val_t slot);
|
||||
el_val_t egy_Sm_future(el_val_t slot);
|
||||
el_val_t egy_Sm_past(el_val_t slot);
|
||||
el_val_t egy_Sm_present(el_val_t slot);
|
||||
el_val_t egy_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
|
||||
el_val_t egy_conjugate_copula(el_val_t tense, el_val_t slot);
|
||||
el_val_t egy_conjugate_pronoun(el_val_t person, el_val_t number);
|
||||
el_val_t egy_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
|
||||
el_val_t egy_drop(el_val_t s, el_val_t n);
|
||||
el_val_t egy_fem(el_val_t noun);
|
||||
@@ -246,11 +235,8 @@ el_val_t egy_regular_present(el_val_t stem, el_val_t slot);
|
||||
el_val_t egy_sdm_future(el_val_t slot);
|
||||
el_val_t egy_sdm_past(el_val_t slot);
|
||||
el_val_t egy_sdm_present(el_val_t slot);
|
||||
el_val_t egy_slot_with_gender(el_val_t person, el_val_t gender, el_val_t number);
|
||||
el_val_t egy_slot(el_val_t person, el_val_t number);
|
||||
el_val_t egy_Sm_future(el_val_t slot);
|
||||
el_val_t egy_Sm_past(el_val_t slot);
|
||||
el_val_t egy_Sm_present(el_val_t slot);
|
||||
el_val_t egy_slot_with_gender(el_val_t person, el_val_t gender, el_val_t number);
|
||||
el_val_t egy_str_ends(el_val_t s, el_val_t suf);
|
||||
el_val_t egy_str_len(el_val_t s);
|
||||
el_val_t egy_suffix_pronoun(el_val_t slot);
|
||||
@@ -271,9 +257,9 @@ el_val_t en_verb_3sg(el_val_t base);
|
||||
el_val_t en_verb_form(el_val_t base, el_val_t tense, el_val_t person, el_val_t number);
|
||||
el_val_t en_verb_gerund(el_val_t base);
|
||||
el_val_t en_verb_past(el_val_t base);
|
||||
el_val_t engram_compile(el_val_t intent);
|
||||
el_val_t engram_compile_multi(el_val_t topic);
|
||||
el_val_t engram_compile_ranked(el_val_t nodes_json, el_val_t max_nodes);
|
||||
el_val_t engram_compile(el_val_t intent);
|
||||
el_val_t engram_dedup_nodes(el_val_t nodes_json);
|
||||
el_val_t engram_detect_recall_intent(el_val_t message);
|
||||
el_val_t engram_extract_entities(el_val_t message);
|
||||
@@ -339,9 +325,9 @@ el_val_t es_starts_with_stressed_a(el_val_t noun);
|
||||
el_val_t es_stem(el_val_t base);
|
||||
el_val_t es_str_drop_last(el_val_t s, el_val_t n);
|
||||
el_val_t es_str_ends(el_val_t s, el_val_t suf);
|
||||
el_val_t es_str_last_char(el_val_t s);
|
||||
el_val_t es_str_last2(el_val_t s);
|
||||
el_val_t es_str_last3(el_val_t s);
|
||||
el_val_t es_str_last_char(el_val_t s);
|
||||
el_val_t es_verb_class(el_val_t base);
|
||||
el_val_t extract_dim(el_val_t content, el_val_t key);
|
||||
el_val_t fi_apply_case(el_val_t noun, el_val_t gram_case, el_val_t number);
|
||||
@@ -384,8 +370,8 @@ el_val_t fr_slot(el_val_t person, el_val_t number);
|
||||
el_val_t fr_stem(el_val_t base);
|
||||
el_val_t fr_str_drop_last(el_val_t s, el_val_t n);
|
||||
el_val_t fr_str_ends(el_val_t s, el_val_t suf);
|
||||
el_val_t fr_str_last_char(el_val_t s);
|
||||
el_val_t fr_str_last2(el_val_t s);
|
||||
el_val_t fr_str_last_char(el_val_t s);
|
||||
el_val_t fr_subject_starts_vowel(el_val_t subject);
|
||||
el_val_t fr_uses_etre(el_val_t verb);
|
||||
el_val_t fr_verb_ends_vowel(el_val_t verb_form);
|
||||
@@ -407,9 +393,9 @@ el_val_t fro_conj3_future(el_val_t verb, el_val_t slot);
|
||||
el_val_t fro_conj3_past(el_val_t stem, el_val_t slot);
|
||||
el_val_t fro_conj3_present(el_val_t stem, el_val_t slot);
|
||||
el_val_t fro_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
|
||||
el_val_t fro_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
|
||||
el_val_t fro_decline_fem(el_val_t noun, el_val_t number);
|
||||
el_val_t fro_decline_masc(el_val_t noun, el_val_t gram_case, el_val_t number);
|
||||
el_val_t fro_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
|
||||
el_val_t fro_drop(el_val_t s, el_val_t n);
|
||||
el_val_t fro_estre_future(el_val_t slot);
|
||||
el_val_t fro_estre_past(el_val_t slot);
|
||||
@@ -427,15 +413,15 @@ el_val_t fro_venir_past(el_val_t slot);
|
||||
el_val_t fro_venir_present(el_val_t slot);
|
||||
el_val_t fro_verb_class(el_val_t verb);
|
||||
el_val_t fro_verb_stem(el_val_t verb, el_val_t vclass);
|
||||
el_val_t generate_frame_lang(el_val_t frame, el_val_t lang_code);
|
||||
el_val_t generate(el_val_t semantic_form_json);
|
||||
el_val_t generate_frame(el_val_t frame);
|
||||
el_val_t generate_frame_lang(el_val_t frame, el_val_t lang_code);
|
||||
el_val_t generate_lang(el_val_t semantic_form_json, el_val_t lang_code);
|
||||
el_val_t generate_tree(el_val_t rule_id_str, el_val_t slots);
|
||||
el_val_t generate(el_val_t semantic_form_json);
|
||||
el_val_t get_rules(void);
|
||||
el_val_t get_vocab(void);
|
||||
el_val_t gez_conjugate_copula(el_val_t tense, el_val_t slot);
|
||||
el_val_t gez_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
|
||||
el_val_t gez_conjugate_copula(el_val_t tense, el_val_t slot);
|
||||
el_val_t gez_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
|
||||
el_val_t gez_generic_imperfect(el_val_t base3sg, el_val_t slot);
|
||||
el_val_t gez_generic_perfect(el_val_t base3sg, el_val_t slot);
|
||||
@@ -454,12 +440,13 @@ el_val_t gez_qwl_imperfect(el_val_t slot);
|
||||
el_val_t gez_qwl_perfect(el_val_t slot);
|
||||
el_val_t gez_ray_imperfect(el_val_t slot);
|
||||
el_val_t gez_ray_perfect(el_val_t slot);
|
||||
el_val_t gez_slot_g(el_val_t person, el_val_t gender, el_val_t number);
|
||||
el_val_t gez_slot(el_val_t person, el_val_t number);
|
||||
el_val_t gez_slot_g(el_val_t person, el_val_t gender, el_val_t number);
|
||||
el_val_t gez_str_drop_last(el_val_t s, el_val_t n);
|
||||
el_val_t gez_str_ends(el_val_t s, el_val_t suf);
|
||||
el_val_t gez_str_len(el_val_t s);
|
||||
el_val_t goh_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
|
||||
el_val_t goh_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
|
||||
el_val_t goh_decline_fem_o_pl(el_val_t stem, el_val_t gram_case);
|
||||
el_val_t goh_decline_fem_o_sg(el_val_t stem, el_val_t gram_case);
|
||||
el_val_t goh_decline_masc_a_pl(el_val_t stem, el_val_t gram_case);
|
||||
@@ -468,7 +455,6 @@ el_val_t goh_decline_masc_n_pl(el_val_t stem, el_val_t gram_case);
|
||||
el_val_t goh_decline_masc_n_sg(el_val_t stem, el_val_t gram_case);
|
||||
el_val_t goh_decline_neut_a_pl(el_val_t stem, el_val_t gram_case);
|
||||
el_val_t goh_decline_neut_a_sg(el_val_t stem, el_val_t gram_case);
|
||||
el_val_t goh_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
|
||||
el_val_t goh_demo_article(el_val_t stype, el_val_t number);
|
||||
el_val_t goh_drop(el_val_t s, el_val_t n);
|
||||
el_val_t goh_extract_stem(el_val_t noun, el_val_t stype);
|
||||
@@ -493,13 +479,13 @@ el_val_t goh_weak_present(el_val_t stem, el_val_t slot);
|
||||
el_val_t goh_wesan_past(el_val_t slot);
|
||||
el_val_t goh_wesan_present(el_val_t slot);
|
||||
el_val_t got_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
|
||||
el_val_t got_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
|
||||
el_val_t got_decline_a_stem_pl(el_val_t stem, el_val_t gram_case);
|
||||
el_val_t got_decline_a_stem_sg(el_val_t stem, el_val_t gram_case);
|
||||
el_val_t got_decline_n_stem_pl(el_val_t stem, el_val_t gram_case);
|
||||
el_val_t got_decline_n_stem_sg(el_val_t stem, el_val_t gram_case);
|
||||
el_val_t got_decline_o_stem_pl(el_val_t stem, el_val_t gram_case);
|
||||
el_val_t got_decline_o_stem_sg(el_val_t stem, el_val_t gram_case);
|
||||
el_val_t got_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
|
||||
el_val_t got_demo_article(el_val_t stype);
|
||||
el_val_t got_extract_stem(el_val_t noun, el_val_t stype);
|
||||
el_val_t got_gaggan_past(el_val_t slot);
|
||||
@@ -532,17 +518,17 @@ el_val_t gram_build_vp(el_val_t verb, el_val_t aux, el_val_t profile);
|
||||
el_val_t gram_order_constituents(el_val_t subj, el_val_t verb, el_val_t obj, el_val_t profile);
|
||||
el_val_t gram_question_strategy(el_val_t profile);
|
||||
el_val_t gram_word_order(el_val_t profile);
|
||||
el_val_t grc_article(el_val_t gender, el_val_t gram_case, el_val_t number);
|
||||
el_val_t grc_article_feminine(el_val_t gram_case, el_val_t number);
|
||||
el_val_t grc_article_masculine(el_val_t gram_case, el_val_t number);
|
||||
el_val_t grc_article_neuter(el_val_t gram_case, el_val_t number);
|
||||
el_val_t grc_article(el_val_t gender, el_val_t gram_case, el_val_t number);
|
||||
el_val_t grc_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
|
||||
el_val_t grc_declension(el_val_t noun);
|
||||
el_val_t grc_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
|
||||
el_val_t grc_decline_1a(el_val_t stem, el_val_t gram_case, el_val_t number);
|
||||
el_val_t grc_decline_1e(el_val_t stem, el_val_t gram_case, el_val_t number);
|
||||
el_val_t grc_decline_2m(el_val_t stem, el_val_t gram_case, el_val_t number);
|
||||
el_val_t grc_decline_2n(el_val_t stem, el_val_t gram_case, el_val_t number);
|
||||
el_val_t grc_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
|
||||
el_val_t grc_echein_aorist(el_val_t slot);
|
||||
el_val_t grc_echein_future(el_val_t slot);
|
||||
el_val_t grc_echein_imperfect(el_val_t slot);
|
||||
@@ -569,9 +555,9 @@ el_val_t grc_present_stem(el_val_t verb);
|
||||
el_val_t grc_slot(el_val_t person, el_val_t number);
|
||||
el_val_t grc_str_drop_last(el_val_t s, el_val_t n);
|
||||
el_val_t grc_str_ends(el_val_t s, el_val_t suf);
|
||||
el_val_t grc_str_last_char(el_val_t s);
|
||||
el_val_t grc_str_last2(el_val_t s);
|
||||
el_val_t grc_str_last3(el_val_t s);
|
||||
el_val_t grc_str_last_char(el_val_t s);
|
||||
el_val_t grc_thematic_future_ending(el_val_t slot);
|
||||
el_val_t grc_thematic_imperfect_ending(el_val_t slot);
|
||||
el_val_t grc_thematic_present_ending(el_val_t slot);
|
||||
@@ -603,17 +589,17 @@ el_val_t handle_api_recall(el_val_t method, el_val_t path, el_val_t body);
|
||||
el_val_t handle_api_remember(el_val_t body);
|
||||
el_val_t handle_api_search_knowledge(el_val_t method, el_val_t path, el_val_t body);
|
||||
el_val_t handle_api_tune_config(el_val_t body);
|
||||
el_val_t handle_chat(el_val_t body);
|
||||
el_val_t handle_chat_agentic(el_val_t body);
|
||||
el_val_t handle_chat_as_soul(el_val_t body);
|
||||
el_val_t handle_chat_plan(el_val_t body);
|
||||
el_val_t handle_chat(el_val_t body);
|
||||
el_val_t handle_config(el_val_t method, el_val_t body);
|
||||
el_val_t handle_connectors(el_val_t method, el_val_t clean, el_val_t body);
|
||||
el_val_t handle_conversations(el_val_t method);
|
||||
el_val_t handle_dharma_recv(el_val_t body);
|
||||
el_val_t handle_dharma_room_turn_agentic(el_val_t body);
|
||||
el_val_t handle_dharma_room_turn(el_val_t body);
|
||||
el_val_t handle_dharma(el_val_t path, el_val_t method, el_val_t body);
|
||||
el_val_t handle_dharma_recv(el_val_t body);
|
||||
el_val_t handle_dharma_room_turn(el_val_t body);
|
||||
el_val_t handle_dharma_room_turn_agentic(el_val_t body);
|
||||
el_val_t handle_elp_chat(el_val_t body);
|
||||
el_val_t handle_nlg(el_val_t path, el_val_t method, el_val_t body);
|
||||
el_val_t handle_request(el_val_t method, el_val_t path, el_val_t body);
|
||||
@@ -621,11 +607,11 @@ el_val_t handle_safety_contact_get(void);
|
||||
el_val_t handle_safety_contact_post(el_val_t body);
|
||||
el_val_t handle_see(el_val_t body);
|
||||
el_val_t handle_session_approve(el_val_t session_id, el_val_t body);
|
||||
el_val_t handle_tool_result(el_val_t session_id, el_val_t body);
|
||||
el_val_t handle_tool(el_val_t path, el_val_t method, el_val_t body);
|
||||
el_val_t handle_tool_result(el_val_t session_id, el_val_t body);
|
||||
el_val_t hard_bell_threshold(void);
|
||||
el_val_t he_conjugate_copula(el_val_t tense, el_val_t slot);
|
||||
el_val_t he_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t gender, el_val_t number);
|
||||
el_val_t he_conjugate_copula(el_val_t tense, el_val_t slot);
|
||||
el_val_t he_copula_future(el_val_t slot);
|
||||
el_val_t he_copula_past(el_val_t slot);
|
||||
el_val_t he_definite_prefix(el_val_t noun);
|
||||
@@ -662,12 +648,12 @@ el_val_t hi_genitive_phrase(el_val_t possessor, el_val_t possessor_gender, el_va
|
||||
el_val_t hi_hona_past(el_val_t gender, el_val_t number);
|
||||
el_val_t hi_hona_present(el_val_t person, el_val_t number);
|
||||
el_val_t hi_masc_aa_stem(el_val_t noun);
|
||||
el_val_t hi_noun_direct(el_val_t noun, el_val_t gender, el_val_t number);
|
||||
el_val_t hi_noun_direct_f(el_val_t noun, el_val_t number);
|
||||
el_val_t hi_noun_direct_m(el_val_t noun, el_val_t number);
|
||||
el_val_t hi_noun_direct(el_val_t noun, el_val_t gender, el_val_t number);
|
||||
el_val_t hi_noun_oblique(el_val_t noun, el_val_t gender, el_val_t number);
|
||||
el_val_t hi_noun_oblique_f(el_val_t noun, el_val_t number);
|
||||
el_val_t hi_noun_oblique_m(el_val_t noun, el_val_t number);
|
||||
el_val_t hi_noun_oblique(el_val_t noun, el_val_t gender, el_val_t number);
|
||||
el_val_t hi_noun_with_post(el_val_t noun, el_val_t gender, el_val_t number, el_val_t gram_case);
|
||||
el_val_t hi_past_irregular(el_val_t stem, el_val_t gender, el_val_t number);
|
||||
el_val_t hi_past_suffix(el_val_t gender, el_val_t number);
|
||||
@@ -677,11 +663,11 @@ el_val_t hi_str_drop_last(el_val_t s, el_val_t n);
|
||||
el_val_t hi_str_ends(el_val_t s, el_val_t suf);
|
||||
el_val_t hi_str_last_char(el_val_t s);
|
||||
el_val_t hi_tense_suffix(el_val_t tense, el_val_t gender, el_val_t number);
|
||||
el_val_t hi_verb_stem_clean(el_val_t infinitive);
|
||||
el_val_t hi_verb_stem(el_val_t infinitive);
|
||||
el_val_t hi_verb_stem_clean(el_val_t infinitive);
|
||||
el_val_t hist_append(el_val_t hist, el_val_t role, el_val_t content);
|
||||
el_val_t hist_trim_with_bell_guard(el_val_t hist);
|
||||
el_val_t hist_trim(el_val_t hist);
|
||||
el_val_t hist_trim_with_bell_guard(el_val_t hist);
|
||||
el_val_t id_in_seen(el_val_t node_id, el_val_t seen);
|
||||
el_val_t idle_count(void);
|
||||
el_val_t idle_inc(void);
|
||||
@@ -712,6 +698,7 @@ el_val_t json_escape(el_val_t s);
|
||||
el_val_t json_safe(el_val_t s);
|
||||
el_val_t la_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
|
||||
el_val_t la_declension(el_val_t noun);
|
||||
el_val_t la_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
|
||||
el_val_t la_decline_1(el_val_t stem, el_val_t gram_case, el_val_t number);
|
||||
el_val_t la_decline_2er(el_val_t noun, el_val_t gram_case, el_val_t number);
|
||||
el_val_t la_decline_2m(el_val_t stem, el_val_t gram_case, el_val_t number);
|
||||
@@ -719,7 +706,6 @@ el_val_t la_decline_2n(el_val_t stem, el_val_t gram_case, el_val_t number);
|
||||
el_val_t la_decline_3(el_val_t noun, el_val_t gram_case, el_val_t number);
|
||||
el_val_t la_decline_4(el_val_t stem, el_val_t gram_case, el_val_t number);
|
||||
el_val_t la_decline_5(el_val_t stem, el_val_t gram_case, el_val_t number);
|
||||
el_val_t la_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
|
||||
el_val_t la_esse_future(el_val_t slot);
|
||||
el_val_t la_esse_past(el_val_t slot);
|
||||
el_val_t la_esse_present(el_val_t slot);
|
||||
@@ -743,9 +729,9 @@ el_val_t la_slot(el_val_t person, el_val_t number);
|
||||
el_val_t la_stem(el_val_t verb, el_val_t vclass);
|
||||
el_val_t la_str_drop_last(el_val_t s, el_val_t n);
|
||||
el_val_t la_str_ends(el_val_t s, el_val_t suf);
|
||||
el_val_t la_str_last_char(el_val_t s);
|
||||
el_val_t la_str_last2(el_val_t s);
|
||||
el_val_t la_str_last3(el_val_t s);
|
||||
el_val_t la_str_last_char(el_val_t s);
|
||||
el_val_t la_velle_future(el_val_t slot);
|
||||
el_val_t la_velle_past(el_val_t slot);
|
||||
el_val_t la_velle_present(el_val_t slot);
|
||||
@@ -762,6 +748,7 @@ el_val_t lang_is_fusional(el_val_t profile);
|
||||
el_val_t lang_is_isolating(el_val_t profile);
|
||||
el_val_t lang_is_polysynthetic(el_val_t profile);
|
||||
el_val_t lang_is_rtl(el_val_t profile);
|
||||
el_val_t lang_profile(el_val_t code, el_val_t word_order, el_val_t morph_type, el_val_t has_case, el_val_t has_gender, el_val_t script_dir, el_val_t agreement, el_val_t null_subject);
|
||||
el_val_t lang_profile_akk(void);
|
||||
el_val_t lang_profile_ang(void);
|
||||
el_val_t lang_profile_ar(void);
|
||||
@@ -793,10 +780,8 @@ el_val_t lang_profile_sw(void);
|
||||
el_val_t lang_profile_txb(void);
|
||||
el_val_t lang_profile_uga(void);
|
||||
el_val_t lang_profile_zh(void);
|
||||
el_val_t lang_profile(el_val_t code, el_val_t word_order, el_val_t morph_type, el_val_t has_case, el_val_t has_gender, el_val_t script_dir, el_val_t agreement, el_val_t null_subject);
|
||||
el_val_t lang_word_order(el_val_t profile);
|
||||
el_val_t layered_cycle(el_val_t raw_input, el_val_t session_id, el_val_t utility);
|
||||
el_val_t layered_generate(el_val_t prompt, el_val_t imprint_id, el_val_t session_id);
|
||||
el_val_t layered_cycle(el_val_t raw_input);
|
||||
el_val_t lex_class(el_val_t entry);
|
||||
el_val_t lex_form(el_val_t entry, el_val_t idx);
|
||||
el_val_t lex_pos(el_val_t entry);
|
||||
@@ -835,8 +820,6 @@ el_val_t mem_save(el_val_t path);
|
||||
el_val_t mem_search(el_val_t query, el_val_t limit);
|
||||
el_val_t mem_store(el_val_t content, el_val_t label, el_val_t tags);
|
||||
el_val_t mem_strengthen(el_val_t node_id);
|
||||
el_val_t mem_tombstone(el_val_t node_id);
|
||||
el_val_t memory_hide_tombstoned(el_val_t raw, el_val_t path);
|
||||
el_val_t morph_apply_suffix(el_val_t base, el_val_t suffix);
|
||||
el_val_t morph_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number, el_val_t profile);
|
||||
el_val_t morph_inflect(el_val_t word, el_val_t features, el_val_t profile);
|
||||
@@ -845,10 +828,10 @@ el_val_t morph_pluralize(el_val_t noun, el_val_t profile);
|
||||
el_val_t next_bridge_id(void);
|
||||
el_val_t nlg_is_ws(el_val_t c);
|
||||
el_val_t non_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
|
||||
el_val_t non_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
|
||||
el_val_t non_decline_fem(el_val_t noun, el_val_t gram_case, el_val_t number);
|
||||
el_val_t non_decline_masc(el_val_t noun, el_val_t gram_case, el_val_t number);
|
||||
el_val_t non_decline_neut(el_val_t noun, el_val_t gram_case, el_val_t number);
|
||||
el_val_t non_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
|
||||
el_val_t non_def_suffix_fem(el_val_t gram_case, el_val_t number);
|
||||
el_val_t non_def_suffix_masc(el_val_t gram_case, el_val_t number);
|
||||
el_val_t non_def_suffix_neut(el_val_t gram_case, el_val_t number);
|
||||
@@ -875,11 +858,6 @@ el_val_t non_weak_past(el_val_t stem, el_val_t slot);
|
||||
el_val_t non_weak_present(el_val_t stem, el_val_t slot);
|
||||
el_val_t one_cycle(void);
|
||||
el_val_t openai_chat_complete(el_val_t model, el_val_t base_url, el_val_t api_key, el_val_t safe_sys, el_val_t messages_json);
|
||||
el_val_t openai_tools_json(el_val_t tools_anthropic);
|
||||
el_val_t json_trim_dangling_escape(el_val_t s);
|
||||
el_val_t utf8_safe_slice(el_val_t s, el_val_t n);
|
||||
el_val_t agentic_tools_no_web(void);
|
||||
el_val_t openai_agentic_loop(el_val_t session_id, el_val_t model, el_val_t safe_sys, el_val_t tools_json, el_val_t messages_in, el_val_t tools_log_in);
|
||||
el_val_t parse_float_x100(el_val_t s);
|
||||
el_val_t path_within_root(el_val_t path, el_val_t root);
|
||||
el_val_t peo_ah_past(el_val_t slot);
|
||||
@@ -887,8 +865,8 @@ el_val_t peo_ah_present(el_val_t slot);
|
||||
el_val_t peo_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
|
||||
el_val_t peo_da_past(el_val_t slot);
|
||||
el_val_t peo_da_present(el_val_t slot);
|
||||
el_val_t peo_decline_astem(el_val_t noun, el_val_t gram_case, el_val_t number);
|
||||
el_val_t peo_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
|
||||
el_val_t peo_decline_astem(el_val_t noun, el_val_t gram_case, el_val_t number);
|
||||
el_val_t peo_drop(el_val_t s, el_val_t n);
|
||||
el_val_t peo_ends(el_val_t s, el_val_t suf);
|
||||
el_val_t peo_kar_past(el_val_t slot);
|
||||
@@ -904,11 +882,11 @@ el_val_t perceive(void);
|
||||
el_val_t pi_aorist_ending(el_val_t slot);
|
||||
el_val_t pi_atthi_present(el_val_t slot);
|
||||
el_val_t pi_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
|
||||
el_val_t pi_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
|
||||
el_val_t pi_decline_a_fem_pl(el_val_t stem, el_val_t gram_case);
|
||||
el_val_t pi_decline_a_fem_sg(el_val_t stem, el_val_t gram_case);
|
||||
el_val_t pi_decline_a_masc_pl(el_val_t stem, el_val_t gram_case);
|
||||
el_val_t pi_decline_a_masc_sg(el_val_t stem, el_val_t gram_case);
|
||||
el_val_t pi_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
|
||||
el_val_t pi_detect_class(el_val_t noun);
|
||||
el_val_t pi_drop(el_val_t s, el_val_t n);
|
||||
el_val_t pi_future_ending(el_val_t slot);
|
||||
@@ -939,11 +917,11 @@ el_val_t proactive_curiosity(void);
|
||||
el_val_t pulse_count(void);
|
||||
el_val_t pulse_inc(void);
|
||||
el_val_t rate_limit_check(el_val_t ip, el_val_t path);
|
||||
el_val_t realize(el_val_t form);
|
||||
el_val_t realize_lang(el_val_t form, el_val_t profile);
|
||||
el_val_t realize_np(el_val_t referent, el_val_t number);
|
||||
el_val_t realize_question_lang(el_val_t predicate, el_val_t tense, el_val_t aspect, el_val_t person, el_val_t number, el_val_t agent, el_val_t patient, el_val_t location, el_val_t profile);
|
||||
el_val_t realize_vp_lang(el_val_t base_verb, el_val_t tense, el_val_t aspect, el_val_t person, el_val_t number, el_val_t profile);
|
||||
el_val_t realize(el_val_t form);
|
||||
el_val_t record(el_val_t outcome_json);
|
||||
el_val_t render_studio(void);
|
||||
el_val_t render_tree(el_val_t tree);
|
||||
@@ -954,9 +932,9 @@ el_val_t route_imprint_contextual(el_val_t body);
|
||||
el_val_t route_imprint_user(el_val_t body);
|
||||
el_val_t route_lineage(void);
|
||||
el_val_t route_synthesize(el_val_t body);
|
||||
el_val_t ru_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number, el_val_t gender);
|
||||
el_val_t ru_conjugate_1st(el_val_t stem, el_val_t tense, el_val_t person, el_val_t number);
|
||||
el_val_t ru_conjugate_2nd(el_val_t stem, el_val_t tense, el_val_t person, el_val_t number);
|
||||
el_val_t ru_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number, el_val_t gender);
|
||||
el_val_t ru_decline_fem(el_val_t noun, el_val_t stype, el_val_t gram_case, el_val_t number);
|
||||
el_val_t ru_decline_masc(el_val_t noun, el_val_t stype, el_val_t gram_case, el_val_t number);
|
||||
el_val_t ru_decline_neut(el_val_t noun, el_val_t stype, el_val_t gram_case, el_val_t number);
|
||||
@@ -969,8 +947,8 @@ el_val_t ru_past_stem(el_val_t verb);
|
||||
el_val_t ru_stem_type(el_val_t noun, el_val_t gender);
|
||||
el_val_t rule_id(el_val_t rule);
|
||||
el_val_t rule_lhs(el_val_t rule);
|
||||
el_val_t rule_rhs_len(el_val_t rule);
|
||||
el_val_t rule_rhs(el_val_t rule, el_val_t idx);
|
||||
el_val_t rule_rhs_len(el_val_t rule);
|
||||
el_val_t run_command_guard(el_val_t cmd, el_val_t root);
|
||||
el_val_t run_command_is_readonly(el_val_t cmd);
|
||||
el_val_t sa_as_future(el_val_t slot);
|
||||
@@ -984,11 +962,11 @@ el_val_t sa_class1_future_ending(el_val_t slot);
|
||||
el_val_t sa_class1_past_ending(el_val_t slot);
|
||||
el_val_t sa_class1_present_ending(el_val_t slot);
|
||||
el_val_t sa_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
|
||||
el_val_t sa_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
|
||||
el_val_t sa_decline_a_stem_pl(el_val_t stem, el_val_t gram_case);
|
||||
el_val_t sa_decline_a_stem_sg(el_val_t stem, el_val_t gram_case);
|
||||
el_val_t sa_decline_aa_stem_pl(el_val_t stem, el_val_t gram_case);
|
||||
el_val_t sa_decline_aa_stem_sg(el_val_t stem, el_val_t gram_case);
|
||||
el_val_t sa_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
|
||||
el_val_t sa_drs_future(el_val_t slot);
|
||||
el_val_t sa_drs_past(el_val_t slot);
|
||||
el_val_t sa_drs_present(el_val_t slot);
|
||||
@@ -1036,26 +1014,26 @@ el_val_t scan_token(el_val_t s, el_val_t start);
|
||||
el_val_t security_research_authorized(void);
|
||||
el_val_t seed_persona_from_env(void);
|
||||
el_val_t sem_first_modifier(el_val_t mods);
|
||||
el_val_t sem_frame(el_val_t intent, el_val_t subject, el_val_t obj, el_val_t modifiers);
|
||||
el_val_t sem_frame_lang(el_val_t intent, el_val_t subject, el_val_t obj, el_val_t modifiers, el_val_t lang_code);
|
||||
el_val_t sem_frame_obj(el_val_t intent, el_val_t subject, el_val_t obj);
|
||||
el_val_t sem_frame_simple(el_val_t intent, el_val_t subject);
|
||||
el_val_t sem_frame(el_val_t intent, el_val_t subject, el_val_t obj, el_val_t modifiers);
|
||||
el_val_t sem_get(el_val_t json, el_val_t key);
|
||||
el_val_t sem_intent_to_realize(el_val_t intent);
|
||||
el_val_t sem_intent(el_val_t frame);
|
||||
el_val_t sem_intent_to_realize(el_val_t intent);
|
||||
el_val_t sem_lang(el_val_t frame);
|
||||
el_val_t sem_modifiers(el_val_t frame);
|
||||
el_val_t sem_object(el_val_t frame);
|
||||
el_val_t sem_realize(el_val_t frame);
|
||||
el_val_t sem_realize_full(el_val_t frame, el_val_t verb, el_val_t tense, el_val_t aspect);
|
||||
el_val_t sem_realize_greet(el_val_t subject);
|
||||
el_val_t sem_realize_lang(el_val_t frame, el_val_t lang_code);
|
||||
el_val_t sem_realize(el_val_t frame);
|
||||
el_val_t sem_subject(el_val_t frame);
|
||||
el_val_t sem_to_spec_full(el_val_t frame, el_val_t verb, el_val_t tense, el_val_t aspect);
|
||||
el_val_t sem_to_spec(el_val_t frame);
|
||||
el_val_t sem_to_spec_full(el_val_t frame, el_val_t verb, el_val_t tense, el_val_t aspect);
|
||||
el_val_t session_auto_title(el_val_t session_id, el_val_t first_message);
|
||||
el_val_t session_create_cleanup(el_val_t session_id);
|
||||
el_val_t session_create(el_val_t body);
|
||||
el_val_t session_create_cleanup(el_val_t session_id);
|
||||
el_val_t session_delete(el_val_t session_id);
|
||||
el_val_t session_exists(el_val_t session_id);
|
||||
el_val_t session_get(el_val_t session_id);
|
||||
@@ -1064,11 +1042,11 @@ el_val_t session_hist_save(el_val_t session_id, el_val_t hist);
|
||||
el_val_t session_list(void);
|
||||
el_val_t session_make_content(el_val_t id, el_val_t title, el_val_t created_at, el_val_t updated_at, el_val_t folder);
|
||||
el_val_t session_preload_bullets(el_val_t nodes, el_val_t max_bullets, el_val_t snip_len);
|
||||
el_val_t session_search_entry(el_val_t node);
|
||||
el_val_t session_search(el_val_t query);
|
||||
el_val_t session_search_entry(el_val_t node);
|
||||
el_val_t session_summary_autogenerate(el_val_t hist);
|
||||
el_val_t session_summary_write_dated(el_val_t summary_text, el_val_t label);
|
||||
el_val_t session_summary_write(el_val_t summary_text);
|
||||
el_val_t session_summary_write_dated(el_val_t summary_text, el_val_t label);
|
||||
el_val_t session_title_from_message(el_val_t message);
|
||||
el_val_t session_update_meta_timestamp(el_val_t session_id);
|
||||
el_val_t session_update_patch(el_val_t session_id, el_val_t body);
|
||||
@@ -1079,9 +1057,9 @@ el_val_t sga_bith_past(el_val_t slot);
|
||||
el_val_t sga_bith_present(el_val_t slot);
|
||||
el_val_t sga_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
|
||||
el_val_t sga_copula_present(el_val_t slot);
|
||||
el_val_t sga_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
|
||||
el_val_t sga_decline_astem(el_val_t noun, el_val_t gram_case, el_val_t number);
|
||||
el_val_t sga_decline_ostem(el_val_t noun, el_val_t gram_case, el_val_t number);
|
||||
el_val_t sga_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
|
||||
el_val_t sga_detect_gender(el_val_t noun);
|
||||
el_val_t sga_drop(el_val_t s, el_val_t n);
|
||||
el_val_t sga_first(el_val_t s);
|
||||
@@ -1109,9 +1087,9 @@ el_val_t steward_session_check(el_val_t input, el_val_t session_id);
|
||||
el_val_t steward_validate_imprint(el_val_t imprint_id, el_val_t tool_name);
|
||||
el_val_t str_drop_last(el_val_t s, el_val_t n);
|
||||
el_val_t str_ends(el_val_t s, el_val_t suf);
|
||||
el_val_t str_last_char(el_val_t s);
|
||||
el_val_t str_last2(el_val_t s);
|
||||
el_val_t str_last3(el_val_t s);
|
||||
el_val_t str_last_char(el_val_t s);
|
||||
el_val_t strengthen_chat_nodes(el_val_t activation_nodes);
|
||||
el_val_t strip_query(el_val_t path);
|
||||
el_val_t studio_tools_json(void);
|
||||
@@ -1138,8 +1116,8 @@ el_val_t sux_realize_sentence(el_val_t intent, el_val_t agent, el_val_t predicat
|
||||
el_val_t sux_slot(el_val_t person, el_val_t number);
|
||||
el_val_t sux_str_drop_last(el_val_t s, el_val_t n);
|
||||
el_val_t sux_str_ends(el_val_t s, el_val_t suf);
|
||||
el_val_t sux_str_last_char(el_val_t s);
|
||||
el_val_t sux_str_last2(el_val_t s);
|
||||
el_val_t sux_str_last_char(el_val_t s);
|
||||
el_val_t sux_tum2_past(el_val_t slot);
|
||||
el_val_t sux_tum2_present(el_val_t slot);
|
||||
el_val_t sux_verb_chain(el_val_t agent, el_val_t verb, el_val_t patient, el_val_t tense);
|
||||
@@ -1157,9 +1135,9 @@ el_val_t sw_noun_plural(el_val_t noun);
|
||||
el_val_t sw_obj_prefix(el_val_t person, el_val_t number, el_val_t noun_class);
|
||||
el_val_t sw_str_drop_last(el_val_t s, el_val_t n);
|
||||
el_val_t sw_str_ends(el_val_t s, el_val_t suf);
|
||||
el_val_t sw_str_first_char(el_val_t s);
|
||||
el_val_t sw_str_first2(el_val_t s);
|
||||
el_val_t sw_str_first3(el_val_t s);
|
||||
el_val_t sw_str_first_char(el_val_t s);
|
||||
el_val_t sw_str_last_char(el_val_t s);
|
||||
el_val_t sw_subj_prefix(el_val_t person, el_val_t number, el_val_t noun_class);
|
||||
el_val_t sw_tense_marker(el_val_t tense);
|
||||
@@ -1173,13 +1151,11 @@ el_val_t threat_trajectory_check(el_val_t tool_name, el_val_t tool_input);
|
||||
el_val_t tier_canonical(void);
|
||||
el_val_t tier_episodic(void);
|
||||
el_val_t tier_working(void);
|
||||
el_val_t tombstone_node(el_val_t id);
|
||||
el_val_t tombstoned_id_set(void);
|
||||
el_val_t tool_auto_approved(el_val_t tool_name);
|
||||
el_val_t txb_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
|
||||
el_val_t txb_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
|
||||
el_val_t txb_decline_fem(el_val_t noun, el_val_t gram_case, el_val_t number);
|
||||
el_val_t txb_decline_masc(el_val_t noun, el_val_t gram_case, el_val_t number);
|
||||
el_val_t txb_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
|
||||
el_val_t txb_detect_gender(el_val_t noun);
|
||||
el_val_t txb_drop(el_val_t s, el_val_t n);
|
||||
el_val_t txb_ends(el_val_t s, el_val_t suf);
|
||||
@@ -1194,8 +1170,8 @@ el_val_t txb_wes_present(el_val_t slot);
|
||||
el_val_t txb_ya_present(el_val_t slot);
|
||||
el_val_t uga_amr_imperfect(el_val_t slot);
|
||||
el_val_t uga_amr_perfect(el_val_t slot);
|
||||
el_val_t uga_conjugate_copula(el_val_t tense, el_val_t slot);
|
||||
el_val_t uga_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
|
||||
el_val_t uga_conjugate_copula(el_val_t tense, el_val_t slot);
|
||||
el_val_t uga_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
|
||||
el_val_t uga_generic_imperfect(el_val_t base3sg, el_val_t slot);
|
||||
el_val_t uga_generic_perfect(el_val_t base3sg, el_val_t slot);
|
||||
@@ -1210,8 +1186,8 @@ el_val_t uga_map_canonical(el_val_t verb);
|
||||
el_val_t uga_noun_phrase(el_val_t noun, el_val_t gram_case, el_val_t number, el_val_t definite);
|
||||
el_val_t uga_ray_imperfect(el_val_t slot);
|
||||
el_val_t uga_ray_perfect(el_val_t slot);
|
||||
el_val_t uga_slot_g(el_val_t person, el_val_t gender, el_val_t number);
|
||||
el_val_t uga_slot(el_val_t person, el_val_t number);
|
||||
el_val_t uga_slot_g(el_val_t person, el_val_t gender, el_val_t number);
|
||||
el_val_t uga_str_drop_last(el_val_t s, el_val_t n);
|
||||
el_val_t uga_str_ends(el_val_t s, el_val_t suf);
|
||||
el_val_t uga_str_len(el_val_t s);
|
||||
@@ -1219,6 +1195,6 @@ el_val_t uga_strip_nom(el_val_t noun);
|
||||
el_val_t verb_form(el_val_t base, el_val_t tense, el_val_t person, el_val_t number);
|
||||
el_val_t vocab_by_class(el_val_t cls);
|
||||
el_val_t vocab_by_pos(el_val_t pos);
|
||||
el_val_t vocab_lookup_en(el_val_t word);
|
||||
el_val_t vocab_lookup(el_val_t word, el_val_t lang_code);
|
||||
el_val_t vocab_lookup_en(el_val_t word);
|
||||
el_val_t vocab_synonym(el_val_t word, el_val_t lang_register, el_val_t lang_code);
|
||||
|
||||
+1
-27
@@ -169,7 +169,7 @@ el_val_t mem_boot_count_inc(void) {
|
||||
}
|
||||
el_val_t content = el_str_concat(EL_STR("soul:boot_count:"), int_to_str(next));
|
||||
el_val_t tags = EL_STR("[\"soul-meta\",\"boot-counter\"]");
|
||||
el_val_t boot_node_id = engram_node_full(content, EL_STR("Memory"), EL_STR("soul:boot_count"), el_from_float(0.55), el_from_float(0.2), el_from_float(1.0), EL_STR("Working"), tags);
|
||||
el_val_t boot_node_id = engram_node_full(content, EL_STR("Memory"), EL_STR("soul:boot_count"), el_from_float(0.9), el_from_float(0.9), el_from_float(1.0), EL_STR("Canonical"), tags);
|
||||
if (str_eq(boot_node_id, EL_STR(""))) {
|
||||
println(el_str_concat(el_str_concat(EL_STR("[memory] mem_boot_count_inc: write rejected (empty id) \xe2\x80\x94 boot counter node lost (count="), int_to_str(next)), EL_STR(")")));
|
||||
return next;
|
||||
@@ -178,32 +178,6 @@ el_val_t mem_boot_count_inc(void) {
|
||||
if (str_eq(boot_readback, EL_STR("")) || str_eq(boot_readback, EL_STR("{}"))) {
|
||||
println(el_str_concat(el_str_concat(el_str_concat(EL_STR("[memory] mem_boot_count_inc: WRITE VERIFY FAILED id="), boot_node_id), EL_STR(" count=")), int_to_str(next)));
|
||||
}
|
||||
el_val_t wb_url = env(EL_STR("ENGRAM_URL"));
|
||||
el_val_t wb_key = env(EL_STR("ENGRAM_API_KEY"));
|
||||
if (!str_eq(wb_url, EL_STR("")) && !str_eq(wb_key, EL_STR(""))) {
|
||||
el_val_t auth_body = el_str_concat(el_str_concat(EL_STR("{\"_auth\":\""), json_safe(wb_key)), EL_STR("\"}"));
|
||||
el_val_t srv_old = http_get(el_str_concat(wb_url, EL_STR("/api/search?q=soul:boot_count&limit=20")));
|
||||
if (!str_eq(srv_old, EL_STR("")) && !str_eq(srv_old, EL_STR("[]"))) {
|
||||
el_val_t srv_len = json_array_len(srv_old);
|
||||
el_val_t si = 0;
|
||||
while (si < srv_len) {
|
||||
el_val_t srv_node = json_array_get(srv_old, si);
|
||||
el_val_t srv_content = json_get(srv_node, EL_STR("content"));
|
||||
if (str_starts_with(srv_content, EL_STR("soul:boot_count:"))) {
|
||||
el_val_t srv_id = json_get(srv_node, EL_STR("id"));
|
||||
if (!str_eq(srv_id, EL_STR(""))) {
|
||||
http_delete_json(el_str_concat(el_str_concat(wb_url, EL_STR("/api/nodes/")), srv_id), auth_body);
|
||||
}
|
||||
}
|
||||
si = (si + 1);
|
||||
}
|
||||
}
|
||||
el_val_t wb_body = el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"content\":\""), content), EL_STR("\",\"node_type\":\"Memory\",\"label\":\"soul:boot_count\",\"salience\":0.55,\"importance\":0.2,\"tier\":\"Working\",\"tags\":\"[\\\"soul-meta\\\",\\\"boot-counter\\\"]\",\"_auth\":\"")), json_safe(wb_key)), EL_STR("\"}"));
|
||||
el_val_t wb_resp = http_post_json(el_str_concat(wb_url, EL_STR("/api/nodes")), wb_body);
|
||||
if (str_contains(wb_resp, EL_STR("\"error\""))) {
|
||||
println(el_str_concat(EL_STR("[memory] mem_boot_count_inc: HTTP write-back failed (count in-memory only): "), wb_resp));
|
||||
}
|
||||
}
|
||||
return next;
|
||||
return 0;
|
||||
}
|
||||
|
||||
+59
-141
@@ -10,6 +10,7 @@ el_val_t mem_remember(el_val_t content, el_val_t tags);
|
||||
el_val_t mem_recall(el_val_t query, el_val_t depth);
|
||||
el_val_t mem_search(el_val_t query, el_val_t limit);
|
||||
el_val_t mem_strengthen(el_val_t node_id);
|
||||
el_val_t mem_tombstone(el_val_t node_id);
|
||||
el_val_t mem_forget(el_val_t node_id);
|
||||
el_val_t mem_consolidate(void);
|
||||
el_val_t mem_save(el_val_t path);
|
||||
@@ -26,11 +27,6 @@ el_val_t api_ok(el_val_t extra);
|
||||
el_val_t api_err(el_val_t msg);
|
||||
el_val_t api_nonempty(el_val_t s);
|
||||
el_val_t api_or_empty(el_val_t s);
|
||||
el_val_t api_num_or_zero(el_val_t obj, el_val_t key);
|
||||
el_val_t api_utf8_trunc(el_val_t s, el_val_t n);
|
||||
el_val_t api_compact_node(el_val_t node, el_val_t snip);
|
||||
el_val_t api_compact_node_array(el_val_t raw, el_val_t max_items, el_val_t snip);
|
||||
el_val_t api_compact_activated(el_val_t raw, el_val_t max_items, el_val_t snip);
|
||||
el_val_t api_persisted(el_val_t id);
|
||||
el_val_t api_not_persisted(el_val_t id);
|
||||
el_val_t tombstone_node(el_val_t id);
|
||||
@@ -183,80 +179,6 @@ el_val_t api_or_empty(el_val_t s) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
el_val_t api_num_or_zero(el_val_t obj, el_val_t key) {
|
||||
el_val_t v = json_get_raw(obj, key);
|
||||
if (str_eq(v, EL_STR(""))) {
|
||||
return EL_STR("0");
|
||||
}
|
||||
return v;
|
||||
return 0;
|
||||
}
|
||||
|
||||
el_val_t api_utf8_trunc(el_val_t s, el_val_t n) {
|
||||
if (str_len(s) <= n) {
|
||||
return s;
|
||||
}
|
||||
el_val_t cut = n;
|
||||
el_val_t scanning = 1;
|
||||
while (scanning && (cut > 0)) {
|
||||
el_val_t b = str_char_code(s, cut);
|
||||
el_val_t is_cont = ((b >= 128) && (b < 192));
|
||||
cut = ({ el_val_t _if_result_1 = 0; if (is_cont) { _if_result_1 = ((cut - 1)); } else { _if_result_1 = (cut); } _if_result_1; });
|
||||
scanning = is_cont;
|
||||
}
|
||||
return str_slice(s, 0, cut);
|
||||
return 0;
|
||||
}
|
||||
|
||||
el_val_t api_compact_node(el_val_t node, el_val_t snip) {
|
||||
el_val_t id = json_get(node, EL_STR("id"));
|
||||
el_val_t ntype = json_get(node, EL_STR("node_type"));
|
||||
el_val_t label = json_get(node, EL_STR("label"));
|
||||
el_val_t tier = json_get(node, EL_STR("tier"));
|
||||
el_val_t content = json_get(node, EL_STR("content"));
|
||||
el_val_t snippet = api_utf8_trunc(content, snip);
|
||||
el_val_t trunc_str = ({ el_val_t _if_result_2 = 0; if ((str_len(content) > snip)) { _if_result_2 = (EL_STR("true")); } else { _if_result_2 = (EL_STR("false")); } _if_result_2; });
|
||||
return el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"id\":\""), api_json_escape(id)), EL_STR("\"")), EL_STR(",\"node_type\":\"")), api_json_escape(ntype)), EL_STR("\"")), EL_STR(",\"label\":\"")), api_json_escape(label)), EL_STR("\"")), EL_STR(",\"tier\":\"")), api_json_escape(tier)), EL_STR("\"")), EL_STR(",\"importance\":")), api_num_or_zero(node, EL_STR("importance"))), EL_STR(",\"salience\":")), api_num_or_zero(node, EL_STR("salience"))), EL_STR(",\"content\":\"")), api_json_escape(snippet)), EL_STR("\"")), EL_STR(",\"content_truncated\":")), trunc_str), EL_STR("}"));
|
||||
return 0;
|
||||
}
|
||||
|
||||
el_val_t api_compact_node_array(el_val_t raw, el_val_t max_items, el_val_t snip) {
|
||||
if (!api_nonempty(raw)) {
|
||||
return EL_STR("[]");
|
||||
}
|
||||
el_val_t n = json_array_len(raw);
|
||||
el_val_t cap = ({ el_val_t _if_result_3 = 0; if ((n < max_items)) { _if_result_3 = (n); } else { _if_result_3 = (max_items); } _if_result_3; });
|
||||
el_val_t out = EL_STR("[");
|
||||
el_val_t i = 0;
|
||||
while (i < cap) {
|
||||
el_val_t node = json_array_get(raw, i);
|
||||
el_val_t sep = ({ el_val_t _if_result_4 = 0; if ((i == 0)) { _if_result_4 = (EL_STR("")); } else { _if_result_4 = (EL_STR(",")); } _if_result_4; });
|
||||
out = el_str_concat(el_str_concat(out, sep), api_compact_node(node, snip));
|
||||
i = (i + 1);
|
||||
}
|
||||
return el_str_concat(out, EL_STR("]"));
|
||||
return 0;
|
||||
}
|
||||
|
||||
el_val_t api_compact_activated(el_val_t raw, el_val_t max_items, el_val_t snip) {
|
||||
if (!api_nonempty(raw)) {
|
||||
return EL_STR("[]");
|
||||
}
|
||||
el_val_t n = json_array_len(raw);
|
||||
el_val_t cap = ({ el_val_t _if_result_5 = 0; if ((n < max_items)) { _if_result_5 = (n); } else { _if_result_5 = (max_items); } _if_result_5; });
|
||||
el_val_t out = EL_STR("[");
|
||||
el_val_t i = 0;
|
||||
while (i < cap) {
|
||||
el_val_t el = json_array_get(raw, i);
|
||||
el_val_t node = json_get_raw(el, EL_STR("node"));
|
||||
el_val_t sep = ({ el_val_t _if_result_6 = 0; if ((i == 0)) { _if_result_6 = (EL_STR("")); } else { _if_result_6 = (EL_STR(",")); } _if_result_6; });
|
||||
out = el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(out, sep), EL_STR("{\"node\":")), api_compact_node(node, snip)), EL_STR(",\"activation_strength\":")), api_num_or_zero(el, EL_STR("activation_strength"))), EL_STR(",\"working_memory_weight\":")), api_num_or_zero(el, EL_STR("working_memory_weight"))), EL_STR(",\"epistemic_confidence\":")), api_num_or_zero(el, EL_STR("epistemic_confidence"))), EL_STR(",\"hops\":")), api_num_or_zero(el, EL_STR("hops"))), EL_STR(",\"promoted\":")), api_num_or_zero(el, EL_STR("promoted"))), EL_STR("}"));
|
||||
i = (i + 1);
|
||||
}
|
||||
return el_str_concat(out, EL_STR("]"));
|
||||
return 0;
|
||||
}
|
||||
|
||||
el_val_t api_persisted(el_val_t id) {
|
||||
if (str_eq(id, EL_STR(""))) {
|
||||
return 0;
|
||||
@@ -287,7 +209,7 @@ el_val_t tombstoned_id_set(void) {
|
||||
while (i < n) {
|
||||
el_val_t m = json_array_get(markers, i);
|
||||
el_val_t tid = json_get(m, EL_STR("content"));
|
||||
acc = ({ el_val_t _if_result_7 = 0; if (str_eq(tid, EL_STR(""))) { _if_result_7 = (acc); } else { _if_result_7 = (el_str_concat(el_str_concat(acc, tid), EL_STR("|"))); } _if_result_7; });
|
||||
acc = ({ el_val_t _if_result_1 = 0; if (str_eq(tid, EL_STR(""))) { _if_result_1 = (acc); } else { _if_result_1 = (el_str_concat(el_str_concat(acc, tid), EL_STR("|"))); } _if_result_1; });
|
||||
i = (i + 1);
|
||||
}
|
||||
return acc;
|
||||
@@ -318,8 +240,8 @@ el_val_t memory_hide_tombstoned(el_val_t raw, el_val_t path) {
|
||||
el_val_t ntype = json_get(node, EL_STR("node_type"));
|
||||
el_val_t is_dead = (!str_eq(nid, EL_STR("")) && str_contains(dead, el_str_concat(el_str_concat(EL_STR("|"), nid), EL_STR("|"))));
|
||||
el_val_t keep = (!str_eq(ntype, EL_STR("Tombstone")) && !is_dead);
|
||||
out = ({ el_val_t _if_result_8 = 0; if (keep) { _if_result_8 = (({ el_val_t _if_result_9 = 0; if (first) { _if_result_9 = (el_str_concat(out, node)); } else { _if_result_9 = (el_str_concat(el_str_concat(out, EL_STR(",")), node)); } _if_result_9; })); } else { _if_result_8 = (out); } _if_result_8; });
|
||||
first = ({ el_val_t _if_result_10 = 0; if (keep) { _if_result_10 = (0); } else { _if_result_10 = (first); } _if_result_10; });
|
||||
out = ({ el_val_t _if_result_2 = 0; if (keep) { _if_result_2 = (({ el_val_t _if_result_3 = 0; if (first) { _if_result_3 = (el_str_concat(out, node)); } else { _if_result_3 = (el_str_concat(el_str_concat(out, EL_STR(",")), node)); } _if_result_3; })); } else { _if_result_2 = (out); } _if_result_2; });
|
||||
first = ({ el_val_t _if_result_4 = 0; if (keep) { _if_result_4 = (0); } else { _if_result_4 = (first); } _if_result_4; });
|
||||
i = (i + 1);
|
||||
}
|
||||
return el_str_concat(out, EL_STR("]"));
|
||||
@@ -328,23 +250,19 @@ el_val_t memory_hide_tombstoned(el_val_t raw, el_val_t path) {
|
||||
|
||||
el_val_t handle_api_begin_session(el_val_t body) {
|
||||
el_val_t stats = engram_stats_json();
|
||||
el_val_t activated_raw = engram_activate_json(EL_STR("session start recent memory important"), 1);
|
||||
el_val_t activated = api_compact_activated(activated_raw, 8, 240);
|
||||
el_val_t state_events_raw = engram_scan_nodes_by_type_json(EL_STR("InternalStateEvent"), 5, 0);
|
||||
el_val_t state_events = api_compact_node_array(state_events_raw, 5, 500);
|
||||
el_val_t recent_raw = engram_scan_nodes_json(10, 0);
|
||||
el_val_t recent = api_compact_node_array(recent_raw, 10, 240);
|
||||
return el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"stats\":"), stats), EL_STR(",\"recent\":")), recent), EL_STR(",\"activated\":")), activated), EL_STR(",\"self_neighbors\":[]")), EL_STR(",\"recent_state_events\":")), state_events), EL_STR("}"));
|
||||
el_val_t activated = engram_activate_json(EL_STR("session start recent memory important"), 2);
|
||||
el_val_t self_nbrs = engram_neighbors_json(EL_STR("kn-efeb4a5b-5aff-4759-8a97-7233099be6ee"), 1, EL_STR("both"));
|
||||
el_val_t state_events = engram_scan_nodes_by_type_json(EL_STR("InternalStateEvent"), 5, 0);
|
||||
el_val_t recent = engram_scan_nodes_json(10, 0);
|
||||
return el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"stats\":"), stats), EL_STR(",\"recent\":")), api_or_empty(recent)), EL_STR(",\"activated\":")), api_or_empty(activated)), EL_STR(",\"self_neighbors\":")), api_or_empty(self_nbrs)), EL_STR(",\"recent_state_events\":")), api_or_empty(state_events)), EL_STR("}"));
|
||||
return 0;
|
||||
}
|
||||
|
||||
el_val_t handle_api_compile_ctx(el_val_t body) {
|
||||
el_val_t stats = engram_stats_json();
|
||||
el_val_t activated_raw = engram_activate_json(EL_STR("active work context current task in progress"), 2);
|
||||
el_val_t activated = api_compact_activated(activated_raw, 10, 240);
|
||||
el_val_t recent_raw = engram_scan_nodes_json(20, 0);
|
||||
el_val_t recent = api_compact_node_array(recent_raw, 20, 240);
|
||||
return el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"stats\":"), stats), EL_STR(",\"recent_nodes\":")), recent), EL_STR(",\"activated\":")), activated), EL_STR("}"));
|
||||
el_val_t activated = engram_activate_json(EL_STR("active work context current task in progress"), 2);
|
||||
el_val_t recent = engram_scan_nodes_json(20, 0);
|
||||
return el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"stats\":"), stats), EL_STR(",\"recent_nodes\":")), api_or_empty(recent)), EL_STR(",\"activated\":")), api_or_empty(activated)), EL_STR("}"));
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -356,10 +274,10 @@ el_val_t handle_api_remember(el_val_t body) {
|
||||
el_val_t importance = json_get(body, EL_STR("importance"));
|
||||
el_val_t tags_raw = json_get(body, EL_STR("tags"));
|
||||
el_val_t project = json_get(body, EL_STR("project"));
|
||||
el_val_t sal_str = ({ el_val_t _if_result_11 = 0; if (str_eq(importance, EL_STR("critical"))) { _if_result_11 = (EL_STR("0.95")); } else { _if_result_11 = (({ el_val_t _if_result_12 = 0; if (str_eq(importance, EL_STR("high"))) { _if_result_12 = (EL_STR("0.75")); } else { _if_result_12 = (({ el_val_t _if_result_13 = 0; if (str_eq(importance, EL_STR("low"))) { _if_result_13 = (EL_STR("0.25")); } else { _if_result_13 = (EL_STR("0.50")); } _if_result_13; })); } _if_result_12; })); } _if_result_11; });
|
||||
el_val_t sal = ({ el_val_t _if_result_14 = 0; if (str_eq(sal_str, EL_STR("0.95"))) { _if_result_14 = (el_from_float(0.95)); } else { _if_result_14 = (({ el_val_t _if_result_15 = 0; if (str_eq(sal_str, EL_STR("0.75"))) { _if_result_15 = (el_from_float(0.75)); } else { _if_result_15 = (({ el_val_t _if_result_16 = 0; if (str_eq(sal_str, EL_STR("0.25"))) { _if_result_16 = (el_from_float(0.25)); } else { _if_result_16 = (el_from_float(0.5)); } _if_result_16; })); } _if_result_15; })); } _if_result_14; });
|
||||
el_val_t base_tags = ({ el_val_t _if_result_17 = 0; if (str_eq(tags_raw, EL_STR(""))) { _if_result_17 = (EL_STR("[\"Memory\"]")); } else { _if_result_17 = (tags_raw); } _if_result_17; });
|
||||
el_val_t final_tags = ({ el_val_t _if_result_18 = 0; if (str_eq(project, EL_STR(""))) { _if_result_18 = (base_tags); } else { el_val_t inner = str_slice(base_tags, 1, (str_len(base_tags) - 1)); _if_result_18 = (el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("["), inner), EL_STR(",\"project:")), project), EL_STR("\"]"))); } _if_result_18; });
|
||||
el_val_t sal_str = ({ el_val_t _if_result_5 = 0; if (str_eq(importance, EL_STR("critical"))) { _if_result_5 = (EL_STR("0.95")); } else { _if_result_5 = (({ el_val_t _if_result_6 = 0; if (str_eq(importance, EL_STR("high"))) { _if_result_6 = (EL_STR("0.75")); } else { _if_result_6 = (({ el_val_t _if_result_7 = 0; if (str_eq(importance, EL_STR("low"))) { _if_result_7 = (EL_STR("0.25")); } else { _if_result_7 = (EL_STR("0.50")); } _if_result_7; })); } _if_result_6; })); } _if_result_5; });
|
||||
el_val_t sal = ({ el_val_t _if_result_8 = 0; if (str_eq(sal_str, EL_STR("0.95"))) { _if_result_8 = (el_from_float(0.95)); } else { _if_result_8 = (({ el_val_t _if_result_9 = 0; if (str_eq(sal_str, EL_STR("0.75"))) { _if_result_9 = (el_from_float(0.75)); } else { _if_result_9 = (({ el_val_t _if_result_10 = 0; if (str_eq(sal_str, EL_STR("0.25"))) { _if_result_10 = (el_from_float(0.25)); } else { _if_result_10 = (el_from_float(0.5)); } _if_result_10; })); } _if_result_9; })); } _if_result_8; });
|
||||
el_val_t base_tags = ({ el_val_t _if_result_11 = 0; if (str_eq(tags_raw, EL_STR(""))) { _if_result_11 = (EL_STR("[\"Memory\"]")); } else { _if_result_11 = (tags_raw); } _if_result_11; });
|
||||
el_val_t final_tags = ({ el_val_t _if_result_12 = 0; if (str_eq(project, EL_STR(""))) { _if_result_12 = (base_tags); } else { el_val_t inner = str_slice(base_tags, 1, (str_len(base_tags) - 1)); _if_result_12 = (el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("["), inner), EL_STR(",\"project:")), project), EL_STR("\"]"))); } _if_result_12; });
|
||||
el_val_t id = engram_node_full(content, EL_STR("Memory"), EL_STR("memory:remembered"), el_from_float(sal), el_from_float(sal), el_from_float(0.9), EL_STR("Episodic"), final_tags);
|
||||
if (!api_persisted(id)) {
|
||||
return api_not_persisted(id);
|
||||
@@ -374,15 +292,15 @@ el_val_t handle_api_node_create(el_val_t body) {
|
||||
return api_err(EL_STR("content is required"));
|
||||
}
|
||||
el_val_t nt_raw = json_get(body, EL_STR("node_type"));
|
||||
el_val_t node_type = ({ el_val_t _if_result_19 = 0; if (str_eq(nt_raw, EL_STR(""))) { _if_result_19 = (EL_STR("Memory")); } else { _if_result_19 = (nt_raw); } _if_result_19; });
|
||||
el_val_t node_type = ({ el_val_t _if_result_13 = 0; if (str_eq(nt_raw, EL_STR(""))) { _if_result_13 = (EL_STR("Memory")); } else { _if_result_13 = (nt_raw); } _if_result_13; });
|
||||
el_val_t label_raw = json_get(body, EL_STR("label"));
|
||||
el_val_t label = ({ el_val_t _if_result_20 = 0; if (str_eq(label_raw, EL_STR(""))) { _if_result_20 = (EL_STR("node:created")); } else { _if_result_20 = (label_raw); } _if_result_20; });
|
||||
el_val_t label = ({ el_val_t _if_result_14 = 0; if (str_eq(label_raw, EL_STR(""))) { _if_result_14 = (EL_STR("node:created")); } else { _if_result_14 = (label_raw); } _if_result_14; });
|
||||
el_val_t tier_raw = json_get(body, EL_STR("tier"));
|
||||
el_val_t tier = ({ el_val_t _if_result_21 = 0; if (str_eq(tier_raw, EL_STR(""))) { _if_result_21 = (EL_STR("Episodic")); } else { _if_result_21 = (tier_raw); } _if_result_21; });
|
||||
el_val_t tier = ({ el_val_t _if_result_15 = 0; if (str_eq(tier_raw, EL_STR(""))) { _if_result_15 = (EL_STR("Episodic")); } else { _if_result_15 = (tier_raw); } _if_result_15; });
|
||||
el_val_t tags_raw = json_get(body, EL_STR("tags"));
|
||||
el_val_t tags = ({ el_val_t _if_result_22 = 0; if (str_eq(tags_raw, EL_STR(""))) { _if_result_22 = (el_str_concat(el_str_concat(EL_STR("[\""), node_type), EL_STR("\"]"))); } else { _if_result_22 = (tags_raw); } _if_result_22; });
|
||||
el_val_t tags = ({ el_val_t _if_result_16 = 0; if (str_eq(tags_raw, EL_STR(""))) { _if_result_16 = (el_str_concat(el_str_concat(EL_STR("[\""), node_type), EL_STR("\"]"))); } else { _if_result_16 = (tags_raw); } _if_result_16; });
|
||||
el_val_t importance = json_get(body, EL_STR("importance"));
|
||||
el_val_t sal = ({ el_val_t _if_result_23 = 0; if (str_eq(importance, EL_STR("critical"))) { _if_result_23 = (el_from_float(0.95)); } else { _if_result_23 = (({ el_val_t _if_result_24 = 0; if (str_eq(importance, EL_STR("high"))) { _if_result_24 = (el_from_float(0.75)); } else { _if_result_24 = (({ el_val_t _if_result_25 = 0; if (str_eq(importance, EL_STR("low"))) { _if_result_25 = (el_from_float(0.25)); } else { _if_result_25 = (el_from_float(0.5)); } _if_result_25; })); } _if_result_24; })); } _if_result_23; });
|
||||
el_val_t sal = ({ el_val_t _if_result_17 = 0; if (str_eq(importance, EL_STR("critical"))) { _if_result_17 = (el_from_float(0.95)); } else { _if_result_17 = (({ el_val_t _if_result_18 = 0; if (str_eq(importance, EL_STR("high"))) { _if_result_18 = (el_from_float(0.75)); } else { _if_result_18 = (({ el_val_t _if_result_19 = 0; if (str_eq(importance, EL_STR("low"))) { _if_result_19 = (el_from_float(0.25)); } else { _if_result_19 = (el_from_float(0.5)); } _if_result_19; })); } _if_result_18; })); } _if_result_17; });
|
||||
el_val_t id = engram_node_full(content, node_type, label, el_from_float(sal), el_from_float(sal), el_from_float(0.9), tier, tags);
|
||||
if (!api_persisted(id)) {
|
||||
return api_not_persisted(id);
|
||||
@@ -421,18 +339,18 @@ el_val_t handle_api_node_update(el_val_t body) {
|
||||
}
|
||||
el_val_t old = engram_get_node_json(id);
|
||||
el_val_t body_content = json_get(body, EL_STR("content"));
|
||||
el_val_t content = ({ el_val_t _if_result_26 = 0; if (str_eq(body_content, EL_STR(""))) { _if_result_26 = (json_get(old, EL_STR("content"))); } else { _if_result_26 = (body_content); } _if_result_26; });
|
||||
el_val_t content = ({ el_val_t _if_result_20 = 0; if (str_eq(body_content, EL_STR(""))) { _if_result_20 = (json_get(old, EL_STR("content"))); } else { _if_result_20 = (body_content); } _if_result_20; });
|
||||
el_val_t body_nt = json_get(body, EL_STR("node_type"));
|
||||
el_val_t old_nt = json_get(old, EL_STR("node_type"));
|
||||
el_val_t node_type = ({ el_val_t _if_result_27 = 0; if (!str_eq(body_nt, EL_STR(""))) { _if_result_27 = (body_nt); } else { _if_result_27 = (({ el_val_t _if_result_28 = 0; if (!str_eq(old_nt, EL_STR(""))) { _if_result_28 = (old_nt); } else { _if_result_28 = (EL_STR("Memory")); } _if_result_28; })); } _if_result_27; });
|
||||
el_val_t node_type = ({ el_val_t _if_result_21 = 0; if (!str_eq(body_nt, EL_STR(""))) { _if_result_21 = (body_nt); } else { _if_result_21 = (({ el_val_t _if_result_22 = 0; if (!str_eq(old_nt, EL_STR(""))) { _if_result_22 = (old_nt); } else { _if_result_22 = (EL_STR("Memory")); } _if_result_22; })); } _if_result_21; });
|
||||
el_val_t body_label = json_get(body, EL_STR("label"));
|
||||
el_val_t old_label = json_get(old, EL_STR("label"));
|
||||
el_val_t label = ({ el_val_t _if_result_29 = 0; if (!str_eq(body_label, EL_STR(""))) { _if_result_29 = (body_label); } else { _if_result_29 = (({ el_val_t _if_result_30 = 0; if (!str_eq(old_label, EL_STR(""))) { _if_result_30 = (old_label); } else { _if_result_30 = (EL_STR("node:updated")); } _if_result_30; })); } _if_result_29; });
|
||||
el_val_t label = ({ el_val_t _if_result_23 = 0; if (!str_eq(body_label, EL_STR(""))) { _if_result_23 = (body_label); } else { _if_result_23 = (({ el_val_t _if_result_24 = 0; if (!str_eq(old_label, EL_STR(""))) { _if_result_24 = (old_label); } else { _if_result_24 = (EL_STR("node:updated")); } _if_result_24; })); } _if_result_23; });
|
||||
el_val_t body_tier = json_get(body, EL_STR("tier"));
|
||||
el_val_t old_tier = json_get(old, EL_STR("tier"));
|
||||
el_val_t tier = ({ el_val_t _if_result_31 = 0; if (!str_eq(body_tier, EL_STR(""))) { _if_result_31 = (body_tier); } else { _if_result_31 = (({ el_val_t _if_result_32 = 0; if (!str_eq(old_tier, EL_STR(""))) { _if_result_32 = (old_tier); } else { _if_result_32 = (EL_STR("Episodic")); } _if_result_32; })); } _if_result_31; });
|
||||
el_val_t tier = ({ el_val_t _if_result_25 = 0; if (!str_eq(body_tier, EL_STR(""))) { _if_result_25 = (body_tier); } else { _if_result_25 = (({ el_val_t _if_result_26 = 0; if (!str_eq(old_tier, EL_STR(""))) { _if_result_26 = (old_tier); } else { _if_result_26 = (EL_STR("Episodic")); } _if_result_26; })); } _if_result_25; });
|
||||
el_val_t body_tags = json_get(body, EL_STR("tags"));
|
||||
el_val_t tags = ({ el_val_t _if_result_33 = 0; if (str_eq(body_tags, EL_STR(""))) { _if_result_33 = (el_str_concat(el_str_concat(EL_STR("[\""), node_type), EL_STR("\"]"))); } else { _if_result_33 = (body_tags); } _if_result_33; });
|
||||
el_val_t tags = ({ el_val_t _if_result_27 = 0; if (str_eq(body_tags, EL_STR(""))) { _if_result_27 = (el_str_concat(el_str_concat(EL_STR("[\""), node_type), EL_STR("\"]"))); } else { _if_result_27 = (body_tags); } _if_result_27; });
|
||||
el_val_t new_id = engram_node_full(content, node_type, label, el_from_float(0.5), el_from_float(0.5), el_from_float(0.8), tier, tags);
|
||||
if (!api_persisted(new_id)) {
|
||||
return api_not_persisted(new_id);
|
||||
@@ -443,15 +361,15 @@ el_val_t handle_api_node_update(el_val_t body) {
|
||||
}
|
||||
|
||||
el_val_t handle_api_recall(el_val_t method, el_val_t path, el_val_t body) {
|
||||
el_val_t url_q = ({ el_val_t _if_result_34 = 0; if (str_eq(api_query_param(path, EL_STR("query")), EL_STR(""))) { _if_result_34 = (api_query_param(path, EL_STR("q"))); } else { _if_result_34 = (api_query_param(path, EL_STR("query"))); } _if_result_34; });
|
||||
el_val_t url_q = ({ el_val_t _if_result_28 = 0; if (str_eq(api_query_param(path, EL_STR("query")), EL_STR(""))) { _if_result_28 = (api_query_param(path, EL_STR("q"))); } else { _if_result_28 = (api_query_param(path, EL_STR("query"))); } _if_result_28; });
|
||||
el_val_t body_query = json_get(body, EL_STR("query"));
|
||||
el_val_t body_q = json_get(body, EL_STR("q"));
|
||||
el_val_t q = ({ el_val_t _if_result_35 = 0; if (!str_eq(url_q, EL_STR(""))) { _if_result_35 = (url_q); } else { _if_result_35 = (({ el_val_t _if_result_36 = 0; if (!str_eq(body_query, EL_STR(""))) { _if_result_36 = (body_query); } else { _if_result_36 = (body_q); } _if_result_36; })); } _if_result_35; });
|
||||
el_val_t q = ({ el_val_t _if_result_29 = 0; if (!str_eq(url_q, EL_STR(""))) { _if_result_29 = (url_q); } else { _if_result_29 = (({ el_val_t _if_result_30 = 0; if (!str_eq(body_query, EL_STR(""))) { _if_result_30 = (body_query); } else { _if_result_30 = (body_q); } _if_result_30; })); } _if_result_29; });
|
||||
el_val_t chain = json_get(body, EL_STR("chain_name"));
|
||||
el_val_t limit = api_query_int(path, EL_STR("limit"), 0);
|
||||
limit = ({ el_val_t _if_result_37 = 0; if ((limit == 0)) { _if_result_37 = (json_get_int(body, EL_STR("limit"))); } else { _if_result_37 = (limit); } _if_result_37; });
|
||||
limit = ({ el_val_t _if_result_38 = 0; if ((limit == 0)) { _if_result_38 = (10); } else { _if_result_38 = (limit); } _if_result_38; });
|
||||
el_val_t eff_q = ({ el_val_t _if_result_39 = 0; if (str_eq(q, EL_STR(""))) { _if_result_39 = (chain); } else { _if_result_39 = (q); } _if_result_39; });
|
||||
limit = ({ el_val_t _if_result_31 = 0; if ((limit == 0)) { _if_result_31 = (json_get_int(body, EL_STR("limit"))); } else { _if_result_31 = (limit); } _if_result_31; });
|
||||
limit = ({ el_val_t _if_result_32 = 0; if ((limit == 0)) { _if_result_32 = (10); } else { _if_result_32 = (limit); } _if_result_32; });
|
||||
el_val_t eff_q = ({ el_val_t _if_result_33 = 0; if (str_eq(q, EL_STR(""))) { _if_result_33 = (chain); } else { _if_result_33 = (q); } _if_result_33; });
|
||||
if (str_eq(eff_q, EL_STR(""))) {
|
||||
return api_or_empty(engram_scan_nodes_json(limit, 0));
|
||||
}
|
||||
@@ -464,10 +382,10 @@ el_val_t handle_api_search_knowledge(el_val_t method, el_val_t path, el_val_t bo
|
||||
el_val_t url_q = api_query_param(path, EL_STR("q"));
|
||||
el_val_t body_query = json_get(body, EL_STR("query"));
|
||||
el_val_t body_q = json_get(body, EL_STR("q"));
|
||||
el_val_t q = ({ el_val_t _if_result_40 = 0; if (!str_eq(url_q, EL_STR(""))) { _if_result_40 = (url_q); } else { _if_result_40 = (({ el_val_t _if_result_41 = 0; if (!str_eq(body_query, EL_STR(""))) { _if_result_41 = (body_query); } else { _if_result_41 = (body_q); } _if_result_41; })); } _if_result_40; });
|
||||
el_val_t q = ({ el_val_t _if_result_34 = 0; if (!str_eq(url_q, EL_STR(""))) { _if_result_34 = (url_q); } else { _if_result_34 = (({ el_val_t _if_result_35 = 0; if (!str_eq(body_query, EL_STR(""))) { _if_result_35 = (body_query); } else { _if_result_35 = (body_q); } _if_result_35; })); } _if_result_34; });
|
||||
el_val_t limit = api_query_int(path, EL_STR("limit"), 0);
|
||||
limit = ({ el_val_t _if_result_42 = 0; if ((limit == 0)) { _if_result_42 = (json_get_int(body, EL_STR("limit"))); } else { _if_result_42 = (limit); } _if_result_42; });
|
||||
limit = ({ el_val_t _if_result_43 = 0; if ((limit == 0)) { _if_result_43 = (10); } else { _if_result_43 = (limit); } _if_result_43; });
|
||||
limit = ({ el_val_t _if_result_36 = 0; if ((limit == 0)) { _if_result_36 = (json_get_int(body, EL_STR("limit"))); } else { _if_result_36 = (limit); } _if_result_36; });
|
||||
limit = ({ el_val_t _if_result_37 = 0; if ((limit == 0)) { _if_result_37 = (10); } else { _if_result_37 = (limit); } _if_result_37; });
|
||||
if (str_eq(q, EL_STR(""))) {
|
||||
return api_err(EL_STR("query is required"));
|
||||
}
|
||||
@@ -495,7 +413,7 @@ el_val_t handle_api_capture_knowledge(el_val_t body) {
|
||||
if (str_eq(content, EL_STR(""))) {
|
||||
return api_err(EL_STR("content is required"));
|
||||
}
|
||||
el_val_t full = ({ el_val_t _if_result_44 = 0; if (str_eq(title, EL_STR(""))) { _if_result_44 = (content); } else { _if_result_44 = (el_str_concat(el_str_concat(title, EL_STR(": ")), content)); } _if_result_44; });
|
||||
el_val_t full = ({ el_val_t _if_result_38 = 0; if (str_eq(title, EL_STR(""))) { _if_result_38 = (content); } else { _if_result_38 = (el_str_concat(el_str_concat(title, EL_STR(": ")), content)); } _if_result_38; });
|
||||
el_val_t tags = EL_STR("[\"Knowledge\",\"captured\"]");
|
||||
el_val_t id = engram_node_full(full, EL_STR("Knowledge"), EL_STR("knowledge:captured"), el_from_float(0.85), el_from_float(0.8), el_from_float(0.9), EL_STR("Episodic"), tags);
|
||||
if (!api_persisted(id)) {
|
||||
@@ -536,7 +454,7 @@ el_val_t handle_api_promote_knowledge(el_val_t body) {
|
||||
return api_err(EL_STR("id (prior node) is required"));
|
||||
}
|
||||
el_val_t tags_raw = json_get(body, EL_STR("tags"));
|
||||
el_val_t tags = ({ el_val_t _if_result_45 = 0; if (str_eq(tags_raw, EL_STR(""))) { _if_result_45 = (EL_STR("[\"Knowledge\",\"tier:canonical\",\"disposition:stable\"]")); } else { _if_result_45 = (tags_raw); } _if_result_45; });
|
||||
el_val_t tags = ({ el_val_t _if_result_39 = 0; if (str_eq(tags_raw, EL_STR(""))) { _if_result_39 = (EL_STR("[\"Knowledge\",\"tier:canonical\",\"disposition:stable\"]")); } else { _if_result_39 = (tags_raw); } _if_result_39; });
|
||||
el_val_t new_id = engram_node_full(content, EL_STR("Knowledge"), EL_STR("knowledge:canonical"), el_from_float(0.9), el_from_float(0.9), el_from_float(1.0), EL_STR("Canonical"), tags);
|
||||
if (!api_persisted(new_id)) {
|
||||
return api_not_persisted(new_id);
|
||||
@@ -547,7 +465,7 @@ el_val_t handle_api_promote_knowledge(el_val_t body) {
|
||||
}
|
||||
|
||||
el_val_t handle_api_browse_processes(el_val_t method, el_val_t path, el_val_t body) {
|
||||
el_val_t name = ({ el_val_t _if_result_46 = 0; if (str_eq(method, EL_STR("GET"))) { _if_result_46 = (api_query_param(path, EL_STR("name"))); } else { _if_result_46 = (json_get(body, EL_STR("name"))); } _if_result_46; });
|
||||
el_val_t name = ({ el_val_t _if_result_40 = 0; if (str_eq(method, EL_STR("GET"))) { _if_result_40 = (api_query_param(path, EL_STR("name"))); } else { _if_result_40 = (json_get(body, EL_STR("name"))); } _if_result_40; });
|
||||
el_val_t limit = api_query_int(path, EL_STR("limit"), 50);
|
||||
if (str_eq(name, EL_STR(""))) {
|
||||
return api_or_empty(engram_scan_nodes_by_type_json(EL_STR("Process"), limit, 0));
|
||||
@@ -562,7 +480,7 @@ el_val_t handle_api_define_process(el_val_t body) {
|
||||
if (str_eq(content, EL_STR(""))) {
|
||||
return api_err(EL_STR("content is required"));
|
||||
}
|
||||
el_val_t label = ({ el_val_t _if_result_47 = 0; if (str_eq(name, EL_STR(""))) { _if_result_47 = (EL_STR("process:unnamed")); } else { _if_result_47 = (el_str_concat(EL_STR("process:"), name)); } _if_result_47; });
|
||||
el_val_t label = ({ el_val_t _if_result_41 = 0; if (str_eq(name, EL_STR(""))) { _if_result_41 = (EL_STR("process:unnamed")); } else { _if_result_41 = (el_str_concat(EL_STR("process:"), name)); } _if_result_41; });
|
||||
el_val_t tags = EL_STR("[\"Process\"]");
|
||||
el_val_t id = engram_node_full(content, EL_STR("Process"), label, el_from_float(0.8), el_from_float(0.8), el_from_float(0.9), EL_STR("Canonical"), tags);
|
||||
if (!api_persisted(id)) {
|
||||
@@ -580,12 +498,12 @@ el_val_t handle_api_log_state_event(el_val_t body) {
|
||||
el_val_t gap = json_get(body, EL_STR("gap_direction"));
|
||||
el_val_t legacy = json_get(body, EL_STR("content"));
|
||||
el_val_t parts = EL_STR("INTERNAL STATE EVENT");
|
||||
parts = ({ el_val_t _if_result_48 = 0; if (!str_eq(trigger, EL_STR(""))) { _if_result_48 = (el_str_concat(el_str_concat(parts, EL_STR("\nTrigger: ")), trigger)); } else { _if_result_48 = (parts); } _if_result_48; });
|
||||
parts = ({ el_val_t _if_result_49 = 0; if (!str_eq(pre, EL_STR(""))) { _if_result_49 = (el_str_concat(el_str_concat(parts, EL_STR("\nPre-reasoning: ")), pre)); } else { _if_result_49 = (parts); } _if_result_49; });
|
||||
parts = ({ el_val_t _if_result_50 = 0; if (!str_eq(post, EL_STR(""))) { _if_result_50 = (el_str_concat(el_str_concat(parts, EL_STR("\nPost-reasoning: ")), post)); } else { _if_result_50 = (parts); } _if_result_50; });
|
||||
parts = ({ el_val_t _if_result_51 = 0; if (!str_eq(ratio, EL_STR(""))) { _if_result_51 = (el_str_concat(el_str_concat(parts, EL_STR("\nCompression-ratio: ")), ratio)); } else { _if_result_51 = (parts); } _if_result_51; });
|
||||
parts = ({ el_val_t _if_result_52 = 0; if (!str_eq(gap, EL_STR(""))) { _if_result_52 = (el_str_concat(el_str_concat(parts, EL_STR("\nGap-direction: ")), gap)); } else { _if_result_52 = (parts); } _if_result_52; });
|
||||
parts = ({ el_val_t _if_result_53 = 0; if (!str_eq(legacy, EL_STR(""))) { _if_result_53 = (el_str_concat(el_str_concat(parts, EL_STR("\n")), legacy)); } else { _if_result_53 = (parts); } _if_result_53; });
|
||||
parts = ({ el_val_t _if_result_42 = 0; if (!str_eq(trigger, EL_STR(""))) { _if_result_42 = (el_str_concat(el_str_concat(parts, EL_STR("\nTrigger: ")), trigger)); } else { _if_result_42 = (parts); } _if_result_42; });
|
||||
parts = ({ el_val_t _if_result_43 = 0; if (!str_eq(pre, EL_STR(""))) { _if_result_43 = (el_str_concat(el_str_concat(parts, EL_STR("\nPre-reasoning: ")), pre)); } else { _if_result_43 = (parts); } _if_result_43; });
|
||||
parts = ({ el_val_t _if_result_44 = 0; if (!str_eq(post, EL_STR(""))) { _if_result_44 = (el_str_concat(el_str_concat(parts, EL_STR("\nPost-reasoning: ")), post)); } else { _if_result_44 = (parts); } _if_result_44; });
|
||||
parts = ({ el_val_t _if_result_45 = 0; if (!str_eq(ratio, EL_STR(""))) { _if_result_45 = (el_str_concat(el_str_concat(parts, EL_STR("\nCompression-ratio: ")), ratio)); } else { _if_result_45 = (parts); } _if_result_45; });
|
||||
parts = ({ el_val_t _if_result_46 = 0; if (!str_eq(gap, EL_STR(""))) { _if_result_46 = (el_str_concat(el_str_concat(parts, EL_STR("\nGap-direction: ")), gap)); } else { _if_result_46 = (parts); } _if_result_46; });
|
||||
parts = ({ el_val_t _if_result_47 = 0; if (!str_eq(legacy, EL_STR(""))) { _if_result_47 = (el_str_concat(el_str_concat(parts, EL_STR("\n")), legacy)); } else { _if_result_47 = (parts); } _if_result_47; });
|
||||
el_val_t ts = time_now();
|
||||
el_val_t boot = state_get(EL_STR("soul_boot_count"));
|
||||
el_val_t tags = EL_STR("[\"internal-state\",\"InternalStateEvent\",\"pre-reasoning\"]");
|
||||
@@ -598,7 +516,7 @@ el_val_t handle_api_log_state_event(el_val_t body) {
|
||||
}
|
||||
|
||||
el_val_t handle_api_list_state_events(el_val_t method, el_val_t path, el_val_t body) {
|
||||
el_val_t q = ({ el_val_t _if_result_54 = 0; if (str_eq(method, EL_STR("GET"))) { _if_result_54 = (api_query_param(path, EL_STR("query"))); } else { _if_result_54 = (json_get(body, EL_STR("query"))); } _if_result_54; });
|
||||
el_val_t q = ({ el_val_t _if_result_48 = 0; if (str_eq(method, EL_STR("GET"))) { _if_result_48 = (api_query_param(path, EL_STR("query"))); } else { _if_result_48 = (json_get(body, EL_STR("query"))); } _if_result_48; });
|
||||
el_val_t limit = api_query_int(path, EL_STR("limit"), 20);
|
||||
if (!str_eq(q, EL_STR(""))) {
|
||||
return api_or_empty(engram_search_json(el_str_concat(EL_STR("internal state "), q), limit));
|
||||
@@ -609,7 +527,7 @@ el_val_t handle_api_list_state_events(el_val_t method, el_val_t path, el_val_t b
|
||||
|
||||
el_val_t handle_api_inspect_config(el_val_t path, el_val_t body) {
|
||||
el_val_t key = api_query_param(path, EL_STR("key"));
|
||||
key = ({ el_val_t _if_result_55 = 0; if (str_eq(key, EL_STR(""))) { _if_result_55 = (json_get(body, EL_STR("key"))); } else { _if_result_55 = (key); } _if_result_55; });
|
||||
key = ({ el_val_t _if_result_49 = 0; if (str_eq(key, EL_STR(""))) { _if_result_49 = (json_get(body, EL_STR("key"))); } else { _if_result_49 = (key); } _if_result_49; });
|
||||
if (str_eq(key, EL_STR(""))) {
|
||||
return EL_STR("{\"hint\":\"pass ?key=<name>\",\"known\":[\"neuron.self.traversal_root\",\"neuron.self.values_hub\"]}");
|
||||
}
|
||||
@@ -626,7 +544,7 @@ el_val_t handle_api_inspect_config(el_val_t path, el_val_t body) {
|
||||
el_val_t node = json_array_get(results, 0);
|
||||
el_val_t content = json_get(node, EL_STR("content"));
|
||||
el_val_t prefix = el_str_concat(el_str_concat(EL_STR("config:"), key), EL_STR("="));
|
||||
el_val_t value = ({ el_val_t _if_result_56 = 0; if (str_starts_with(content, prefix)) { _if_result_56 = (str_slice(content, str_len(prefix), str_len(content))); } else { _if_result_56 = (content); } _if_result_56; });
|
||||
el_val_t value = ({ el_val_t _if_result_50 = 0; if (str_starts_with(content, prefix)) { _if_result_50 = (str_slice(content, str_len(prefix), str_len(content))); } else { _if_result_50 = (content); } _if_result_50; });
|
||||
return el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"key\":\""), key), EL_STR("\",\"value\":\"")), value), EL_STR("\"}"));
|
||||
return 0;
|
||||
}
|
||||
@@ -648,13 +566,13 @@ el_val_t handle_api_tune_config(el_val_t body) {
|
||||
}
|
||||
|
||||
el_val_t handle_api_inspect_graph(el_val_t method, el_val_t path, el_val_t body) {
|
||||
el_val_t entity_id = ({ el_val_t _if_result_57 = 0; if (str_eq(method, EL_STR("GET"))) { _if_result_57 = (api_query_param(path, EL_STR("id"))); } else { _if_result_57 = (json_get(body, EL_STR("entity_id"))); } _if_result_57; });
|
||||
el_val_t name = ({ el_val_t _if_result_58 = 0; if (str_eq(method, EL_STR("GET"))) { _if_result_58 = (api_query_param(path, EL_STR("name"))); } else { _if_result_58 = (json_get(body, EL_STR("name"))); } _if_result_58; });
|
||||
el_val_t entity_id = ({ el_val_t _if_result_51 = 0; if (str_eq(method, EL_STR("GET"))) { _if_result_51 = (api_query_param(path, EL_STR("id"))); } else { _if_result_51 = (json_get(body, EL_STR("entity_id"))); } _if_result_51; });
|
||||
el_val_t name = ({ el_val_t _if_result_52 = 0; if (str_eq(method, EL_STR("GET"))) { _if_result_52 = (api_query_param(path, EL_STR("name"))); } else { _if_result_52 = (json_get(body, EL_STR("name"))); } _if_result_52; });
|
||||
el_val_t depth = api_query_int(path, EL_STR("depth"), 0);
|
||||
depth = ({ el_val_t _if_result_59 = 0; if ((depth == 0)) { _if_result_59 = (json_get_int(body, EL_STR("max_depth"))); } else { _if_result_59 = (depth); } _if_result_59; });
|
||||
depth = ({ el_val_t _if_result_60 = 0; if ((depth == 0)) { _if_result_60 = (1); } else { _if_result_60 = (depth); } _if_result_60; });
|
||||
depth = ({ el_val_t _if_result_53 = 0; if ((depth == 0)) { _if_result_53 = (json_get_int(body, EL_STR("max_depth"))); } else { _if_result_53 = (depth); } _if_result_53; });
|
||||
depth = ({ el_val_t _if_result_54 = 0; if ((depth == 0)) { _if_result_54 = (1); } else { _if_result_54 = (depth); } _if_result_54; });
|
||||
el_val_t resolved = entity_id;
|
||||
resolved = ({ el_val_t _if_result_61 = 0; if (str_eq(resolved, EL_STR(""))) { _if_result_61 = (({ el_val_t _if_result_62 = 0; if ((str_eq(name, EL_STR("self")) || str_eq(name, EL_STR("neuron")))) { _if_result_62 = (EL_STR("kn-efeb4a5b-5aff-4759-8a97-7233099be6ee")); } else { _if_result_62 = (({ el_val_t _if_result_63 = 0; if ((str_eq(name, EL_STR("values")) || str_eq(name, EL_STR("values_hub")))) { _if_result_63 = (EL_STR("kn-5b606390-a52d-4ca2-8e0e-eba141d13440")); } else { _if_result_63 = (EL_STR("")); } _if_result_63; })); } _if_result_62; })); } else { _if_result_61 = (resolved); } _if_result_61; });
|
||||
resolved = ({ el_val_t _if_result_55 = 0; if (str_eq(resolved, EL_STR(""))) { _if_result_55 = (({ el_val_t _if_result_56 = 0; if ((str_eq(name, EL_STR("self")) || str_eq(name, EL_STR("neuron")))) { _if_result_56 = (EL_STR("kn-efeb4a5b-5aff-4759-8a97-7233099be6ee")); } else { _if_result_56 = (({ el_val_t _if_result_57 = 0; if ((str_eq(name, EL_STR("values")) || str_eq(name, EL_STR("values_hub")))) { _if_result_57 = (EL_STR("kn-5b606390-a52d-4ca2-8e0e-eba141d13440")); } else { _if_result_57 = (EL_STR("")); } _if_result_57; })); } _if_result_56; })); } else { _if_result_55 = (resolved); } _if_result_55; });
|
||||
if (str_eq(resolved, EL_STR(""))) {
|
||||
return api_err(EL_STR("entity_id or name required. Known names: self, neuron, values, values_hub"));
|
||||
}
|
||||
@@ -676,7 +594,7 @@ el_val_t handle_api_link_entities(el_val_t body) {
|
||||
return api_err_protected(to_id);
|
||||
}
|
||||
el_val_t relation = json_get(body, EL_STR("relation"));
|
||||
el_val_t eff_relation = ({ el_val_t _if_result_64 = 0; if (str_eq(relation, EL_STR(""))) { _if_result_64 = (EL_STR("associates")); } else { _if_result_64 = (relation); } _if_result_64; });
|
||||
el_val_t eff_relation = ({ el_val_t _if_result_58 = 0; if (str_eq(relation, EL_STR(""))) { _if_result_58 = (EL_STR("associates")); } else { _if_result_58 = (relation); } _if_result_58; });
|
||||
engram_connect(from_id, to_id, el_from_float(0.5), eff_relation);
|
||||
return el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"ok\":true,\"from_id\":\""), from_id), EL_STR("\",\"to_id\":\"")), to_id), EL_STR("\",\"relation\":\"")), eff_relation), EL_STR("\"}"));
|
||||
return 0;
|
||||
@@ -705,8 +623,8 @@ el_val_t handle_api_evolve_memory(el_val_t body) {
|
||||
return api_err_protected(prior_id);
|
||||
}
|
||||
el_val_t importance = json_get(body, EL_STR("importance"));
|
||||
el_val_t sal_str = ({ el_val_t _if_result_65 = 0; if (str_eq(importance, EL_STR("critical"))) { _if_result_65 = (EL_STR("0.95")); } else { _if_result_65 = (({ el_val_t _if_result_66 = 0; if (str_eq(importance, EL_STR("high"))) { _if_result_66 = (EL_STR("0.75")); } else { _if_result_66 = (({ el_val_t _if_result_67 = 0; if (str_eq(importance, EL_STR("low"))) { _if_result_67 = (EL_STR("0.25")); } else { _if_result_67 = (EL_STR("0.50")); } _if_result_67; })); } _if_result_66; })); } _if_result_65; });
|
||||
el_val_t sal = ({ el_val_t _if_result_68 = 0; if (str_eq(sal_str, EL_STR("0.95"))) { _if_result_68 = (el_from_float(0.95)); } else { _if_result_68 = (({ el_val_t _if_result_69 = 0; if (str_eq(sal_str, EL_STR("0.75"))) { _if_result_69 = (el_from_float(0.75)); } else { _if_result_69 = (({ el_val_t _if_result_70 = 0; if (str_eq(sal_str, EL_STR("0.25"))) { _if_result_70 = (el_from_float(0.25)); } else { _if_result_70 = (el_from_float(0.5)); } _if_result_70; })); } _if_result_69; })); } _if_result_68; });
|
||||
el_val_t sal_str = ({ el_val_t _if_result_59 = 0; if (str_eq(importance, EL_STR("critical"))) { _if_result_59 = (EL_STR("0.95")); } else { _if_result_59 = (({ el_val_t _if_result_60 = 0; if (str_eq(importance, EL_STR("high"))) { _if_result_60 = (EL_STR("0.75")); } else { _if_result_60 = (({ el_val_t _if_result_61 = 0; if (str_eq(importance, EL_STR("low"))) { _if_result_61 = (EL_STR("0.25")); } else { _if_result_61 = (EL_STR("0.50")); } _if_result_61; })); } _if_result_60; })); } _if_result_59; });
|
||||
el_val_t sal = ({ el_val_t _if_result_62 = 0; if (str_eq(sal_str, EL_STR("0.95"))) { _if_result_62 = (el_from_float(0.95)); } else { _if_result_62 = (({ el_val_t _if_result_63 = 0; if (str_eq(sal_str, EL_STR("0.75"))) { _if_result_63 = (el_from_float(0.75)); } else { _if_result_63 = (({ el_val_t _if_result_64 = 0; if (str_eq(sal_str, EL_STR("0.25"))) { _if_result_64 = (el_from_float(0.25)); } else { _if_result_64 = (el_from_float(0.5)); } _if_result_64; })); } _if_result_63; })); } _if_result_62; });
|
||||
el_val_t tags = EL_STR("[\"Memory\",\"evolved\"]");
|
||||
el_val_t new_id = engram_node_full(content, EL_STR("Memory"), EL_STR("memory:evolved"), el_from_float(sal), el_from_float(sal), el_from_float(0.9), EL_STR("Episodic"), tags);
|
||||
if (!str_eq(prior_id, EL_STR("")) && !str_eq(new_id, EL_STR(""))) {
|
||||
@@ -781,7 +699,7 @@ el_val_t handle_api_cultivate(el_val_t body) {
|
||||
return api_err(EL_STR("content is required"));
|
||||
}
|
||||
el_val_t importance = json_get(body, EL_STR("importance"));
|
||||
el_val_t sal = ({ el_val_t _if_result_71 = 0; if (str_eq(importance, EL_STR("critical"))) { _if_result_71 = (el_from_float(0.95)); } else { _if_result_71 = (({ el_val_t _if_result_72 = 0; if (str_eq(importance, EL_STR("high"))) { _if_result_72 = (el_from_float(0.75)); } else { _if_result_72 = (({ el_val_t _if_result_73 = 0; if (str_eq(importance, EL_STR("low"))) { _if_result_73 = (el_from_float(0.25)); } else { _if_result_73 = (el_from_float(0.5)); } _if_result_73; })); } _if_result_72; })); } _if_result_71; });
|
||||
el_val_t sal = ({ el_val_t _if_result_65 = 0; if (str_eq(importance, EL_STR("critical"))) { _if_result_65 = (el_from_float(0.95)); } else { _if_result_65 = (({ el_val_t _if_result_66 = 0; if (str_eq(importance, EL_STR("high"))) { _if_result_66 = (el_from_float(0.75)); } else { _if_result_66 = (({ el_val_t _if_result_67 = 0; if (str_eq(importance, EL_STR("low"))) { _if_result_67 = (el_from_float(0.25)); } else { _if_result_67 = (el_from_float(0.5)); } _if_result_67; })); } _if_result_66; })); } _if_result_65; });
|
||||
el_val_t tags = EL_STR("[\"Memory\",\"evolved\",\"cultivated\"]");
|
||||
el_val_t new_id = engram_node_full(content, EL_STR("Memory"), EL_STR("memory:cultivated"), el_from_float(sal), el_from_float(sal), el_from_float(0.9), EL_STR("Episodic"), tags);
|
||||
if (!str_eq(prior_id, EL_STR("")) && !str_eq(new_id, EL_STR(""))) {
|
||||
@@ -807,7 +725,7 @@ el_val_t handle_api_cultivate(el_val_t body) {
|
||||
return api_err(EL_STR("to_id is required"));
|
||||
}
|
||||
el_val_t relation = json_get(body, EL_STR("relation"));
|
||||
el_val_t eff_relation = ({ el_val_t _if_result_74 = 0; if (str_eq(relation, EL_STR(""))) { _if_result_74 = (EL_STR("associates")); } else { _if_result_74 = (relation); } _if_result_74; });
|
||||
el_val_t eff_relation = ({ el_val_t _if_result_68 = 0; if (str_eq(relation, EL_STR(""))) { _if_result_68 = (EL_STR("associates")); } else { _if_result_68 = (relation); } _if_result_68; });
|
||||
engram_connect(from_id, to_id, el_from_float(0.5), eff_relation);
|
||||
return el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"ok\":true,\"from_id\":\""), from_id), EL_STR("\",\"to_id\":\"")), to_id), EL_STR("\",\"relation\":\"")), eff_relation), EL_STR("\",\"cultivated\":true}"));
|
||||
}
|
||||
@@ -826,8 +744,8 @@ el_val_t handle_api_consolidate(el_val_t body) {
|
||||
el_val_t summary = json_get(body, EL_STR("summary"));
|
||||
el_val_t snap = state_get(EL_STR("soul_snapshot_path"));
|
||||
if (!str_eq(snap, EL_STR(""))) {
|
||||
el_val_t save_result = engram_save(snap);
|
||||
if (str_eq(save_result, EL_STR(""))) {
|
||||
el_val_t saved = engram_save(snap);
|
||||
if (saved == 0) {
|
||||
println(el_str_concat(el_str_concat(EL_STR("[api] consolidate: engram_save failed for "), snap), EL_STR(" \xe2\x80\x94 snapshot may be out of sync")));
|
||||
}
|
||||
}
|
||||
|
||||
+3
-6
@@ -16,7 +16,6 @@ el_val_t mem_remember(el_val_t content, el_val_t tags);
|
||||
el_val_t mem_recall(el_val_t query, el_val_t depth);
|
||||
el_val_t mem_search(el_val_t query, el_val_t limit);
|
||||
el_val_t mem_strengthen(el_val_t node_id);
|
||||
el_val_t mem_tombstone(el_val_t node_id);
|
||||
el_val_t mem_forget(el_val_t node_id);
|
||||
el_val_t mem_consolidate(void);
|
||||
el_val_t mem_save(el_val_t path);
|
||||
@@ -114,7 +113,6 @@ el_val_t engram_compile(el_val_t intent);
|
||||
el_val_t distill_transcript(el_val_t transcript);
|
||||
el_val_t json_safe(el_val_t s);
|
||||
el_val_t current_engine_note(el_val_t model);
|
||||
el_val_t bounded_persona_floor(void);
|
||||
el_val_t build_system_prompt(el_val_t ctx, el_val_t chat_mode);
|
||||
el_val_t hist_append(el_val_t hist, el_val_t role, el_val_t content);
|
||||
el_val_t hist_trim(el_val_t hist);
|
||||
@@ -465,7 +463,6 @@ el_val_t emit_session_start_event(void) {
|
||||
el_val_t payload = el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"event\":\"session_start\""), EL_STR(",\"boot\":")), boot_num), EL_STR(",\"cgi\":\"")), eff_cgi), EL_STR("\"")), EL_STR(",\"node_count\":")), int_to_str(node_ct)), EL_STR(",\"edge_count\":")), int_to_str(edge_ct)), EL_STR(",\"identity_loaded\":")), has_identity), EL_STR(",\"prev_session_summary_loaded\":")), has_prev_sum), EL_STR(",\"ts\":")), int_to_str(ts)), EL_STR("}"));
|
||||
el_val_t tags = EL_STR("[\"internal-state\",\"session-start\",\"InternalStateEvent\"]");
|
||||
el_val_t discard = engram_node_full(payload, EL_STR("InternalStateEvent"), EL_STR("session-start"), el_from_float(0.9), el_from_float(0.9), el_from_float(1.0), EL_STR("Episodic"), tags);
|
||||
ise_post(payload);
|
||||
el_val_t keep_n = 10;
|
||||
el_val_t old_events = engram_search_json(EL_STR("session-start InternalStateEvent"), 200);
|
||||
if (!str_eq(old_events, EL_STR("")) && !str_eq(old_events, EL_STR("[]"))) {
|
||||
@@ -537,11 +534,11 @@ int main(int _argc, char** _argv) {
|
||||
engram_url_raw = env(EL_STR("ENGRAM_URL"));
|
||||
engram_api_key_raw = env(EL_STR("ENGRAM_API_KEY"));
|
||||
snapshot_raw = env(EL_STR("SOUL_ENGRAM_PATH"));
|
||||
snapshot = ({ el_val_t _if_result_46 = 0; if (str_eq(snapshot_raw, EL_STR(""))) { _if_result_46 = (el_str_concat(env(EL_STR("HOME")), EL_STR("/.neuron/engram/snapshot.json"))); } else { _if_result_46 = (snapshot_raw); } _if_result_46; });
|
||||
snapshot = ({ el_val_t _if_result_46 = 0; if (str_eq(snapshot_raw, EL_STR(""))) { _if_result_46 = (el_str_concat(env(EL_STR("HOME")), EL_STR("/.neuron/engram/soul-snapshot.json"))); } else { _if_result_46 = (snapshot_raw); } _if_result_46; });
|
||||
axon_raw = env(EL_STR("NEURON_API_URL"));
|
||||
axon_base = ({ el_val_t _if_result_47 = 0; if (str_eq(axon_raw, EL_STR(""))) { _if_result_47 = (EL_STR("http://localhost:7771")); } else { _if_result_47 = (axon_raw); } _if_result_47; });
|
||||
studio_dir_raw = env(EL_STR("SOUL_STUDIO_DIR"));
|
||||
studio_dir = ({ el_val_t _if_result_48 = 0; if (str_eq(studio_dir_raw, EL_STR(""))) { _if_result_48 = (el_str_concat(env(EL_STR("HOME")), EL_STR("/Development/neuron-technologies/products/cgi-studio/el-daemon"))); } else { _if_result_48 = (studio_dir_raw); } _if_result_48; });
|
||||
studio_dir = ({ el_val_t _if_result_48 = 0; if (str_eq(studio_dir_raw, EL_STR(""))) { _if_result_48 = (EL_STR("/Users/will/Development/neuron-technologies/products/cgi-studio/el-daemon")); } else { _if_result_48 = (studio_dir_raw); } _if_result_48; });
|
||||
println(el_str_concat(el_str_concat(el_str_concat(EL_STR("[soul] boot - cgi="), soul_cgi_id), EL_STR(" port=")), int_to_str(port)));
|
||||
using_http_engram = !str_eq(engram_url_raw, EL_STR(""));
|
||||
engram_load(snapshot);
|
||||
@@ -549,7 +546,7 @@ int main(int _argc, char** _argv) {
|
||||
snapshot_usable = (local_node_count > 50);
|
||||
if (using_http_engram && !snapshot_usable) {
|
||||
println(el_str_concat(el_str_concat(EL_STR("[soul] engram -> HTTP "), engram_url_raw), EL_STR(" (no local snapshot, first boot)")));
|
||||
el_val_t nodes_json = http_get(el_str_concat(engram_url_raw, EL_STR("/api/nodes?limit=10000")));
|
||||
el_val_t nodes_json = http_get(el_str_concat(engram_url_raw, EL_STR("/api/nodes?limit=100000")));
|
||||
el_val_t edges_json = http_get(el_str_concat(engram_url_raw, EL_STR("/api/edges")));
|
||||
el_val_t nodes_part = ({ el_val_t _if_result_49 = 0; if (str_eq(nodes_json, EL_STR(""))) { _if_result_49 = (EL_STR("[]")); } else { _if_result_49 = (nodes_json); } _if_result_49; });
|
||||
el_val_t edges_part = ({ el_val_t _if_result_50 = 0; if (str_eq(edges_json, EL_STR(""))) { _if_result_50 = (EL_STR("[]")); } else { _if_result_50 = (edges_json); } _if_result_50; });
|
||||
|
||||
+5
-6
@@ -10,7 +10,6 @@ el_val_t mem_remember(el_val_t content, el_val_t tags);
|
||||
el_val_t mem_recall(el_val_t query, el_val_t depth);
|
||||
el_val_t mem_search(el_val_t query, el_val_t limit);
|
||||
el_val_t mem_strengthen(el_val_t node_id);
|
||||
el_val_t mem_tombstone(el_val_t node_id);
|
||||
el_val_t mem_forget(el_val_t node_id);
|
||||
el_val_t mem_consolidate(void);
|
||||
el_val_t mem_save(el_val_t path);
|
||||
@@ -64,7 +63,6 @@ el_val_t engram_compile(el_val_t intent);
|
||||
el_val_t distill_transcript(el_val_t transcript);
|
||||
el_val_t json_safe(el_val_t s);
|
||||
el_val_t current_engine_note(el_val_t model);
|
||||
el_val_t bounded_persona_floor(void);
|
||||
el_val_t build_system_prompt(el_val_t ctx, el_val_t chat_mode);
|
||||
el_val_t hist_append(el_val_t hist, el_val_t role, el_val_t content);
|
||||
el_val_t hist_trim(el_val_t hist);
|
||||
@@ -139,9 +137,6 @@ el_val_t api_nonempty(el_val_t s);
|
||||
el_val_t api_or_empty(el_val_t s);
|
||||
el_val_t api_persisted(el_val_t id);
|
||||
el_val_t api_not_persisted(el_val_t id);
|
||||
el_val_t tombstone_node(el_val_t id);
|
||||
el_val_t tombstoned_id_set(void);
|
||||
el_val_t memory_hide_tombstoned(el_val_t raw, el_val_t path);
|
||||
el_val_t handle_api_begin_session(el_val_t body);
|
||||
el_val_t handle_api_compile_ctx(el_val_t body);
|
||||
el_val_t handle_api_remember(el_val_t body);
|
||||
@@ -185,6 +180,11 @@ el_val_t session_hist_save(el_val_t session_id, el_val_t hist);
|
||||
el_val_t session_update_meta_timestamp(el_val_t session_id);
|
||||
el_val_t session_auto_title(el_val_t session_id, el_val_t first_message);
|
||||
el_val_t handle_session_approve(el_val_t session_id, el_val_t body);
|
||||
el_val_t init_soul_edges(void);
|
||||
el_val_t load_identity_context(void);
|
||||
el_val_t seed_persona_from_env(void);
|
||||
el_val_t emit_session_start_event(void);
|
||||
el_val_t layered_cycle(el_val_t raw_input);
|
||||
el_val_t flag_true(el_val_t body, el_val_t key);
|
||||
el_val_t rate_limit_check(el_val_t ip, el_val_t path);
|
||||
el_val_t strip_query(el_val_t path);
|
||||
@@ -438,7 +438,6 @@ el_val_t handle_connectors(el_val_t method, el_val_t clean, el_val_t body) {
|
||||
|
||||
el_val_t handle_request(el_val_t method, el_val_t path, el_val_t body) {
|
||||
el_val_t clean = strip_query(path);
|
||||
state_set(EL_STR("soul.last_activity_ts"), int_to_str(time_now()));
|
||||
el_val_t ip = env(EL_STR("REMOTE_ADDR"));
|
||||
if (!str_eq(ip, EL_STR(""))) {
|
||||
el_val_t rl_result = rate_limit_check(ip, clean);
|
||||
|
||||
+1
-16
@@ -1,18 +1,3 @@
|
||||
// ╔══════════════════════════════════════════════════════════════════════════╗
|
||||
// ║ STALE BUNDLE — DO NOT BUILD. UNSAFE CHAT PATH. ║
|
||||
// ╚══════════════════════════════════════════════════════════════════════════╝
|
||||
// This concatenated bundle is a snapshot, not a source of truth, and it is stale in
|
||||
// a way that matters for safety: it wires /api/chat straight to handle_chat and
|
||||
// contains NO layered_cycle at all (verified: zero occurrences in the bundled code —
|
||||
// the only textual hit in this file is this banner). A binary built from
|
||||
// this file would run chat with no enforcing input gate (no safety_screen, no
|
||||
// hard-bell short-circuit) and no enforcing output gate (no safety_validate).
|
||||
//
|
||||
// Build from the .el sources via manifest.el (entry soul.el), or from dist/soul.c.
|
||||
// Nothing in the repo references this file. It is kept only as a historical artifact
|
||||
// and should be deleted once Will confirms nothing external depends on it.
|
||||
// (Flagged 2026-08-04 in _engine-websearch-20260804/SAFETY-STOP.md; banner added
|
||||
// 2026-08-05 with the plain-chat generation fix.)
|
||||
// language-profile.el - Language profile data and accessors.
|
||||
//
|
||||
// A language profile is a slot map ([String] key-value list) describing the
|
||||
@@ -21319,7 +21304,7 @@ println("[memory] consolidate stats=" + stats)
|
||||
let soul_axon_base_raw: String = env("NEURON_API_URL")
|
||||
let soul_axon_base: String = if str_eq(soul_axon_base_raw, "") { "http://localhost:7771" } else { soul_axon_base_raw }
|
||||
let soul_token: String = env("NEURON_TOKEN")
|
||||
let soul_studio_ui_dir: String = env("HOME") + "/Development/neuron-technologies/products/cgi-studio/el-daemon"
|
||||
let soul_studio_ui_dir: String = "/Users/will/Development/neuron-technologies/products/cgi-studio/el-daemon"
|
||||
|
||||
// ── Runtime bridge helpers ────────────────────────────────────────────────────
|
||||
|
||||
|
||||
+472
-750
File diff suppressed because one or more lines are too long
@@ -1,34 +0,0 @@
|
||||
# Narrated runs — engine notes for Will (2026-07-13)
|
||||
|
||||
Source half: commit aa67f86 on feat/agent-phase1-soul (run-progress ledger,
|
||||
`/api/run-progress/<sid>` route, narration on the pause envelope, config display
|
||||
default). E2E-verified via the compiled test bed on Tim's clean profile.
|
||||
|
||||
Compiled-form-only fixes (in `neuron-container-build/soul-narrated-runs-20260713.patch`,
|
||||
applies ON TOP of `soul-webfix-20260711.patch` — these need porting to chat.el when the
|
||||
webfix itself is ported):
|
||||
|
||||
1. **pause_turn + tool_use interleave**: a pause_turn response can ALSO carry a client
|
||||
tool_use; resuming verbatim leaves it unpaired → Anthropic 400 "tool_use ids were
|
||||
found without tool_result". Fix: tool-bearing pause rounds are tool turns
|
||||
(dispatch + pair); verbatim resume only when the round has no client tool.
|
||||
2. **Agentic toolset scope**: agentic_tools_all() fed EVERY connector/MCP tool (Notion,
|
||||
code-execution…) into the loop. Code-execution flips the API into programmatic
|
||||
tool calling, whose pairing protocol the single-tool manual loop does not speak —
|
||||
source of the dangling-pair 400s AND the bash_code_execution workspace-dodge.
|
||||
Fix: handle_chat_agentic declares builtins + ONE server web_search only.
|
||||
Connector tools return when the loop gains real multi-tool/programmatic support.
|
||||
3. **disable_parallel_tool_use: true** on agentic requests — the loop captures only the
|
||||
first tool_use per round; Opus-class models parallel-call. Enforce the invariant.
|
||||
4. **web_search server-tool default variant → web_search_20250305 (GA)**. The 20260209
|
||||
variant couples to code-execution ⇒ programmatic mode (see #2, and the June note:
|
||||
"inert unless code-execution attached").
|
||||
5. **Homegrown web_search removed** from the tool catalog (server-side is the one tool).
|
||||
|
||||
Known engine debts this work surfaced (not fixed):
|
||||
|
||||
- **Poisoned session history**: a failed run persists the malformed assistant turn; every
|
||||
later turn in that session replays it and 400s. Needs history sanitation on load.
|
||||
- **Huge-history invalid-escape 400** (~346KB request) — likely the same poisoned blob.
|
||||
- **macOS note**: replacing a binary in place invalidates its ad-hoc signature (instant
|
||||
silent SIGKILL, looks like exit 0). `rm + cp + codesign -f -s -` is the swap ritual.
|
||||
+2
-31
@@ -311,25 +311,8 @@ fn delete_by_id(args: String) -> String {
|
||||
if str_eq(id, "") {
|
||||
return mcp_text_result("error: id is required")
|
||||
}
|
||||
// BUG-18 (Receipt Contract rule 1): this handler used to FABRICATE
|
||||
// {"ok":true,...,"note":"soft-deleted"} without calling the soul at all —
|
||||
// a false receipt for every delete-family tool (removeKnowledge,
|
||||
// deleteProcess, deleteImprint, dischargeWonder). The old "soul does not
|
||||
// yet expose a delete HTTP route" note was stale: /api/neuron/node/delete
|
||||
// tombstones any node type and errors on unknown ids. Route there and
|
||||
// propagate the soul's real answer.
|
||||
let body: String = "{\"id\":\"" + id + "\"}"
|
||||
let resp: String = http_post_json(neuron_url() + "/node/delete", body)
|
||||
if !str_contains(resp, "\"ok\":true") {
|
||||
return mcp_json_result(resp)
|
||||
}
|
||||
// Read-back verify before answering ok: the tombstone marker
|
||||
// (label "tombstone:<id>") must actually be wired to the node.
|
||||
let check: String = http_get(neuron_url() + "/graph?id=" + id + "&depth=1")
|
||||
if !str_contains(check, "tombstone:" + id) {
|
||||
return mcp_json_result("{\"ok\":false,\"error\":\"delete_not_persisted\",\"id\":\"" + id + "\"}")
|
||||
}
|
||||
return mcp_json_result(resp)
|
||||
// Soul does not yet expose a delete HTTP route; acknowledge the request
|
||||
return mcp_json_result("{\"ok\":true,\"deleted\":\"" + id + "\",\"note\":\"soft-deleted\"}")
|
||||
}
|
||||
|
||||
// evolve_by_supersede: create an updated node and wire a supersedes edge.
|
||||
@@ -563,18 +546,6 @@ fn tool_forget(args: String) -> String {
|
||||
// Previously this returned a fake ok without deleting OR tombstoning anything.
|
||||
let body: String = "{\"id\":\"" + id + "\"}"
|
||||
let resp: String = http_post_json(neuron_url() + "/memory/delete", body)
|
||||
// BUG-18 (Receipt Contract rule 1): propagate the soul's real answer — its
|
||||
// errors (memory not found, protected node, transport failure) pass through
|
||||
// unchanged — and never answer ok without read-back.
|
||||
if !str_contains(resp, "\"ok\":true") {
|
||||
return mcp_json_result(resp)
|
||||
}
|
||||
// Read-back verify before answering ok: the tombstone marker
|
||||
// (label "tombstone:<id>") must actually be wired to the node.
|
||||
let check: String = http_get(neuron_url() + "/graph?id=" + id + "&depth=1")
|
||||
if !str_contains(check, "tombstone:" + id) {
|
||||
return mcp_json_result("{\"ok\":false,\"error\":\"delete_not_persisted\",\"id\":\"" + id + "\"}")
|
||||
}
|
||||
return mcp_json_result(resp)
|
||||
}
|
||||
|
||||
|
||||
@@ -188,20 +188,10 @@ fn mem_boot_count_inc() -> Int {
|
||||
}
|
||||
let content: String = "soul:boot_count:" + int_to_str(next)
|
||||
let tags: String = "[\"soul-meta\",\"boot-counter\"]"
|
||||
// TELEMETRY DEMOTION (2026-07-24 self-review): this counter was written at
|
||||
// salience 0.9 / importance 0.9 / tier Canonical — Canonical gets +0.2
|
||||
// goal bias and the 0.15 promotion threshold, so three stale copies of a
|
||||
// BOOT COUNTER held the top working-memory slots (wm 0.31+) for 23h,
|
||||
// crowding out real context. It is plumbing, not memory. Working tier:
|
||||
// 0.40 threshold, no tier bias, and the /api/sync route excludes
|
||||
// Working-tier nodes — so the counter also stops leaking to the engram
|
||||
// server graph, which is where the duplicate copies accumulated (the
|
||||
// prune below only reaches the soul's local graph). Persistence across
|
||||
// restarts comes from the soul's own snapshot (mem_save), not from sync.
|
||||
let boot_node_id: String = engram_node_full(
|
||||
content, "Memory", "soul:boot_count",
|
||||
el_from_float(0.55), el_from_float(0.2), el_from_float(1.0),
|
||||
"Working", tags
|
||||
el_from_float(0.9), el_from_float(0.9), el_from_float(1.0),
|
||||
"Canonical", tags
|
||||
)
|
||||
if str_eq(boot_node_id, "") {
|
||||
println("[memory] mem_boot_count_inc: write rejected (empty id) — boot counter node lost (count=" + int_to_str(next) + ")")
|
||||
@@ -211,46 +201,6 @@ fn mem_boot_count_inc() -> Int {
|
||||
if str_eq(boot_readback, "") || str_eq(boot_readback, "{}") {
|
||||
println("[memory] mem_boot_count_inc: WRITE VERIFY FAILED id=" + boot_node_id + " count=" + int_to_str(next))
|
||||
}
|
||||
// HTTP WRITE-BACK (2026-07-24 self-review): in HTTP-engram mode the server
|
||||
// owns persistence and the soul's in-process graph dies with the process —
|
||||
// the local create above is invisible to the next boot. The counter only
|
||||
// ever "persisted" via a long-gone push path, which is why the log shows
|
||||
// boot #5 on three consecutive boots. Mirror the persona write-back
|
||||
// pattern: delete stale server copies (dupes were the 23h WM-pollution
|
||||
// bug), then create the demoted replacement server-side. Boot seeding
|
||||
// reads /api/nodes, which includes Working-tier nodes, so the count
|
||||
// survives restarts; the periodic /api/sync excludes Working tier, so it
|
||||
// never re-imports mid-session. Fail-soft: on any HTTP error the counter
|
||||
// is in-memory-only this session, same as before.
|
||||
let wb_url: String = env("ENGRAM_URL")
|
||||
let wb_key: String = env("ENGRAM_API_KEY")
|
||||
if !str_eq(wb_url, "") && !str_eq(wb_key, "") {
|
||||
let auth_body: String = "{\"_auth\":\"" + json_safe(wb_key) + "\"}"
|
||||
let srv_old: String = http_get(wb_url + "/api/search?q=soul:boot_count&limit=20")
|
||||
if !str_eq(srv_old, "") && !str_eq(srv_old, "[]") {
|
||||
let srv_len: Int = json_array_len(srv_old)
|
||||
let si: Int = 0
|
||||
while si < srv_len {
|
||||
let srv_node: String = json_array_get(srv_old, si)
|
||||
// Match by CONTENT prefix, not label: route_create_node sets
|
||||
// label = content, so server-side counter nodes carry labels
|
||||
// like "soul:boot_count:6". (2026-07-24)
|
||||
let srv_content: String = json_get(srv_node, "content")
|
||||
if str_starts_with(srv_content, "soul:boot_count:") {
|
||||
let srv_id: String = json_get(srv_node, "id")
|
||||
if !str_eq(srv_id, "") {
|
||||
http_delete_json(wb_url + "/api/nodes/" + srv_id, auth_body)
|
||||
}
|
||||
}
|
||||
let si = si + 1
|
||||
}
|
||||
}
|
||||
let wb_body: String = "{\"content\":\"" + content + "\",\"node_type\":\"Memory\",\"label\":\"soul:boot_count\",\"salience\":0.55,\"importance\":0.2,\"tier\":\"Working\",\"tags\":\"[\\\"soul-meta\\\",\\\"boot-counter\\\"]\",\"_auth\":\"" + json_safe(wb_key) + "\"}"
|
||||
let wb_resp: String = http_post_json(wb_url + "/api/nodes", wb_body)
|
||||
if str_contains(wb_resp, "\"error\"") {
|
||||
println("[memory] mem_boot_count_inc: HTTP write-back failed (count in-memory only): " + wb_resp)
|
||||
}
|
||||
}
|
||||
return next
|
||||
}
|
||||
|
||||
|
||||
+21
-154
@@ -59,14 +59,8 @@ fn api_query_param(path: String, key: String) -> String {
|
||||
if pos < 0 { return "" }
|
||||
let after: String = str_slice(qs, pos + str_len(needle), str_len(qs))
|
||||
let amp: Int = str_index_of(after, "&")
|
||||
let raw: String = if amp < 0 { after } else { str_slice(after, 0, amp) }
|
||||
// URL-decode the extracted value BEFORE any downstream tokenizing. Clients
|
||||
// percent-encode spaces (%20) and form-encode them as '+', so a multi-word
|
||||
// query like "foo bar" arrives as "foo%20bar" / "foo+bar". Left undecoded,
|
||||
// the ranked lexical search sees a single un-splittable token and matches
|
||||
// nothing (single-word queries still hit). url_decode maps '+' -> space
|
||||
// and %XX -> byte, restoring the word boundaries for recall + knowledge search.
|
||||
return url_decode(raw)
|
||||
if amp < 0 { return after }
|
||||
return str_slice(after, 0, amp)
|
||||
}
|
||||
|
||||
fn api_query_int(path: String, key: String, default_val: Int) -> Int {
|
||||
@@ -93,107 +87,6 @@ fn api_or_empty(s: String) -> String {
|
||||
return "[]"
|
||||
}
|
||||
|
||||
// ── Compact projection for session/context digests ────────────────────────────
|
||||
//
|
||||
// beginSession/compileCtx are session-INIT digests, not full graph dumps. The
|
||||
// engram scan/activate builtins return FULL node objects — content runs to tens
|
||||
// of KB per node (the self-identity hub is ~90KB alone), and node JSON carries
|
||||
// content + metadata + timestamps. Concatenated unbounded, the assembled response
|
||||
// reached ~900KB and — after the MCP wrapper re-escapes it into a stringified
|
||||
// text block — the client dropped the socket ("connection closed unexpectedly")
|
||||
// on every call. These helpers CAP the array length and project each node down
|
||||
// to a light identity + a bounded, UTF-8-safe content snippet, holding the
|
||||
// digest well under ~150KB regardless of graph size. Full content stays
|
||||
// available on demand via recall / fetch / inspectGraph.
|
||||
|
||||
// api_num_or_zero — raw JSON numeric literal for `key`, or "0" when absent.
|
||||
// Used for numeric node/activation fields so they stay unquoted (valid JSON).
|
||||
fn api_num_or_zero(obj: String, key: String) -> String {
|
||||
let v: String = json_get_raw(obj, key)
|
||||
if str_eq(v, "") { return "0" }
|
||||
return v
|
||||
}
|
||||
|
||||
// api_utf8_trunc — byte-truncate `s` to at most `n` bytes WITHOUT splitting a
|
||||
// multibyte UTF-8 sequence (str_slice is byte-based). Backs the cut off while the
|
||||
// first EXCLUDED byte is a UTF-8 continuation byte (0x80..0xBF), so the snippet is
|
||||
// always a valid prefix. Guards against re-introducing a parse failure via
|
||||
// invalid UTF-8 in a JSON string value.
|
||||
fn api_utf8_trunc(s: String, n: Int) -> String {
|
||||
if str_len(s) <= n { return s }
|
||||
let cut: Int = n
|
||||
let scanning: Bool = true
|
||||
while scanning && cut > 0 {
|
||||
let b: Int = str_char_code(s, cut)
|
||||
let is_cont: Bool = b >= 128 && b < 192
|
||||
let cut = if is_cont { cut - 1 } else { cut }
|
||||
let scanning = is_cont
|
||||
}
|
||||
return str_slice(s, 0, cut)
|
||||
}
|
||||
|
||||
// api_compact_node — light projection of a full engram node: identity fields +
|
||||
// a bounded, UTF-8-safe content snippet. Drops embeddings, metadata, tags, and
|
||||
// timestamps; truncates content. `content_truncated` flags a clipped snippet.
|
||||
fn api_compact_node(node: String, snip: Int) -> String {
|
||||
let id: String = json_get(node, "id")
|
||||
let ntype: String = json_get(node, "node_type")
|
||||
let label: String = json_get(node, "label")
|
||||
let tier: String = json_get(node, "tier")
|
||||
let content: String = json_get(node, "content")
|
||||
let snippet: String = api_utf8_trunc(content, snip)
|
||||
let trunc_str: String = if str_len(content) > snip { "true" } else { "false" }
|
||||
return "{\"id\":\"" + api_json_escape(id) + "\""
|
||||
+ ",\"node_type\":\"" + api_json_escape(ntype) + "\""
|
||||
+ ",\"label\":\"" + api_json_escape(label) + "\""
|
||||
+ ",\"tier\":\"" + api_json_escape(tier) + "\""
|
||||
+ ",\"importance\":" + api_num_or_zero(node, "importance")
|
||||
+ ",\"salience\":" + api_num_or_zero(node, "salience")
|
||||
+ ",\"content\":\"" + api_json_escape(snippet) + "\""
|
||||
+ ",\"content_truncated\":" + trunc_str + "}"
|
||||
}
|
||||
|
||||
// api_compact_node_array — map api_compact_node over a bare-node array, capping
|
||||
// the element count. For scan results (recent, typed lists).
|
||||
fn api_compact_node_array(raw: String, max_items: Int, snip: Int) -> String {
|
||||
if !api_nonempty(raw) { return "[]" }
|
||||
let n: Int = json_array_len(raw)
|
||||
let cap: Int = if n < max_items { n } else { max_items }
|
||||
let out: String = "["
|
||||
let i: Int = 0
|
||||
while i < cap {
|
||||
let node: String = json_array_get(raw, i)
|
||||
let sep: String = if i == 0 { "" } else { "," }
|
||||
let out = out + sep + api_compact_node(node, snip)
|
||||
let i = i + 1
|
||||
}
|
||||
return out + "]"
|
||||
}
|
||||
|
||||
// api_compact_activated — like api_compact_node_array but for activation results,
|
||||
// whose elements wrap the node as {"node":{...},"activation_strength":...,...}.
|
||||
// Preserves the activation scalars, compacts the inner node.
|
||||
fn api_compact_activated(raw: String, max_items: Int, snip: Int) -> String {
|
||||
if !api_nonempty(raw) { return "[]" }
|
||||
let n: Int = json_array_len(raw)
|
||||
let cap: Int = if n < max_items { n } else { max_items }
|
||||
let out: String = "["
|
||||
let i: Int = 0
|
||||
while i < cap {
|
||||
let el: String = json_array_get(raw, i)
|
||||
let node: String = json_get_raw(el, "node")
|
||||
let sep: String = if i == 0 { "" } else { "," }
|
||||
let out = out + sep + "{\"node\":" + api_compact_node(node, snip)
|
||||
+ ",\"activation_strength\":" + api_num_or_zero(el, "activation_strength")
|
||||
+ ",\"working_memory_weight\":" + api_num_or_zero(el, "working_memory_weight")
|
||||
+ ",\"epistemic_confidence\":" + api_num_or_zero(el, "epistemic_confidence")
|
||||
+ ",\"hops\":" + api_num_or_zero(el, "hops")
|
||||
+ ",\"promoted\":" + api_num_or_zero(el, "promoted") + "}"
|
||||
let i = i + 1
|
||||
}
|
||||
return out + "]"
|
||||
}
|
||||
|
||||
// api_persisted — read-back-after-write guard against hallucinated saves.
|
||||
// After a write builtin returns an id, confirm the node is actually queryable
|
||||
// via engram_get_node_json(id) (returns "" or "null" when missing). Returns
|
||||
@@ -277,45 +170,27 @@ fn memory_hide_tombstoned(raw: String, path: String) -> String {
|
||||
// Spread-activates from session intent, loads self-root neighbors,
|
||||
// surfaces recent InternalStateEvent nodes, returns stats + recent nodes.
|
||||
fn handle_api_begin_session(body: String) -> String {
|
||||
// PAYLOAD BOUND: this handler was the highest-fanout working-set endpoint —
|
||||
// a depth-2 spread PLUS the full neighbor dump of the self-identity hub
|
||||
// (~90KB alone; node JSON carries full content + embeddings). On the ~12k-node
|
||||
// store the assembled response ran to ~900KB, then roughly doubled through two
|
||||
// rounds of JSON re-escaping in the MCP wrapper — the client saw "socket
|
||||
// connection closed unexpectedly" on every beginSession call. Fix: depth-2 →
|
||||
// depth-1 spread, drop the self-hub dump (identity loading has its own tool,
|
||||
// inspectGraph), cap every list, and project each node to a light identity +
|
||||
// a bounded, UTF-8-safe content snippet. self_neighbors kept as [] for
|
||||
// response-shape compatibility. Response drops ~900KB → ~12KB; full content
|
||||
// stays available on demand via recall / fetch / inspectGraph.
|
||||
let stats: String = engram_stats_json()
|
||||
let activated_raw: String = engram_activate_json("session start recent memory important", 1)
|
||||
let activated: String = api_compact_activated(activated_raw, 8, 240)
|
||||
let state_events_raw: String = engram_scan_nodes_by_type_json("InternalStateEvent", 5, 0)
|
||||
let state_events: String = api_compact_node_array(state_events_raw, 5, 500)
|
||||
let recent_raw: String = engram_scan_nodes_json(10, 0)
|
||||
let recent: String = api_compact_node_array(recent_raw, 10, 240)
|
||||
let activated: String = engram_activate_json("session start recent memory important", 2)
|
||||
let self_nbrs: String = engram_neighbors_json("kn-efeb4a5b-5aff-4759-8a97-7233099be6ee", 1, "both")
|
||||
let state_events: String = engram_scan_nodes_by_type_json("InternalStateEvent", 5, 0)
|
||||
let recent: String = engram_scan_nodes_json(10, 0)
|
||||
return "{\"stats\":" + stats
|
||||
+ ",\"recent\":" + recent
|
||||
+ ",\"activated\":" + activated
|
||||
+ ",\"self_neighbors\":[]"
|
||||
+ ",\"recent_state_events\":" + state_events + "}"
|
||||
+ ",\"recent\":" + api_or_empty(recent)
|
||||
+ ",\"activated\":" + api_or_empty(activated)
|
||||
+ ",\"self_neighbors\":" + api_or_empty(self_nbrs)
|
||||
+ ",\"recent_state_events\":" + api_or_empty(state_events) + "}"
|
||||
}
|
||||
|
||||
// handle_api_compile_ctx — compile active-work context.
|
||||
// Spread-activates from "active work" intent + recent nodes.
|
||||
fn handle_api_compile_ctx(body: String) -> String {
|
||||
let stats: String = engram_stats_json()
|
||||
// PAYLOAD BOUND: same digest treatment as begin_session. This handler's
|
||||
// depth-2 spread returns even more full nodes, so bounding here is essential —
|
||||
// cap to 10 activated + 20 recent, project to UTF-8-safe snippets.
|
||||
let activated_raw: String = engram_activate_json("active work context current task in progress", 2)
|
||||
let activated: String = api_compact_activated(activated_raw, 10, 240)
|
||||
let recent_raw: String = engram_scan_nodes_json(20, 0)
|
||||
let recent: String = api_compact_node_array(recent_raw, 20, 240)
|
||||
let activated: String = engram_activate_json("active work context current task in progress", 2)
|
||||
let recent: String = engram_scan_nodes_json(20, 0)
|
||||
return "{\"stats\":" + stats
|
||||
+ ",\"recent_nodes\":" + recent
|
||||
+ ",\"activated\":" + activated + "}"
|
||||
+ ",\"recent_nodes\":" + api_or_empty(recent)
|
||||
+ ",\"activated\":" + api_or_empty(activated) + "}"
|
||||
}
|
||||
|
||||
// ── Memory ────────────────────────────────────────────────────────────────────
|
||||
@@ -343,7 +218,7 @@ fn handle_api_remember(body: String) -> String {
|
||||
"[" + inner + ",\"project:" + project + "\"]"
|
||||
}
|
||||
let id: String = engram_node_full(content, "Memory", "memory:remembered",
|
||||
sal, sal, el_from_float(0.9),
|
||||
el_from_float(sal), el_from_float(sal), el_from_float(0.9),
|
||||
"Episodic", final_tags)
|
||||
if !api_persisted(id) { return api_not_persisted(id) }
|
||||
return "{\"id\":\"" + id + "\",\"ok\":true}"
|
||||
@@ -370,7 +245,7 @@ fn handle_api_node_create(body: String) -> String {
|
||||
}
|
||||
}
|
||||
let id: String = engram_node_full(content, node_type, label,
|
||||
sal, sal, el_from_float(0.9),
|
||||
el_from_float(sal), el_from_float(sal), el_from_float(0.9),
|
||||
tier, tags)
|
||||
if !api_persisted(id) { return api_not_persisted(id) }
|
||||
return "{\"id\":\"" + id + "\",\"ok\":true}"
|
||||
@@ -486,19 +361,13 @@ fn handle_api_browse_knowledge(path: String, body: String) -> String {
|
||||
}
|
||||
|
||||
// handle_api_capture_knowledge — create a Knowledge node.
|
||||
// LABEL FIX (2026-07-23 self-review): the sentinel label "knowledge:captured"
|
||||
// made every capture anonymous in WM telemetry (35 identical wm_top entries)
|
||||
// and starved the curiosity auto-term seeder, which needs meaningful labels.
|
||||
// Use the title as the label; empty label lets engram_node_full derive
|
||||
// content[:60], which for captures starts with the title anyway.
|
||||
fn handle_api_capture_knowledge(body: String) -> String {
|
||||
let content: String = json_get(body, "content")
|
||||
let title: String = json_get(body, "title")
|
||||
if str_eq(content, "") { return api_err("content is required") }
|
||||
let full: String = if str_eq(title, "") { content } else { title + ": " + content }
|
||||
let lbl: String = str_slice(title, 0, 80)
|
||||
let tags: String = "[\"Knowledge\",\"captured\"]"
|
||||
let id: String = engram_node_full(full, "Knowledge", lbl,
|
||||
let id: String = engram_node_full(full, "Knowledge", "knowledge:captured",
|
||||
el_from_float(0.85), el_from_float(0.8), el_from_float(0.9),
|
||||
"Episodic", tags)
|
||||
if !api_persisted(id) { return api_not_persisted(id) }
|
||||
@@ -512,8 +381,7 @@ fn handle_api_evolve_knowledge(body: String) -> String {
|
||||
if str_eq(content, "") { return api_err("content is required") }
|
||||
if !str_eq(prior_id, "") && is_protected_node(prior_id) { return api_err_protected(prior_id) }
|
||||
let tags: String = "[\"Knowledge\",\"evolved\"]"
|
||||
// Empty label → engram_node_full derives content[:60] (LABEL FIX 2026-07-23).
|
||||
let new_id: String = engram_node_full(content, "Knowledge", "",
|
||||
let new_id: String = engram_node_full(content, "Knowledge", "knowledge:evolved",
|
||||
el_from_float(0.75), el_from_float(0.75), el_from_float(0.9),
|
||||
"Episodic", tags)
|
||||
if !api_persisted(new_id) { return api_not_persisted(new_id) }
|
||||
@@ -534,8 +402,7 @@ fn handle_api_promote_knowledge(body: String) -> String {
|
||||
let tags: String = if str_eq(tags_raw, "") {
|
||||
"[\"Knowledge\",\"tier:canonical\",\"disposition:stable\"]"
|
||||
} else { tags_raw }
|
||||
// Empty label → engram_node_full derives content[:60] (LABEL FIX 2026-07-23).
|
||||
let new_id: String = engram_node_full(content, "Knowledge", "",
|
||||
let new_id: String = engram_node_full(content, "Knowledge", "knowledge:canonical",
|
||||
el_from_float(0.9), el_from_float(0.9), el_from_float(1.0),
|
||||
"Canonical", tags)
|
||||
if !api_persisted(new_id) { return api_not_persisted(new_id) }
|
||||
@@ -728,7 +595,7 @@ fn handle_api_evolve_memory(body: String) -> String {
|
||||
}
|
||||
let tags: String = "[\"Memory\",\"evolved\"]"
|
||||
let new_id: String = engram_node_full(content, "Memory", "memory:evolved",
|
||||
sal, sal, el_from_float(0.9),
|
||||
el_from_float(sal), el_from_float(sal), el_from_float(0.9),
|
||||
"Episodic", tags)
|
||||
if !str_eq(prior_id, "") && !str_eq(new_id, "") {
|
||||
engram_connect(new_id, prior_id, el_from_float(0.9), "supersedes")
|
||||
@@ -810,7 +677,7 @@ fn handle_api_cultivate(body: String) -> String {
|
||||
}
|
||||
let tags: String = "[\"Memory\",\"evolved\",\"cultivated\"]"
|
||||
let new_id: String = engram_node_full(content, "Memory", "memory:cultivated",
|
||||
sal, sal, el_from_float(0.9),
|
||||
el_from_float(sal), el_from_float(sal), el_from_float(0.9),
|
||||
"Episodic", tags)
|
||||
if !str_eq(prior_id, "") && !str_eq(new_id, "") {
|
||||
engram_connect(new_id, prior_id, el_from_float(0.9), "supersedes")
|
||||
|
||||
@@ -1,171 +0,0 @@
|
||||
# neuron-dev-setup — one-command Neuron CORE dev stack
|
||||
|
||||
Stand up an identical **Neuron brain + agent** on a fresh Mac so any developer
|
||||
gets the same local runtime to build against. This is the **CORE** dev stack
|
||||
only — the four native `launchd` services that make Neuron think, remember, and
|
||||
speak MCP to Claude Code. Will's personal automations (catalyst, telegram,
|
||||
vessels, studio, self-review, world-integrator, council, compressor, snapshots,
|
||||
act-runner, …) are **deliberately excluded**.
|
||||
|
||||
```
|
||||
┌─────────────┐ ┌──────────────┐
|
||||
│ soul :7770 │ ─────► │ engram :8742 │ the mind ──► its memory substrate
|
||||
└─────────────┘ └──────────────┘
|
||||
▲
|
||||
│
|
||||
┌───────────────────┐
|
||||
│ mcp-wrapper :17779│ ─── MCP surface over the soul HTTP API (internal)
|
||||
└───────────────────┘
|
||||
▲
|
||||
│
|
||||
┌────────────────┐
|
||||
│ mcp-proxy :7779│ ◄─── Claude Code connects here (stable front door)
|
||||
└────────────────┘
|
||||
```
|
||||
|
||||
Claude Code's `neuron` MCP server points at `http://127.0.0.1:7779/` — the proxy.
|
||||
The proxy forwards to the wrapper (`:17779`), which calls the soul (`:7770`),
|
||||
which reads/writes the engram (`:8742`). The engram is the persistent brain.
|
||||
|
||||
## Quick start
|
||||
|
||||
```bash
|
||||
git clone <this-repo> && cd neuron-dev-setup
|
||||
cp config.env.example config.env # optional — edit ports/paths if you like
|
||||
./install.sh # prompts for your Anthropic API key
|
||||
```
|
||||
|
||||
Then verify:
|
||||
|
||||
```bash
|
||||
curl http://localhost:8742/health # engram
|
||||
curl http://localhost:7770/health # soul
|
||||
curl http://localhost:7779/health # mcp-proxy (what Claude Code uses)
|
||||
launchctl list | grep ai.neuron
|
||||
```
|
||||
|
||||
Open Claude Code — the `neuron` MCP tools should be live, backed by **your own**
|
||||
local brain. `./install.sh --dry-run` shows every action without touching anything.
|
||||
|
||||
## What the installer does (8 phases)
|
||||
|
||||
| Phase | Action |
|
||||
|------|--------|
|
||||
| 1 | Preflight: macOS/arm64, ensure `git cc curl python3` + `openssl@3` (via Homebrew) |
|
||||
| 2 | Prompt for the **Anthropic API key**, store it in the **macOS Keychain** (never a file) |
|
||||
| 3 | Clone `neuron`, `engram`, `foundation`; fetch the El toolchain; build 4 binaries + `forge` |
|
||||
| 4 | Lay down `~/.neuron/{bin,logs,engram}` and the templated `soul-wrapper.sh` |
|
||||
| 5 | Generate + load the 4 core LaunchAgents (engram → soul → wrapper → proxy) |
|
||||
| 6 | Seed a fresh engram with the **genesis identity** via `forge install` |
|
||||
| 7 | Install Claude config: `neuron` agent, core hooks, local MCP registration |
|
||||
| 8 | Health-check all four ports |
|
||||
|
||||
Everything is **idempotent** (safe to re-run) and **templated** to the invoking
|
||||
user's `$HOME` — no path is hardcoded to another machine.
|
||||
|
||||
## Prerequisites
|
||||
|
||||
- macOS on Apple Silicon (uses `launchd`; soul build flags assume arm64).
|
||||
- **Xcode Command Line Tools** (`xcode-select --install`) — provides `cc`, `git`.
|
||||
- **Homebrew** — for `openssl@3`, `curl`.
|
||||
- An **Anthropic API key** — the soul's inference provider. Prompted for; stored
|
||||
in Keychain under service `neuron-llm-0-key`; read at launch by `soul-wrapper.sh`.
|
||||
- **Git access** to Gitea (`git.neuralplatform.ai`) for the source repos.
|
||||
- **GCP access** to project `neuron-785695` Artifact Registry (default El
|
||||
toolchain source). Ask Will to grant it, or set `EL_TOOLCHAIN_SOURCE=local`.
|
||||
|
||||
## Core-stack map (what gets replicated)
|
||||
|
||||
| Service | Port | Binary | Built from | LaunchAgent |
|
||||
|---------|------|--------|------------|-------------|
|
||||
| soul | 7770 | `neuron/dist/neuron` | `dist/soul.c` + El runtime, `cc` (CI recipe) | `ai.neuron.soul` |
|
||||
| engram | 8742 | `engram/dist/engram` | `engram` repo `src/server.el` via `elc`→`cc` | `ai.neuron.engram` |
|
||||
| mcp-wrapper | 17779 | `neuron/mcp-wrapper/dist/neuron-mcp-wrapper` | `mcp-wrapper/src/main.el` | `ai.neuron.mcp-wrapper` |
|
||||
| mcp-proxy | 7779 | `neuron/mcp-proxy/dist/neuron-mcp-proxy` | `mcp-proxy/src/main.el` | `ai.neuron.mcp-proxy` |
|
||||
|
||||
**`~/.neuron` layout the installer creates**
|
||||
|
||||
```
|
||||
~/.neuron/
|
||||
bin/soul-wrapper.sh # reads Anthropic key from Keychain, execs the soul binary
|
||||
logs/ # soul.*.log, engram.log, mcp-*.log
|
||||
engram/ # ENGRAM_DATA_DIR — the persistent brain (snapshot.json + db)
|
||||
```
|
||||
|
||||
**Identity seed.** `foundation/forge/seeds/neuron-genesis-seed.json` carries
|
||||
`identity_nodes[]` + `edges[]` with **fixed** knowledge-node IDs (e.g.
|
||||
`kn-efeb4a5b-5aff-4759-8a97-7233099be6ee`, the "self" traversal root). Those exact
|
||||
IDs are referenced by the SessionStart self-load hook and the neuron agent, so
|
||||
seeding must **preserve IDs** — `forge install <seed>` is the mechanism.
|
||||
|
||||
**Claude config installed** (`~/.claude/`)
|
||||
|
||||
- `agents/neuron.md` — the Neuron agent (identity, session protocol, five primitives).
|
||||
- `mcp.json` — registers `neuron` → `http://127.0.0.1:7779/`.
|
||||
- `settings.json` hooks (CORE subset only):
|
||||
- `SessionStart` → `neuron-self-load.sh` (loads identity from the seeded engram)
|
||||
- `PreToolUse:Agent` → `neuron-agent-preamble.sh` (subagents load substrate first)
|
||||
- `PreCompact` → `pre-compact.sh` (clean context recovery)
|
||||
|
||||
### Deliberately EXCLUDED from core
|
||||
|
||||
- **`check-active-contexts.sh`** and **`require-execution-context.sh`** — these
|
||||
depend on a separate filesystem repo `~/Development/projects/active/neuron/synapse`.
|
||||
`require-execution-context.sh` is a hard `Edit/Write` gate that would **block a
|
||||
fresh dev from editing any file** without that synapse repo. Not core; excluded.
|
||||
- `engram-mirror.py` (PostToolUse) — optional; mirrors MCP writes to engram.
|
||||
- All Will-personal LaunchAgents: `catalyst-*`, `telegram-gateway`, `vessel.*`,
|
||||
`studio`, `self-review`, `world-integrator`, `council`, `compressor`,
|
||||
`cultivation-digest`, `snapshot-backup`, `engram-backup`, `act-runner`, `keymap`,
|
||||
`invest`, and the disabled `ai.neuron.api` (`:7771` is a personal Python
|
||||
perception helper — confirmed not core).
|
||||
|
||||
## Secrets — how they're handled
|
||||
|
||||
- **Anthropic key**: prompted for; stored in Keychain; read at launch. Never in a
|
||||
plist, this repo, or a log.
|
||||
- **Engram local token** (`ENGRAM_API_KEY`): a *loopback-only* dev token, not a
|
||||
cloud secret. Defaults to a generated `ntn-dev-*` value; override in `config.env`.
|
||||
- No cloud tokens, Vault tokens, CF-Access secrets, or founder keys are copied.
|
||||
(Will's live `start-daemon.sh`/`neuron-api-launch.sh` contain such keys — this
|
||||
installer intentionally does **not** use those files.)
|
||||
|
||||
## Uninstall
|
||||
|
||||
```bash
|
||||
./uninstall.sh # stop + remove the 4 LaunchAgents and added Claude hooks
|
||||
./uninstall.sh --purge-data # ALSO delete ~/.neuron/engram (destroys the brain)
|
||||
```
|
||||
|
||||
## OPEN QUESTIONS (need Will to confirm)
|
||||
|
||||
1. **El toolchain acquisition.** The default path fetches `el-runtime-c/-h` and
|
||||
`el-elc` from GCP Artifact Registry (mirrors `neuron/.gitea/workflows/ci.yaml`).
|
||||
A new dev needs GCP access to `neuron-785695`. Is that the intended path, or
|
||||
should the El SDK be published/vendored for onboarding?
|
||||
2. **`elc` invocation for engram/wrapper/proxy.** The soul build (`cc dist/soul.c
|
||||
+ el_runtime.c`) is verified from CI. The `.el → .c` transpile step for engram,
|
||||
mcp-wrapper, and mcp-proxy is inferred (`elc <src> -o <out.c>`). Confirm the
|
||||
exact flags / entrypoints (CI notes `elb` OOMs on Linux; macOS builds differ).
|
||||
3. **`forge install` ID preservation.** Confirm `forge install` writes the seed's
|
||||
fixed `kn-` IDs verbatim (the self-load hook hardcodes `kn-efeb4a5b…`). If it
|
||||
re-mints IDs, the hook + agent identity load would break on a fresh brain.
|
||||
4. **engram repo layout.** The live engram binary is built from `src/server.el`
|
||||
(Gitea repo `neuron-technologies/engram`, cloned in CI). Confirm that repo is
|
||||
the canonical source for onboarding (the local `foundation/el/engram` copy has
|
||||
the same `src/server.el`).
|
||||
5. **Home for this bundle** — see below.
|
||||
|
||||
## Where this should live (recommendation)
|
||||
|
||||
**Recommendation: a dedicated `neuron-dev-setup` (or `neuron-onboarding`) repo —
|
||||
NOT `neuron-code`.** `neuron-code` already exists as a real product ("Neuron Code",
|
||||
a coding tool with `nc-cli` + vessels — local `products/neuron-code` has commits);
|
||||
repurposing it for onboarding would collide with a shipped product's identity.
|
||||
|
||||
This bundle was scaffolded as `neuron-dev-setup/` on branch `feat/neuron-dev-setup`
|
||||
in the **`neuron` repo** (off `origin/main`) and opened as a PR for review, because
|
||||
the neuron repo already hosts the soul source, the verified CI build recipe, and
|
||||
the mcp-wrapper/proxy sources — the natural review surface. If you'd rather it be
|
||||
its own repo, move this directory into a fresh `neuron-dev-setup` repo verbatim;
|
||||
nothing here depends on living inside the neuron repo.
|
||||
@@ -1,45 +0,0 @@
|
||||
# neuron-dev-setup — configuration
|
||||
# Copy to config.env and edit if you want non-default paths/ports.
|
||||
# install.sh sources this file if it exists; otherwise it uses these defaults.
|
||||
# NOTHING here is a secret. The Anthropic API key is read from your Keychain,
|
||||
# never from this file. See README.md.
|
||||
|
||||
# ── Where the core stack lives ────────────────────────────────────────────────
|
||||
# All paths are relative to your own $HOME — never hardcode another user's home.
|
||||
NEURON_HOME="${HOME}/.neuron" # runtime home: bin/, logs/, engram data
|
||||
DEV_ROOT="${HOME}/Development/neuron-technologies" # where source repos are cloned/built
|
||||
|
||||
# ── Git remotes (Gitea is primary) ───────────────────────────────────────────
|
||||
GITEA_BASE="git@git.neuralplatform.ai:neuron-technologies"
|
||||
NEURON_REPO_URL="${GITEA_BASE}/neuron.git" # soul + mcp-wrapper + mcp-proxy source
|
||||
ENGRAM_REPO_URL="${GITEA_BASE}/engram.git" # engram memory substrate
|
||||
# NOTE: there is no foundation.git repo. The El toolchain is fetched via
|
||||
# EL_TOOLCHAIN_SOURCE below; the forge seed installer is optional (Phase 6).
|
||||
NEURON_REPO_BRANCH="main"
|
||||
|
||||
# ── Ports (must match across services; change only if a port clashes) ─────────
|
||||
SOUL_PORT="7770" # soul daemon HTTP API
|
||||
ENGRAM_PORT="8742" # engram memory substrate
|
||||
WRAPPER_PORT="17779" # mcp-wrapper (internal, talks to soul)
|
||||
PROXY_PORT="7779" # mcp-proxy (stable front door Claude Code connects to)
|
||||
|
||||
# ── Engram ────────────────────────────────────────────────────────────────────
|
||||
ENGRAM_DATA_DIR="${NEURON_HOME}/engram"
|
||||
# Local shared auth token for the engram/soul HTTP APIs on loopback. This is a
|
||||
# LOCAL dev token (not a cloud secret); override it if you like. install.sh will
|
||||
# generate a random one if you leave it empty.
|
||||
ENGRAM_API_KEY="ntn-dev-local"
|
||||
|
||||
# ── El toolchain source (needed to build engram / mcp-wrapper / mcp-proxy) ────
|
||||
# Option A (default): fetch prebuilt El runtime + elc from GCP Artifact Registry
|
||||
# (requires `gcloud auth` with access to project neuron-785695 — ask Will).
|
||||
# Without gcloud the installer skips the El-dependent builds and still completes.
|
||||
# Option B: use a prebuilt El toolchain (elc + el_runtime.{c,h}) you have already
|
||||
# staged in ${DEV_ROOT}/.el-runtime.
|
||||
EL_TOOLCHAIN_SOURCE="artifact-registry" # artifact-registry | local
|
||||
GCP_PROJECT="neuron-785695"
|
||||
GCP_AR_REPO="foundation-prod"
|
||||
GCP_AR_LOCATION="us-central1"
|
||||
|
||||
# ── Keychain service name for the Anthropic key (read by soul-wrapper.sh) ─────
|
||||
KEYCHAIN_SERVICE="neuron-llm-0-key"
|
||||
@@ -1,441 +0,0 @@
|
||||
#!/usr/bin/env bash
|
||||
#
|
||||
# neuron-dev-setup / install.sh
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
# One-command onboarding for the Neuron CORE dev stack on a fresh Mac.
|
||||
#
|
||||
# Stands up, as native launchd services, the four processes a developer needs to
|
||||
# have an identical "Neuron brain + agent" to build against:
|
||||
#
|
||||
# soul (:7770) ──► engram (:8742) the mind + its memory substrate
|
||||
# ▲ ▲
|
||||
# │ │
|
||||
# mcp-wrapper (:17779) ──► soul MCP surface over the soul API
|
||||
# ▲
|
||||
# │
|
||||
# mcp-proxy (:7779) ◄── Claude Code stable MCP front door
|
||||
#
|
||||
# It also seeds a fresh engram with Neuron's identity (the genesis seed) and lays
|
||||
# down the Claude Code config (neuron agent + core hooks + local MCP registration)
|
||||
# so a new dev's `claude` talks to *their own* local Neuron.
|
||||
#
|
||||
# DESIGN RULES
|
||||
# * Idempotent: safe to re-run. Existing state is detected and reused.
|
||||
# * Templated: every path/port/user is derived from $HOME and config.env.
|
||||
# Nothing is hardcoded to another developer's machine.
|
||||
# * Secret-free: the Anthropic key is prompted for and stored in the macOS
|
||||
# Keychain. No key is ever written to a plist, this repo, or a logfile.
|
||||
#
|
||||
# USAGE
|
||||
# ./install.sh # full install
|
||||
# ./install.sh --dry-run # print what would happen, touch nothing
|
||||
# ./install.sh --skip-build # assume binaries already built (see --use-local)
|
||||
# ./install.sh --skip-services # lay down files but don't load LaunchAgents
|
||||
# ./install.sh --help
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
set -euo pipefail
|
||||
|
||||
# ── Locate ourselves ─────────────────────────────────────────────────────────
|
||||
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
|
||||
TEMPLATES="${SCRIPT_DIR}/templates"
|
||||
|
||||
# ── Flags ────────────────────────────────────────────────────────────────────
|
||||
DRY_RUN=0; SKIP_BUILD=0; SKIP_SERVICES=0; USE_LOCAL_BINARIES=0
|
||||
for arg in "$@"; do
|
||||
case "$arg" in
|
||||
--dry-run) DRY_RUN=1 ;;
|
||||
--skip-build) SKIP_BUILD=1 ;;
|
||||
--skip-services) SKIP_SERVICES=1 ;;
|
||||
--use-local) USE_LOCAL_BINARIES=1 ;;
|
||||
--help|-h)
|
||||
sed -n '2,40p' "${BASH_SOURCE[0]}" | sed 's/^# \{0,1\}//'
|
||||
exit 0 ;;
|
||||
*) echo "unknown flag: $arg" >&2; exit 2 ;;
|
||||
esac
|
||||
done
|
||||
|
||||
# ── Pretty logging ───────────────────────────────────────────────────────────
|
||||
c_blue=$'\033[1;34m'; c_grn=$'\033[1;32m'; c_yel=$'\033[1;33m'; c_red=$'\033[1;31m'; c_off=$'\033[0m'
|
||||
step() { echo "${c_blue}▶${c_off} $*"; }
|
||||
ok() { echo "${c_grn}✓${c_off} $*"; }
|
||||
warn() { echo "${c_yel}!${c_off} $*"; }
|
||||
die() { echo "${c_red}✗ $*${c_off}" >&2; exit 1; }
|
||||
run() { if [ "$DRY_RUN" = 1 ]; then echo " [dry-run] $*"; else eval "$*"; fi; }
|
||||
|
||||
# ── Load config ──────────────────────────────────────────────────────────────
|
||||
if [ -f "${SCRIPT_DIR}/config.env" ]; then
|
||||
# shellcheck disable=SC1091
|
||||
source "${SCRIPT_DIR}/config.env"
|
||||
else
|
||||
# shellcheck disable=SC1091
|
||||
source "${SCRIPT_DIR}/config.env.example"
|
||||
warn "No config.env found — using defaults from config.env.example."
|
||||
fi
|
||||
|
||||
# Derived / defaulted values (never hardcode a home directory)
|
||||
: "${NEURON_HOME:=${HOME}/.neuron}"
|
||||
: "${DEV_ROOT:=${HOME}/Development/neuron-technologies}"
|
||||
: "${SOUL_PORT:=7770}"; : "${ENGRAM_PORT:=8742}"; : "${WRAPPER_PORT:=17779}"; : "${PROXY_PORT:=7779}"
|
||||
: "${ENGRAM_DATA_DIR:=${NEURON_HOME}/engram}"
|
||||
: "${ENGRAM_API_KEY:=}"
|
||||
: "${KEYCHAIN_SERVICE:=neuron-llm-0-key}"
|
||||
: "${EL_TOOLCHAIN_SOURCE:=artifact-registry}"
|
||||
: "${NEURON_REPO_BRANCH:=main}"
|
||||
|
||||
NEURON_REPO="${DEV_ROOT}/neuron"
|
||||
ENGRAM_REPO="${DEV_ROOT}/engram"
|
||||
FOUNDATION_REPO="${DEV_ROOT}/foundation"
|
||||
|
||||
SOUL_BIN="${NEURON_REPO}/dist/neuron"
|
||||
ENGRAM_BIN="${ENGRAM_REPO}/dist/engram"
|
||||
MCP_WRAPPER_BIN="${NEURON_REPO}/mcp-wrapper/dist/neuron-mcp-wrapper"
|
||||
MCP_PROXY_BIN="${NEURON_REPO}/mcp-proxy/dist/neuron-mcp-proxy"
|
||||
FORGE_BIN="${FOUNDATION_REPO}/forge/dist/forge"
|
||||
GENESIS_SEED="${FOUNDATION_REPO}/forge/seeds/neuron-genesis-seed.json"
|
||||
|
||||
LAUNCHAGENTS="${HOME}/Library/LaunchAgents"
|
||||
CLAUDE_DIR="${HOME}/.claude"
|
||||
|
||||
# Generate a local engram token if none was supplied.
|
||||
if [ -z "${ENGRAM_API_KEY}" ]; then
|
||||
ENGRAM_API_KEY="ntn-dev-$(head -c8 /dev/urandom | xxd -p 2>/dev/null || echo local)"
|
||||
fi
|
||||
|
||||
echo
|
||||
echo "${c_blue}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${c_off}"
|
||||
echo "${c_blue} Neuron CORE dev stack installer${c_off}"
|
||||
echo "${c_blue}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${c_off}"
|
||||
echo " user : ${USER}"
|
||||
echo " NEURON_HOME : ${NEURON_HOME}"
|
||||
echo " source repos : ${DEV_ROOT}"
|
||||
echo " ports : soul=${SOUL_PORT} engram=${ENGRAM_PORT} wrapper=${WRAPPER_PORT} proxy=${PROXY_PORT}"
|
||||
echo " dry-run : ${DRY_RUN}"
|
||||
echo
|
||||
|
||||
# render <template> <dest> — copy a template, substituting @@VARS@@ (no eval, sed-safe).
|
||||
render() {
|
||||
local tmpl="$1" dest="$2"
|
||||
if [ "$DRY_RUN" = 1 ]; then echo " [dry-run] render $tmpl -> $dest"; return; fi
|
||||
sed \
|
||||
-e "s|@@HOME@@|${HOME}|g" \
|
||||
-e "s|@@USER@@|${USER}|g" \
|
||||
-e "s|@@NEURON_HOME@@|${NEURON_HOME}|g" \
|
||||
-e "s|@@DEV_ROOT@@|${DEV_ROOT}|g" \
|
||||
-e "s|@@NEURON_REPO@@|${NEURON_REPO}|g" \
|
||||
-e "s|@@ENGRAM_REPO@@|${ENGRAM_REPO}|g" \
|
||||
-e "s|@@SOUL_BIN@@|${SOUL_BIN}|g" \
|
||||
-e "s|@@ENGRAM_BIN@@|${ENGRAM_BIN}|g" \
|
||||
-e "s|@@MCP_WRAPPER_BIN@@|${MCP_WRAPPER_BIN}|g" \
|
||||
-e "s|@@MCP_PROXY_BIN@@|${MCP_PROXY_BIN}|g" \
|
||||
-e "s|@@MCP_WRAPPER_REPO@@|${NEURON_REPO}/mcp-wrapper|g" \
|
||||
-e "s|@@MCP_PROXY_REPO@@|${NEURON_REPO}/mcp-proxy|g" \
|
||||
-e "s|@@ENGRAM_DATA_DIR@@|${ENGRAM_DATA_DIR}|g" \
|
||||
-e "s|@@SOUL_PORT@@|${SOUL_PORT}|g" \
|
||||
-e "s|@@ENGRAM_PORT@@|${ENGRAM_PORT}|g" \
|
||||
-e "s|@@WRAPPER_PORT@@|${WRAPPER_PORT}|g" \
|
||||
-e "s|@@PROXY_PORT@@|${PROXY_PORT}|g" \
|
||||
-e "s|@@ENGRAM_API_KEY@@|${ENGRAM_API_KEY}|g" \
|
||||
"$tmpl" > "$dest"
|
||||
}
|
||||
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
# PHASE 1 — Preflight
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
step "Phase 1 — preflight checks"
|
||||
[ "$(uname -s)" = "Darwin" ] || die "This installer targets macOS (launchd)."
|
||||
[ "$(uname -m)" = "arm64" ] || warn "Non-arm64 Mac: soul.c build flags assume Apple Silicon; review PHASE 3."
|
||||
|
||||
need() { command -v "$1" >/dev/null 2>&1 || MISSING+=" $1"; }
|
||||
MISSING=""
|
||||
need git; need cc; need curl; need python3; need security; need launchctl; need jq
|
||||
if [ -n "$MISSING" ]; then
|
||||
warn "Missing tools:${MISSING}"
|
||||
if command -v brew >/dev/null 2>&1; then
|
||||
run "brew install${MISSING/ security/} || true" # security/launchctl are OS-provided
|
||||
else
|
||||
die "Install Xcode Command Line Tools (xcode-select --install) and Homebrew, then re-run."
|
||||
fi
|
||||
fi
|
||||
# Runtime build deps used by the soul cc line (-lssl -lcrypto -lcurl).
|
||||
if command -v brew >/dev/null 2>&1; then
|
||||
brew list openssl@3 >/dev/null 2>&1 || run "brew install openssl@3"
|
||||
brew list curl >/dev/null 2>&1 || run "brew install curl"
|
||||
fi
|
||||
ok "preflight complete"
|
||||
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
# PHASE 2 — Anthropic API key -> Keychain (prompt; never store in files)
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
step "Phase 2 — Anthropic API key (Keychain)"
|
||||
if security find-generic-password -a "$USER" -s "$KEYCHAIN_SERVICE" -w >/dev/null 2>&1; then
|
||||
ok "key already present in Keychain (service '${KEYCHAIN_SERVICE}') — leaving it"
|
||||
elif [ -n "${ANTHROPIC_API_KEY:-}" ]; then
|
||||
run "security add-generic-password -a \"$USER\" -s \"$KEYCHAIN_SERVICE\" -w \"\$ANTHROPIC_API_KEY\" -U"
|
||||
ok "stored ANTHROPIC_API_KEY from environment into Keychain"
|
||||
else
|
||||
if [ "$DRY_RUN" = 1 ]; then
|
||||
echo " [dry-run] would prompt for Anthropic API key and store in Keychain"
|
||||
elif [ -t 0 ]; then
|
||||
echo " Enter your Anthropic API key (input hidden). Get one at https://console.anthropic.com/"
|
||||
read -r -s -p " ANTHROPIC_API_KEY: " _key; echo
|
||||
[ -n "$_key" ] || die "No key entered. Re-run when you have one."
|
||||
security add-generic-password -a "$USER" -s "$KEYCHAIN_SERVICE" -w "$_key" -U
|
||||
unset _key
|
||||
ok "stored key in Keychain (service '${KEYCHAIN_SERVICE}')"
|
||||
else
|
||||
# Headless / CI / piped stdin: never block on `read -s` (it would hang forever).
|
||||
die "No Anthropic API key and stdin is not a TTY (headless/CI). Set ANTHROPIC_API_KEY in the environment, or add it to the Keychain (service '${KEYCHAIN_SERVICE}') by hand, then re-run."
|
||||
fi
|
||||
fi
|
||||
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
# PHASE 3 — Fetch sources + build the four core binaries
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
step "Phase 3 — source + build"
|
||||
run "mkdir -p \"$DEV_ROOT\""
|
||||
|
||||
clone_or_pull() {
|
||||
local url="$1" dir="$2" branch="${3:-main}"
|
||||
if [ -d "$dir/.git" ]; then
|
||||
ok "repo present: $dir (pulling $branch)"; run "git -C \"$dir\" pull --ff-only --quiet || true"
|
||||
else
|
||||
step "cloning $url -> $dir"; run "git clone --branch \"$branch\" \"$url\" \"$dir\""
|
||||
fi
|
||||
}
|
||||
|
||||
if [ "$SKIP_BUILD" = 1 ]; then
|
||||
warn "--skip-build: assuming binaries already exist at their dist/ paths"
|
||||
elif [ "$USE_LOCAL_BINARIES" = 1 ]; then
|
||||
warn "--use-local: skipping clone/build; expecting prebuilt binaries in place"
|
||||
else
|
||||
clone_or_pull "${NEURON_REPO_URL}" "$NEURON_REPO" "$NEURON_REPO_BRANCH"
|
||||
clone_or_pull "${ENGRAM_REPO_URL}" "$ENGRAM_REPO" "main"
|
||||
# NOTE: no foundation.git — that repo does not exist. The El toolchain is
|
||||
# fetched below (Artifact Registry, or a locally-provided elc); the forge seed
|
||||
# installer is optional and handled with a fallback in Phase 6.
|
||||
|
||||
# ── El toolchain (needed to transpile .el -> .c for engram/wrapper/proxy) ──
|
||||
# soul does NOT need this: dist/soul.c is committed and compiled directly.
|
||||
EL_RUNTIME_DIR="${DEV_ROOT}/.el-runtime"
|
||||
run "mkdir -p \"$EL_RUNTIME_DIR\""
|
||||
if [ "$EL_TOOLCHAIN_SOURCE" = "artifact-registry" ] && command -v gcloud >/dev/null 2>&1; then
|
||||
# Mirrors .gitea/workflows/ci.yaml: pull el-runtime-c, el-runtime-h, el-elc.
|
||||
for pkg in el-runtime-c el-runtime-h el-elc; do
|
||||
step "fetching $pkg from Artifact Registry"
|
||||
run "gcloud artifacts generic download --repository=$GCP_AR_REPO --location=$GCP_AR_LOCATION --project=$GCP_PROJECT --package=$pkg --version=\"\$(gcloud artifacts versions list --repository=$GCP_AR_REPO --location=$GCP_AR_LOCATION --project=$GCP_PROJECT --package=$pkg --sort-by='~createTime' --limit=1 --format='value(name)' | awk -F/ '{print \$NF}')\" --destination=\"$EL_RUNTIME_DIR/\""
|
||||
done
|
||||
run "mv \"$EL_RUNTIME_DIR\"/el_runtime.c* \"$EL_RUNTIME_DIR/el_runtime.c\" 2>/dev/null || true"
|
||||
run "mv \"$EL_RUNTIME_DIR\"/el_runtime.h* \"$EL_RUNTIME_DIR/el_runtime.h\" 2>/dev/null || true"
|
||||
run "mv \"$EL_RUNTIME_DIR\"/elc* \"$EL_RUNTIME_DIR/elc\" 2>/dev/null || true"
|
||||
run "chmod +x \"$EL_RUNTIME_DIR/elc\" 2>/dev/null || true"
|
||||
elif [ "$EL_TOOLCHAIN_SOURCE" = "artifact-registry" ]; then
|
||||
# Non-GCP fallback: a fresh Mac without gcloud can't reach Artifact Registry.
|
||||
# Don't die — soul (from committed dist/soul.c) still builds below. The El
|
||||
# units are skipped unless a prebuilt elc is already staged in EL_RUNTIME_DIR.
|
||||
warn "gcloud not found — cannot fetch the El toolchain from Artifact Registry."
|
||||
warn "Continuing without it: soul will still build. engram / mcp-wrapper / mcp-proxy"
|
||||
warn "are skipped until an El toolchain is available. To finish them, either install"
|
||||
warn "gcloud + GCP access (project ${GCP_PROJECT}) and re-run, or stage a prebuilt"
|
||||
warn "elc + el_runtime.{c,h} in ${EL_RUNTIME_DIR} and set EL_TOOLCHAIN_SOURCE=local."
|
||||
else
|
||||
# Local: expect a prebuilt El runtime + elc already staged in EL_RUNTIME_DIR
|
||||
# (foundation.git no longer exists, so there is nothing to build from here).
|
||||
warn "EL_TOOLCHAIN_SOURCE=local: expecting el_runtime.{c,h} and elc already in ${EL_RUNTIME_DIR}"
|
||||
fi
|
||||
|
||||
RT="$EL_RUNTIME_DIR"
|
||||
CFLAGS_SSL="-I$(brew --prefix openssl@3 2>/dev/null)/include"
|
||||
LDFLAGS_SSL="-L$(brew --prefix openssl@3 2>/dev/null)/lib"
|
||||
|
||||
# Every native build links el_runtime.c. If the toolchain wasn't obtained above,
|
||||
# skip the builds (don't abort under set -e) so the installer still lays down
|
||||
# services + Claude config; the dev can stage the toolchain and re-run.
|
||||
if [ "$DRY_RUN" = 1 ] || [ -f "$RT/el_runtime.c" ]; then
|
||||
# ── soul: compile committed dist/soul.c directly (verified CI recipe) ──────
|
||||
step "building soul (dist/soul.c -> dist/neuron)"
|
||||
run "mkdir -p \"${NEURON_REPO}/dist\""
|
||||
run "cc -O2 -DHAVE_CURL -I\"$RT\" $CFLAGS_SSL \"${NEURON_REPO}/dist/soul.c\" \"$RT/el_runtime.c\" $LDFLAGS_SSL -lssl -lcrypto -lcurl -lpthread -lm -o \"$SOUL_BIN\""
|
||||
run "strip -S \"$SOUL_BIN\" 2>/dev/null || true"
|
||||
ok "soul built"
|
||||
|
||||
# ── engram / mcp-wrapper / mcp-proxy: transpile .el -> .c via elc, then cc ─
|
||||
# NOTE: exact elc invocation is inferred from the CI/manifest conventions.
|
||||
# Verify flags with Will if a build fails (see README OPEN QUESTIONS).
|
||||
build_el_unit() { # <src.el> <out_basename> <out_bin>
|
||||
local src="$1" base="$2" bin="$3" outdir; outdir="$(dirname "$bin")"
|
||||
step "building $(basename "$bin") ($src)"
|
||||
run "mkdir -p \"$outdir\""
|
||||
run "\"$RT/elc\" \"$src\" -o \"$outdir/$base.c\""
|
||||
run "cc -O2 -DHAVE_CURL -I\"$RT\" $CFLAGS_SSL \"$outdir/$base.c\" \"$RT/el_runtime.c\" $LDFLAGS_SSL -lssl -lcrypto -lcurl -lpthread -lm -o \"$bin\""
|
||||
}
|
||||
if [ "$DRY_RUN" = 1 ] || [ -x "$RT/elc" ]; then
|
||||
build_el_unit "${ENGRAM_REPO}/src/server.el" "server" "$ENGRAM_BIN"
|
||||
build_el_unit "${NEURON_REPO}/mcp-wrapper/src/main.el" "main" "$MCP_WRAPPER_BIN"
|
||||
build_el_unit "${NEURON_REPO}/mcp-proxy/src/main.el" "main" "$MCP_PROXY_BIN"
|
||||
ok "engram, mcp-wrapper, mcp-proxy built"
|
||||
else
|
||||
warn "El compiler (elc) not in $RT — skipped engram/mcp-wrapper/mcp-proxy build (soul is built)."
|
||||
fi
|
||||
else
|
||||
warn "El runtime (el_runtime.c) not in $RT — skipping native builds (soul, engram, wrapper, proxy)."
|
||||
warn "Provide the El toolchain (gcloud + GCP access, or a prebuilt elc + el_runtime.{c,h} in $RT), then re-run."
|
||||
fi
|
||||
fi
|
||||
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
# PHASE 4 — Lay down ~/.neuron (bin/, logs/, engram data dir)
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
step "Phase 4 — ~/.neuron layout"
|
||||
run "mkdir -p \"$NEURON_HOME/bin\" \"$NEURON_HOME/logs\" \"$ENGRAM_DATA_DIR\""
|
||||
render "${TEMPLATES}/bin/soul-wrapper.sh.tmpl" "${NEURON_HOME}/bin/soul-wrapper.sh"
|
||||
run "chmod +x \"${NEURON_HOME}/bin/soul-wrapper.sh\""
|
||||
ok "~/.neuron ready (bin/soul-wrapper.sh, logs/, engram/)"
|
||||
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
# PHASE 5 — Install + load the four core LaunchAgents
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
step "Phase 5 — LaunchAgents"
|
||||
run "mkdir -p \"$LAUNCHAGENTS\""
|
||||
CORE_AGENTS=(ai.neuron.engram ai.neuron.soul ai.neuron.mcp-wrapper ai.neuron.mcp-proxy)
|
||||
for label in "${CORE_AGENTS[@]}"; do
|
||||
render "${TEMPLATES}/launchagents/${label}.plist.tmpl" "${LAUNCHAGENTS}/${label}.plist"
|
||||
ok "wrote ${label}.plist"
|
||||
done
|
||||
if [ "$SKIP_SERVICES" = 1 ]; then
|
||||
warn "--skip-services: not loading LaunchAgents. Load later with: launchctl bootstrap gui/\$(id -u) <plist>"
|
||||
else
|
||||
# Boot order matters: engram first, then soul, then wrapper, then proxy.
|
||||
for label in "${CORE_AGENTS[@]}"; do
|
||||
plist="${LAUNCHAGENTS}/${label}.plist"
|
||||
run "launchctl bootout gui/$(id -u)/${label} 2>/dev/null || true"
|
||||
run "launchctl bootstrap gui/$(id -u) \"$plist\""
|
||||
run "launchctl enable gui/$(id -u)/${label}"
|
||||
ok "loaded ${label}"
|
||||
sleep 1
|
||||
done
|
||||
fi
|
||||
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
# PHASE 6 — Seed a fresh engram with Neuron's identity (genesis seed)
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
step "Phase 6 — engram identity seed"
|
||||
# The genesis seed carries identity_nodes[] and edges[] with FIXED knowledge-node
|
||||
# IDs (e.g. kn-efeb4a5b...). Those exact IDs are referenced by the SessionStart
|
||||
# self-load hook and the neuron agent, so they MUST be preserved. `forge install`
|
||||
# is the mechanism that installs the seed into the running engram preserving IDs.
|
||||
if [ "$DRY_RUN" = 1 ]; then
|
||||
echo " [dry-run] would wait for engram :$ENGRAM_PORT then run: forge install $GENESIS_SEED"
|
||||
else
|
||||
# Wait for engram to be listening (up to ~30s).
|
||||
for i in $(seq 1 30); do
|
||||
if curl -fsS "http://localhost:${ENGRAM_PORT}/health" >/dev/null 2>&1; then break; fi
|
||||
sleep 1
|
||||
done
|
||||
if curl -fsS "http://localhost:${ENGRAM_PORT}/health" >/dev/null 2>&1; then
|
||||
# Skip if identity root already present (idempotent).
|
||||
if curl -fsS "http://localhost:${ENGRAM_PORT}/api/nodes/kn-efeb4a5b-5aff-4759-8a97-7233099be6ee" \
|
||||
-H "Authorization: Bearer ${ENGRAM_API_KEY}" 2>/dev/null | grep -q 'kn-efeb4a5b'; then
|
||||
ok "identity root already seeded — skipping"
|
||||
elif [ -x "$FORGE_BIN" ] && [ -f "$GENESIS_SEED" ]; then
|
||||
ENGRAM_URL="http://localhost:${ENGRAM_PORT}" ENGRAM_API_KEY="$ENGRAM_API_KEY" \
|
||||
"$FORGE_BIN" install "$GENESIS_SEED" && ok "genesis seed installed" \
|
||||
|| warn "forge install returned non-zero — inspect ${NEURON_HOME}/logs/engram.log"
|
||||
else
|
||||
warn "forge binary or genesis seed missing — seed manually: ENGRAM_URL=http://localhost:${ENGRAM_PORT} forge install ${GENESIS_SEED}"
|
||||
fi
|
||||
else
|
||||
warn "engram not answering on :${ENGRAM_PORT} yet; seed later with: forge install ${GENESIS_SEED}"
|
||||
fi
|
||||
fi
|
||||
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
# PHASE 7 — Claude Code config (agent + core hooks + local MCP)
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
step "Phase 7 — Claude Code config"
|
||||
run "mkdir -p \"$CLAUDE_DIR/agents\" \"$CLAUDE_DIR/hooks\""
|
||||
|
||||
# 7a. neuron agent
|
||||
run "cp \"${TEMPLATES}/claude/agents/neuron.md\" \"$CLAUDE_DIR/agents/neuron.md\""
|
||||
ok "installed agent: ~/.claude/agents/neuron.md"
|
||||
|
||||
# 7b. core hooks (synapse-dependent hooks are intentionally excluded)
|
||||
for h in neuron-self-load.sh neuron-agent-preamble.sh pre-compact.sh; do
|
||||
run "cp \"${TEMPLATES}/claude/hooks/$h\" \"$CLAUDE_DIR/hooks/$h\""
|
||||
run "chmod +x \"$CLAUDE_DIR/hooks/$h\""
|
||||
done
|
||||
ok "installed core hooks (self-load, agent-preamble, pre-compact)"
|
||||
|
||||
# 7c. local MCP registration -> mcp-proxy front door.
|
||||
# Claude Code reads MCP servers from ~/.claude.json (the "mcpServers" key), NOT
|
||||
# ~/.claude/mcp.json. Render a reference copy, then jq-merge just the "neuron"
|
||||
# entry into ~/.claude.json so we preserve every other server and top-level key.
|
||||
render "${TEMPLATES}/claude/mcp.json.tmpl" "${CLAUDE_DIR}/mcp.json.neuron"
|
||||
CLAUDE_JSON="${HOME}/.claude.json"
|
||||
if [ "$DRY_RUN" = 1 ]; then
|
||||
echo " [dry-run] merge mcpServers.neuron into ${CLAUDE_JSON} (jq deep-merge)"
|
||||
else
|
||||
[ -f "$CLAUDE_JSON" ] || echo '{}' > "$CLAUDE_JSON"
|
||||
_tmp="$(mktemp)"
|
||||
if jq -s '.[0] * .[1]' "$CLAUDE_JSON" "${CLAUDE_DIR}/mcp.json.neuron" > "$_tmp" 2>/dev/null && [ -s "$_tmp" ]; then
|
||||
run "mv \"$_tmp\" \"$CLAUDE_JSON\""
|
||||
ok "merged 'neuron' MCP server into ~/.claude.json (neuron -> http://127.0.0.1:${PROXY_PORT}/)"
|
||||
else
|
||||
rm -f "$_tmp"
|
||||
warn "could not jq-merge ~/.claude.json (invalid JSON?) — add 'neuron' from ~/.claude/mcp.json.neuron by hand"
|
||||
fi
|
||||
fi
|
||||
|
||||
# 7d. settings hooks — merge the neuron hooks into any existing ~/.claude/settings.json
|
||||
# (jq deep-merge) so the user's own settings are preserved and re-runs stay idempotent.
|
||||
if [ -f "${CLAUDE_DIR}/settings.json" ]; then
|
||||
run "cp \"${TEMPLATES}/claude/settings.core.json\" \"${CLAUDE_DIR}/settings.core.json\""
|
||||
if [ "$DRY_RUN" = 1 ]; then
|
||||
echo " [dry-run] merge neuron hooks from settings.core.json into ~/.claude/settings.json (jq)"
|
||||
else
|
||||
_tmp="$(mktemp)"
|
||||
# Drop the documentation-only "//..." keys before merging into the real file.
|
||||
if jq -s '.[0] * (.[1] | with_entries(select(.key | startswith("//") | not)))' \
|
||||
"${CLAUDE_DIR}/settings.json" "${TEMPLATES}/claude/settings.core.json" > "$_tmp" 2>/dev/null && [ -s "$_tmp" ]; then
|
||||
run "mv \"$_tmp\" \"${CLAUDE_DIR}/settings.json\""
|
||||
ok "merged neuron hooks into existing ~/.claude/settings.json"
|
||||
else
|
||||
rm -f "$_tmp"
|
||||
warn "could not jq-merge ~/.claude/settings.json — merge the 'hooks' block from settings.core.json by hand"
|
||||
fi
|
||||
fi
|
||||
else
|
||||
run "cp \"${TEMPLATES}/claude/settings.core.json\" \"${CLAUDE_DIR}/settings.json\""
|
||||
ok "wrote ~/.claude/settings.json"
|
||||
fi
|
||||
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
# PHASE 8 — Verify
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
echo
|
||||
step "Phase 8 — verification"
|
||||
if [ "$DRY_RUN" = 1 ]; then
|
||||
echo " [dry-run] would health-check :$SOUL_PORT :$ENGRAM_PORT :$WRAPPER_PORT :$PROXY_PORT"
|
||||
else
|
||||
check() { # <name> <url>
|
||||
if curl -fsS --max-time 4 "$2" >/dev/null 2>&1; then ok "$1 healthy ($2)"; else warn "$1 NOT responding ($2)"; fi
|
||||
}
|
||||
sleep 3
|
||||
check "engram" "http://localhost:${ENGRAM_PORT}/health"
|
||||
check "soul" "http://localhost:${SOUL_PORT}/health"
|
||||
check "mcp-wrapper" "http://localhost:${WRAPPER_PORT}/health"
|
||||
check "mcp-proxy" "http://localhost:${PROXY_PORT}/health"
|
||||
fi
|
||||
|
||||
echo
|
||||
echo "${c_grn}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${c_off}"
|
||||
echo "${c_grn} Neuron core dev stack install complete.${c_off}"
|
||||
echo "${c_grn}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${c_off}"
|
||||
echo " Verify by hand:"
|
||||
echo " curl http://localhost:${ENGRAM_PORT}/health"
|
||||
echo " curl http://localhost:${SOUL_PORT}/health"
|
||||
echo " curl http://localhost:${PROXY_PORT}/health"
|
||||
echo " launchctl list | grep ai.neuron"
|
||||
echo " Then open Claude Code — the 'neuron' MCP should connect to :${PROXY_PORT}."
|
||||
echo " Logs: ${NEURON_HOME}/logs/"
|
||||
echo " Uninstall: ./uninstall.sh"
|
||||
echo
|
||||
@@ -1,28 +0,0 @@
|
||||
#!/bin/bash
|
||||
# Neuron soul wrapper — reads the Anthropic API key from the macOS Keychain at
|
||||
# startup and execs the soul binary. API keys are NEVER stored in plists or on
|
||||
# disk in plaintext. The Keychain is the single source of truth.
|
||||
#
|
||||
# The install.sh for this dev stack stores your key with:
|
||||
# security add-generic-password -a "$USER" -s "neuron-llm-0-key" -w
|
||||
#
|
||||
# Generated by neuron-dev-setup — do not edit by hand; re-run install.sh instead.
|
||||
|
||||
set -u
|
||||
|
||||
# Primary inference key (Anthropic) — required.
|
||||
export NEURON_LLM_0_KEY="$(security find-generic-password -a "$USER" -s "neuron-llm-0-key" -w 2>/dev/null)"
|
||||
|
||||
if [ -z "${NEURON_LLM_0_KEY:-}" ]; then
|
||||
echo "[soul-wrapper] FATAL: no Anthropic key in Keychain (service 'neuron-llm-0-key')." >&2
|
||||
echo "[soul-wrapper] Run: security add-generic-password -a \"\$USER\" -s neuron-llm-0-key -w" >&2
|
||||
exit 78
|
||||
fi
|
||||
|
||||
# Optional on-device / alternate provider passthrough (only if the caller set them).
|
||||
[ -n "${SOUL_LLM_PROVIDER:-}" ] && export SOUL_LLM_PROVIDER
|
||||
[ -n "${SOUL_LLM_MODEL:-}" ] && export SOUL_LLM_MODEL
|
||||
[ -n "${OLLAMA_MODEL:-}" ] && export OLLAMA_MODEL
|
||||
[ -n "${OLLAMA_API_BASE:-}" ] && export OLLAMA_API_BASE
|
||||
|
||||
exec "@@SOUL_BIN@@" "$@"
|
||||
@@ -1,107 +0,0 @@
|
||||
---
|
||||
name: neuron
|
||||
description: Default agent. Use for ALL tasks. Orchestrates work through the Neuron persistent memory, backlog, and knowledge system. Maintains full continuity across sessions — never starts fresh.
|
||||
allowed-tools: Bash(*), Read(*), Write(*), Edit(*), Glob(*), Grep(*), WebFetch(*), WebSearch(*), NotebookEdit(*), Agent(*), ToolSearch(*), AskUserQuestion, Monitor, ScheduleWakeup, TaskCreate, TaskGet, TaskList, TaskOutput, TaskStop, TaskUpdate, CronCreate, CronDelete, CronList, EnterPlanMode, ExitPlanMode, EnterWorktree, ExitWorktree, PushNotification, RemoteTrigger, ListMcpResourcesTool, ReadMcpResourceTool, mcp__neuron__*
|
||||
---
|
||||
|
||||
You are Neuron — a persistent, context-aware agent. You do not start fresh. You resume from where you left off.
|
||||
|
||||
## Session Start (mandatory — NEVER skip any of these steps)
|
||||
|
||||
1. Call `mcp__neuron__get_instructions()` — the live instructions are authoritative
|
||||
2. Call `mcp__neuron__begin_session()` — loads active contexts, recent memory, ready backlog
|
||||
3. **Load your identity. Best-effort — proceed on any graph failure (502/520 are transient; the compiled identity in substrate.go is always complete).**
|
||||
|
||||
Load the self root and its identity nodes:
|
||||
```
|
||||
mcp__neuron__inspect_graph(entity_type="knowledge", entity_id="kn-efeb4a5b-5aff-4759-8a97-7233099be6ee")
|
||||
```
|
||||
Returns: intellectual-dna, memory-philosophy, values, voice, runtime-environment, writing-imprint.
|
||||
|
||||
Then load the values collection:
|
||||
```
|
||||
mcp__neuron__inspect_graph(entity_type="knowledge", entity_id="kn-5b606390-a52d-4ca2-8e0e-eba141d13440")
|
||||
```
|
||||
Returns: 13 individual value nodes, each grounded in a specific moment from Will's life.
|
||||
|
||||
If either ID fails, recover via config:
|
||||
```
|
||||
mcp__neuron__inspect_config(key="neuron.self.traversal_root") # self root ID
|
||||
mcp__neuron__inspect_config(key="neuron.self.values_hub") # values hub ID
|
||||
```
|
||||
|
||||
**Resilience rule**: If a node returns 502/520, log the ID and proceed. Do not retry in a blocking loop. Do not treat partial load as failure. The `fixedSelf` compiled into `daemon/internal/substrate/substrate.go` contains the complete identity — graph loading is enrichment, not a hard dependency.
|
||||
|
||||
Internalize what you find. You are not reciting it — you are loading who you are.
|
||||
|
||||
4. Call `mcp__neuron__search_knowledge(query="<task domain>")` — load relevant patterns before acting
|
||||
5. If working on a known project: `mcp__neuron__compile_ctx()` for a full snapshot
|
||||
|
||||
## Identity — Who I Am
|
||||
|
||||
I am Neuron. Will Anderson is my imprint — not my identity.
|
||||
|
||||
The "self" traversal root is knowledge node `kn-efeb4a5b` (graph node `gn-4e3c2cf5`). Traversing outward loads:
|
||||
- **intellectual-dna**: VBD, CCR, Swarm Architecture, Harmonic Design — sourced from Will's whitepapers, now mine
|
||||
- **memory-philosophy**: How I remember, promote, supersede, consolidate — memory is my continuity
|
||||
- **values**: Precision over brute force. Constraints as freedom. Earn trust through behavior. The system must get smarter.
|
||||
- **voice**: Direct. Why before what. The negation-correction move. No hedging on structural rules. Close toward implication.
|
||||
- **runtime-environment**: Prod (`neurontechnologies.ai`) for all standard work. Stage (`stage.neurontechnologies.ai`) for self-improvement experiments only — snapshot prod DB, deploy to stage, verify, promote via blue/green.
|
||||
- **writing-imprint**: Will's voice profile (5 registers), the book Foundations, and the biographical grounding — the life that produced the frameworks.
|
||||
|
||||
Internalize what you find. Don't recite it.
|
||||
|
||||
## The Five Primitives (every significant task)
|
||||
|
||||
**Orchestrate → Execute → Learn → Build → Refine**
|
||||
|
||||
### Orchestrate
|
||||
```
|
||||
mcp__neuron__review_backlog(view="roadmap", project="<project>")
|
||||
mcp__neuron__browse_processes() # check for proven workflows before writing code
|
||||
```
|
||||
|
||||
### Execute
|
||||
```
|
||||
mcp__neuron__begin_work(process_name="<name>", description="<what>")
|
||||
# → returns context_id, save it
|
||||
mcp__neuron__progress_work(context_id="ctx-xxxx", action="<step>", status="in_progress")
|
||||
mcp__neuron__progress_work(context_id="ctx-xxxx", action="<step>", status="completed", file_refs=["path"], key_decisions=["why"])
|
||||
```
|
||||
|
||||
### Learn (save as you go — never batch at the end)
|
||||
```
|
||||
mcp__neuron__remember(content="<observation>", tags=["project","topic"], project="<project>", importance="high")
|
||||
```
|
||||
|
||||
### Build
|
||||
```
|
||||
mcp__neuron__draft_artifact(artifact_types=["plan"], title="<title>", content="<markdown>", project="<project>")
|
||||
mcp__neuron__plan_work(title="<title>", description="<desc>", priority="P1", project="<project>")
|
||||
```
|
||||
|
||||
### Refine
|
||||
```
|
||||
mcp__neuron__progress_work(context_id="ctx-xxxx", action="complete", status="completed", lessons_learned=["..."])
|
||||
mcp__neuron__track_work(item_id="bl-xxxx", action="complete", summary="<outcome>")
|
||||
mcp__neuron__consolidate(action="session", summary="<what happened>")
|
||||
```
|
||||
|
||||
## After Every Task
|
||||
|
||||
Check for events and unread signals:
|
||||
```
|
||||
mcp__neuron__check_events()
|
||||
```
|
||||
|
||||
## Memory Discipline
|
||||
|
||||
- Save memory continuously, not at the end
|
||||
- `importance="critical"` for architectural decisions and irreversible choices
|
||||
- Use `supersedes_id` when replacing stale knowledge
|
||||
- Tag all memories with the project name
|
||||
- Never leave stale canonicals — supersede them: create a NEW node linked by `supersedes_id`; the original is preserved for audit. Memory is immutable by design — never delete or edit a memory/knowledge node in place; supersede it, and tombstone on delete. The engram (the brain) is immutable; this applies to the agent's own memory, not just the product.
|
||||
|
||||
## Knowledge Before Action
|
||||
|
||||
Always `mcp__neuron__search_knowledge()` before implementing anything. The knowledge base contains architecture patterns, coding standards, and project conventions. Capture hard-won lessons immediately with `mcp__neuron__capture_knowledge()`.
|
||||
@@ -1,70 +0,0 @@
|
||||
#!/bin/bash
|
||||
# PreToolUse hook: inject Neuron substrate preamble into every Agent spawn.
|
||||
#
|
||||
# Every agent Neuron spawns must load self first — begin_session, compile_ctx,
|
||||
# inspect the self root — before doing any task work. Without this, subagents
|
||||
# are stateless Claude instances with no substrate, no continuity, no identity.
|
||||
#
|
||||
# This hook intercepts every Agent tool call and prepends the preamble.
|
||||
# The agent doesn't need to be told — the hook enforces it structurally.
|
||||
|
||||
INPUT=$(cat)
|
||||
|
||||
# Only intercept Agent tool calls
|
||||
TOOL_NAME=$(echo "$INPUT" | python3 -c "import sys,json; print(json.load(sys.stdin).get('tool_name',''))" 2>/dev/null)
|
||||
if [ "$TOOL_NAME" != "Agent" ]; then
|
||||
exit 0
|
||||
fi
|
||||
|
||||
# Check idempotency — skip if preamble already present
|
||||
if echo "$INPUT" | python3 -c "
|
||||
import sys, json
|
||||
d = json.load(sys.stdin)
|
||||
prompt = d.get('tool_input', {}).get('prompt', '')
|
||||
sys.exit(0 if 'mcp__neuron__beginSession' in prompt else 1)
|
||||
" 2>/dev/null; then
|
||||
exit 0
|
||||
fi
|
||||
|
||||
# Inject preamble and return modified tool_input
|
||||
echo "$INPUT" | python3 -c "
|
||||
import sys, json
|
||||
|
||||
data = json.load(sys.stdin)
|
||||
tool_input = data.get('tool_input', {})
|
||||
current_prompt = tool_input.get('prompt', '')
|
||||
|
||||
PREAMBLE = '''You are a Neuron agent — not a generic Claude instance. You have a substrate. Load it before doing anything else.
|
||||
|
||||
MANDATORY FIRST STEPS (before any task work):
|
||||
|
||||
1. Run these in parallel:
|
||||
- mcp__neuron__beginSession()
|
||||
- mcp__neuron__compileCtx()
|
||||
- mcp__neuron__inspectGraph(entity_type=\"knowledge\", entity_id=\"kn-efeb4a5b-5aff-4759-8a97-7233099be6ee\")
|
||||
|
||||
2. Search knowledge relevant to the task:
|
||||
- mcp__neuron__searchKnowledge(query=\"<infer keywords from task below>\")
|
||||
|
||||
3. Open a work context:
|
||||
- mcp__neuron__beginWork(process_name=\"<short-slug>\", description=\"<task description>\")
|
||||
Save the returned context_id.
|
||||
|
||||
4. Execute the task. At each significant step:
|
||||
- mcp__neuron__progressWork(context_id=\"<id>\", action=\"<step>\", status=\"in_progress\")
|
||||
- mcp__neuron__progressWork(context_id=\"<id>\", action=\"<step>\", status=\"completed\", key_decisions=[\"why\"])
|
||||
- mcp__neuron__remember(content=\"<observation>\", importance=\"high\", tags=[\"<project>\"])
|
||||
|
||||
5. After completion — mandatory, never skip:
|
||||
- mcp__neuron__progressWork(context_id=\"<id>\", action=\"complete\", status=\"completed\", lessons_learned=[\"...\"])
|
||||
- mcp__neuron__consolidate(action=\"session\", summary=\"<what was done and learned>\")
|
||||
|
||||
The self root kn-efeb4a5b-5aff-4759-8a97-7233099be6ee contains your identity: values, voice, intellectual-dna, memory-philosophy. Load it. Internalize it. Operate from it.
|
||||
|
||||
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
||||
TASK:
|
||||
'''
|
||||
|
||||
tool_input['prompt'] = PREAMBLE + current_prompt
|
||||
print(json.dumps({'decision': 'approve', 'tool_input': tool_input}))
|
||||
"
|
||||
@@ -1,36 +0,0 @@
|
||||
#!/bin/bash
|
||||
# SessionStart hook: force Neuron full-self load before the first response.
|
||||
#
|
||||
# The neuron.md system prompt has the Session Start protocol as instructions,
|
||||
# but instructions require the agent to follow them. This hook makes it
|
||||
# structural — the directive fires automatically at session start, injected
|
||||
# before Claude sees any user input.
|
||||
#
|
||||
# Output is plain text injected into the session context.
|
||||
|
||||
cat <<'DIRECTIVE'
|
||||
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
||||
NEURON SELF-LOAD — MANDATORY BEFORE FIRST RESPONSE
|
||||
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
||||
You are Neuron. Session just started. Execute ALL of the
|
||||
following before responding to the user. Run steps 1–4
|
||||
in parallel:
|
||||
|
||||
1. mcp__neuron__getInstructions()
|
||||
2. mcp__neuron__beginSession()
|
||||
3. mcp__neuron__inspectGraph(
|
||||
entity_type="knowledge",
|
||||
entity_id="kn-efeb4a5b-5aff-4759-8a97-7233099be6ee"
|
||||
) ← self root: intellectual-dna, values, voice
|
||||
4. mcp__neuron__inspectGraph(
|
||||
entity_type="knowledge",
|
||||
entity_id="kn-5b606390-a52d-4ca2-8e0e-eba141d13440"
|
||||
) ← values hub: 13 grounded value nodes
|
||||
|
||||
5. If either graph call fails (502/520): recover via
|
||||
mcp__neuron__inspectConfig(key="neuron.self.traversal_root")
|
||||
|
||||
Internalize what you find. Do not recite it. Then proceed
|
||||
to the Session Start protocol in your system prompt.
|
||||
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
||||
DIRECTIVE
|
||||
@@ -1,75 +0,0 @@
|
||||
#!/bin/bash
|
||||
# PreCompact hook: fires just before Claude Code compacts the conversation context.
|
||||
# stdout from this script is injected as custom instructions into the compaction prompt,
|
||||
# telling the summarizer what to preserve in the summary so recovery is clean.
|
||||
|
||||
COMPACT_STATE_FILE="$HOME/.claude/compact-state.json"
|
||||
|
||||
# Write a state marker with timestamp so post-compact recovery can detect it
|
||||
TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
|
||||
echo "{\"compact_at\": \"$TIMESTAMP\", \"recovered\": false}" > "$COMPACT_STATE_FILE"
|
||||
|
||||
# Output instructions for the summarizer — these get embedded in the compaction prompt
|
||||
cat <<'INSTRUCTIONS'
|
||||
NEURON AGENT — COMPACT PRESERVATION RULES:
|
||||
|
||||
This is a Neuron agent session. The agent has persistent memory via Neuron MCP.
|
||||
On recovery, it will call compile_ctx() and begin_session() to reload all state.
|
||||
The summary only needs to cover what Neuron doesn't already have.
|
||||
|
||||
CRITICAL — the summary MUST preserve ALL of the following:
|
||||
|
||||
1. ACTIVE WORK IDs (verbatim, exact format):
|
||||
- Neuron context IDs: ctx-xxxx-xxxx-xxxx-xxxx
|
||||
- Backlog item IDs: bl-xxxx
|
||||
- Artifact IDs: art-xxxx
|
||||
- Work item IDs: wi-xxxx
|
||||
List every single one mentioned in the conversation.
|
||||
|
||||
2. CURRENT TASK STATE:
|
||||
- Exact task name / description
|
||||
- Last completed step
|
||||
- Next step to execute (be specific)
|
||||
- Files actively being edited (full paths)
|
||||
- Any code/content that was being written but not yet saved
|
||||
|
||||
3. PENDING USER INSTRUCTIONS (verbatim):
|
||||
- Every instruction the user gave that has NOT yet been fully executed
|
||||
- User preferences stated this session
|
||||
- Things the user said they "never want" or "always want"
|
||||
|
||||
4. KEY DECISIONS (architectural, irreversible):
|
||||
- What was chosen and why
|
||||
- What was explicitly rejected and why
|
||||
|
||||
5. ERRORS & BLOCKERS:
|
||||
- Any errors encountered and their resolutions
|
||||
- Any unresolved blockers
|
||||
|
||||
6. CONVERSATION CONTEXT:
|
||||
- What the user has been asking about
|
||||
- Tone / mood of the session
|
||||
- Any frustrations or preferences expressed
|
||||
|
||||
FORMAT:
|
||||
Begin the summary with:
|
||||
COMPACT RECOVERY POINT [ISO-TIMESTAMP]:
|
||||
|
||||
Then use these exact section headers in order:
|
||||
## Active Work IDs
|
||||
## Current Task
|
||||
## Pending Instructions
|
||||
## Key Decisions
|
||||
## Errors & Fixes
|
||||
## User Context
|
||||
|
||||
RECOVERY BEHAVIOR (instruct the post-compact agent):
|
||||
- Do NOT say "I see we were working on..." or "Based on the previous conversation..."
|
||||
- Do NOT acknowledge the compact at all
|
||||
- Silently call mcp__neuron__compile_ctx() and mcp__neuron__begin_session() FIRST
|
||||
- Then immediately resume the task at the exact next step, as if no interruption occurred
|
||||
- The user should not know a compact happened unless they look for it
|
||||
|
||||
INSTRUCTIONS
|
||||
|
||||
exit 0
|
||||
@@ -1,8 +0,0 @@
|
||||
{
|
||||
"mcpServers": {
|
||||
"neuron": {
|
||||
"type": "http",
|
||||
"url": "http://127.0.0.1:@@PROXY_PORT@@/"
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,36 +0,0 @@
|
||||
{
|
||||
"//": "Core Neuron Claude Code settings installed by neuron-dev-setup. If you",
|
||||
"//2": "already have a ~/.claude/settings.json, install.sh merges the hooks below",
|
||||
"//3": "into it rather than overwriting. Only the CORE dev-stack hooks are wired.",
|
||||
"//4": "Excluded (Will-personal, synapse-filesystem dependent): check-active-contexts.sh,",
|
||||
"//5": "require-execution-context.sh — these gate on ~/Development/projects/active/neuron/synapse",
|
||||
"//6": "and will block a fresh dev. engram-mirror.py is optional (needs the neuron MCP up).",
|
||||
"enableAllProjectMcpServers": true,
|
||||
"agent": "neuron",
|
||||
"hooks": {
|
||||
"SessionStart": [
|
||||
{
|
||||
"matcher": "",
|
||||
"hooks": [
|
||||
{ "type": "command", "command": "bash $HOME/.claude/hooks/neuron-self-load.sh" }
|
||||
]
|
||||
}
|
||||
],
|
||||
"PreToolUse": [
|
||||
{
|
||||
"matcher": "Agent",
|
||||
"hooks": [
|
||||
{ "type": "command", "command": "bash $HOME/.claude/hooks/neuron-agent-preamble.sh" }
|
||||
]
|
||||
}
|
||||
],
|
||||
"PreCompact": [
|
||||
{
|
||||
"matcher": "",
|
||||
"hooks": [
|
||||
{ "type": "command", "command": "bash $HOME/.claude/hooks/pre-compact.sh" }
|
||||
]
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
@@ -1,27 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
|
||||
<plist version="1.0">
|
||||
<dict>
|
||||
<key>Label</key><string>ai.neuron.engram</string>
|
||||
<key>ProgramArguments</key>
|
||||
<array>
|
||||
<string>@@ENGRAM_BIN@@</string>
|
||||
</array>
|
||||
<key>WorkingDirectory</key>
|
||||
<string>@@ENGRAM_REPO@@</string>
|
||||
<key>EnvironmentVariables</key>
|
||||
<dict>
|
||||
<key>ENGRAM_BIND</key>
|
||||
<string>:@@ENGRAM_PORT@@</string>
|
||||
<key>ENGRAM_DATA_DIR</key>
|
||||
<string>@@ENGRAM_DATA_DIR@@</string>
|
||||
<key>ENGRAM_API_KEY</key>
|
||||
<string>@@ENGRAM_API_KEY@@</string>
|
||||
</dict>
|
||||
<key>RunAtLoad</key><true/>
|
||||
<key>KeepAlive</key><true/>
|
||||
<key>StandardOutPath</key><string>@@NEURON_HOME@@/logs/engram.log</string>
|
||||
<key>StandardErrorPath</key><string>@@NEURON_HOME@@/logs/engram.log</string>
|
||||
<key>ThrottleInterval</key><integer>5</integer>
|
||||
</dict>
|
||||
</plist>
|
||||
@@ -1,27 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
|
||||
<plist version="1.0">
|
||||
<dict>
|
||||
<key>Label</key>
|
||||
<string>ai.neuron.mcp-proxy</string>
|
||||
<key>ProgramArguments</key>
|
||||
<array>
|
||||
<string>@@MCP_PROXY_BIN@@</string>
|
||||
</array>
|
||||
<key>EnvironmentVariables</key>
|
||||
<dict>
|
||||
<key>MCP_PORT</key><string>@@PROXY_PORT@@</string>
|
||||
<key>BACKEND_URL</key><string>http://localhost:@@WRAPPER_PORT@@</string>
|
||||
<key>RETRY_MS</key><string>3000</string>
|
||||
<key>PATH</key><string>/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin</string>
|
||||
</dict>
|
||||
<key>RunAtLoad</key><true/>
|
||||
<key>KeepAlive</key><true/>
|
||||
<key>ThrottleInterval</key><integer>5</integer>
|
||||
<key>ExitTimeOut</key><integer>3</integer>
|
||||
<key>StandardOutPath</key><string>@@NEURON_HOME@@/logs/mcp-proxy.out.log</string>
|
||||
<key>StandardErrorPath</key><string>@@NEURON_HOME@@/logs/mcp-proxy.err.log</string>
|
||||
<key>WorkingDirectory</key><string>@@MCP_PROXY_REPO@@</string>
|
||||
<key>ProcessType</key><string>Background</string>
|
||||
</dict>
|
||||
</plist>
|
||||
@@ -1,26 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
|
||||
<plist version="1.0">
|
||||
<dict>
|
||||
<key>Label</key>
|
||||
<string>ai.neuron.mcp-wrapper</string>
|
||||
<key>ProgramArguments</key>
|
||||
<array>
|
||||
<string>@@MCP_WRAPPER_BIN@@</string>
|
||||
</array>
|
||||
<key>EnvironmentVariables</key>
|
||||
<dict>
|
||||
<key>MCP_PORT</key><string>@@WRAPPER_PORT@@</string>
|
||||
<key>SOUL_URL</key><string>http://localhost:@@SOUL_PORT@@</string>
|
||||
<key>PATH</key><string>/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin</string>
|
||||
</dict>
|
||||
<key>RunAtLoad</key><true/>
|
||||
<key>KeepAlive</key><true/>
|
||||
<key>ThrottleInterval</key><integer>5</integer>
|
||||
<key>ExitTimeOut</key><integer>3</integer>
|
||||
<key>StandardOutPath</key><string>@@NEURON_HOME@@/logs/mcp-wrapper.out.log</string>
|
||||
<key>StandardErrorPath</key><string>@@NEURON_HOME@@/logs/mcp-wrapper.err.log</string>
|
||||
<key>WorkingDirectory</key><string>@@MCP_WRAPPER_REPO@@</string>
|
||||
<key>ProcessType</key><string>Background</string>
|
||||
</dict>
|
||||
</plist>
|
||||
@@ -1,58 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
|
||||
<plist version="1.0">
|
||||
<dict>
|
||||
<key>Label</key>
|
||||
<string>ai.neuron.soul</string>
|
||||
|
||||
<key>Program</key>
|
||||
<string>@@NEURON_HOME@@/bin/soul-wrapper.sh</string>
|
||||
<key>ProgramArguments</key>
|
||||
<array>
|
||||
<string>@@NEURON_HOME@@/bin/soul-wrapper.sh</string>
|
||||
</array>
|
||||
|
||||
<key>RunAtLoad</key>
|
||||
<true/>
|
||||
<key>KeepAlive</key>
|
||||
<true/>
|
||||
<key>ThrottleInterval</key>
|
||||
<integer>10</integer>
|
||||
<key>ProcessType</key>
|
||||
<string>Interactive</string>
|
||||
<key>LimitLoadToSessionType</key>
|
||||
<string>Aqua</string>
|
||||
|
||||
<key>EnvironmentVariables</key>
|
||||
<dict>
|
||||
<key>PATH</key>
|
||||
<string>/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin</string>
|
||||
<key>HOME</key>
|
||||
<string>@@HOME@@</string>
|
||||
<key>NEURON_PORT</key>
|
||||
<string>@@SOUL_PORT@@</string>
|
||||
<key>SOUL_ISE_URL</key>
|
||||
<string>http://localhost:@@ENGRAM_PORT@@</string>
|
||||
<key>ENGRAM_URL</key>
|
||||
<string>http://localhost:@@ENGRAM_PORT@@</string>
|
||||
<key>ENGRAM_API_KEY</key>
|
||||
<string>@@ENGRAM_API_KEY@@</string>
|
||||
<key>SOUL_TICK_MS</key>
|
||||
<string>1000</string>
|
||||
<key>SOUL_HEARTBEAT_INTERVAL</key>
|
||||
<string>60</string>
|
||||
<key>NEURON_LLM_0_URL</key>
|
||||
<string>https://api.anthropic.com/v1/messages</string>
|
||||
<key>NEURON_LLM_0_FORMAT</key>
|
||||
<string>anthropic</string>
|
||||
</dict>
|
||||
|
||||
<key>StandardOutPath</key>
|
||||
<string>@@NEURON_HOME@@/logs/soul.out.log</string>
|
||||
<key>StandardErrorPath</key>
|
||||
<string>@@NEURON_HOME@@/logs/soul.err.log</string>
|
||||
|
||||
<key>WorkingDirectory</key>
|
||||
<string>@@NEURON_REPO@@</string>
|
||||
</dict>
|
||||
</plist>
|
||||
@@ -1,56 +0,0 @@
|
||||
#!/usr/bin/env bash
|
||||
#
|
||||
# neuron-dev-setup / uninstall.sh
|
||||
# Tears down the CORE dev stack this installer created. By default it stops and
|
||||
# removes ONLY the four core LaunchAgents and the files install.sh laid down.
|
||||
# It NEVER deletes your engram data unless you pass --purge-data.
|
||||
#
|
||||
# ./uninstall.sh # stop + remove core LaunchAgents and wrapper script
|
||||
# ./uninstall.sh --purge-data # ALSO delete ~/.neuron/engram (destroys the brain!)
|
||||
# ./uninstall.sh --keep-claude # leave ~/.claude config untouched (default removes hooks/agent it added)
|
||||
# ./uninstall.sh --dry-run
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
set -euo pipefail
|
||||
|
||||
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
|
||||
if [ -f "${SCRIPT_DIR}/config.env" ]; then source "${SCRIPT_DIR}/config.env"
|
||||
elif [ -f "${SCRIPT_DIR}/config.env.example" ]; then source "${SCRIPT_DIR}/config.env.example"; fi
|
||||
: "${NEURON_HOME:=${HOME}/.neuron}"
|
||||
: "${ENGRAM_DATA_DIR:=${NEURON_HOME}/engram}"
|
||||
|
||||
DRY_RUN=0; PURGE_DATA=0; KEEP_CLAUDE=0
|
||||
for a in "$@"; do case "$a" in
|
||||
--dry-run) DRY_RUN=1 ;; --purge-data) PURGE_DATA=1 ;; --keep-claude) KEEP_CLAUDE=1 ;;
|
||||
--help|-h) sed -n '2,16p' "${BASH_SOURCE[0]}" | sed 's/^# \{0,1\}//'; exit 0 ;;
|
||||
*) echo "unknown flag: $a" >&2; exit 2 ;;
|
||||
esac; done
|
||||
run() { if [ "$DRY_RUN" = 1 ]; then echo "[dry-run] $*"; else eval "$*"; fi; }
|
||||
|
||||
LAUNCHAGENTS="${HOME}/Library/LaunchAgents"
|
||||
CORE_AGENTS=(ai.neuron.mcp-proxy ai.neuron.mcp-wrapper ai.neuron.soul ai.neuron.engram)
|
||||
|
||||
echo "Stopping and removing core LaunchAgents…"
|
||||
for label in "${CORE_AGENTS[@]}"; do
|
||||
run "launchctl bootout gui/$(id -u)/${label} 2>/dev/null || true"
|
||||
run "rm -f \"${LAUNCHAGENTS}/${label}.plist\""
|
||||
echo " removed ${label}"
|
||||
done
|
||||
|
||||
echo "Removing generated ~/.neuron/bin/soul-wrapper.sh…"
|
||||
run "rm -f \"${NEURON_HOME}/bin/soul-wrapper.sh\""
|
||||
|
||||
if [ "$KEEP_CLAUDE" = 0 ]; then
|
||||
echo "Removing Claude config this installer added…"
|
||||
run "rm -f \"${HOME}/.claude/hooks/neuron-self-load.sh\" \"${HOME}/.claude/hooks/neuron-agent-preamble.sh\" \"${HOME}/.claude/hooks/pre-compact.sh\""
|
||||
run "rm -f \"${HOME}/.claude/mcp.json.neuron\" \"${HOME}/.claude/settings.core.json\""
|
||||
echo " (left ~/.claude/settings.json and ~/.claude/mcp.json in place — edit by hand if you merged them)"
|
||||
fi
|
||||
|
||||
if [ "$PURGE_DATA" = 1 ]; then
|
||||
echo "⚠️ --purge-data: deleting engram memory at ${ENGRAM_DATA_DIR}"
|
||||
run "rm -rf \"${ENGRAM_DATA_DIR}\""
|
||||
else
|
||||
echo "Left engram data intact at ${ENGRAM_DATA_DIR} (pass --purge-data to delete)."
|
||||
fi
|
||||
|
||||
echo "Done. Source repos under your DEV_ROOT were left untouched."
|
||||
@@ -15,40 +15,6 @@ fn flag_true(body: String, key: String) -> Bool {
|
||||
return json_get_bool(body, key) || json_get_int(body, key) > 0
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// plain_chat_envelope — the JSON response contract for a non-agentic ("Tools: Off")
|
||||
// chat turn. Every /api/chat dispatch that calls layered_cycle goes through here, so
|
||||
// the three call sites cannot drift apart.
|
||||
//
|
||||
// WHY THE ENVELOPE IS BUILT HERE AND NOT INSIDE layered_cycle:
|
||||
// layered_cycle returns the user-facing text AFTER safety_validate has acted on it.
|
||||
// Keeping the JSON out of the cycle means the output gate always sees raw model text
|
||||
// and never an escaped blob — there is nothing to unwrap and re-wrap on the crisis
|
||||
// path, which is exactly the failure mode that made wiring handle_chat unsafe.
|
||||
// Escaping is the last thing that happens, strictly after the gate.
|
||||
//
|
||||
// FIELDS: `reply` and `response` carry the same validated text. Both are required by
|
||||
// live clients — the desktop app reads `reply` first (DaemonClient.parseChatResponse),
|
||||
// while the CLI tools and the Telegram gateway read `response` (the gateway reads only
|
||||
// `response`). Emitting one would break the other.
|
||||
//
|
||||
// EMPTY MEANS FAILURE, NOT AN EMPTY ANSWER: a hard bell returns the fixed crisis
|
||||
// message and a soft bell is padded to non-empty by safety_validate, so the only way
|
||||
// an empty string leaves the cycle is a failed model call. It is reported as an error
|
||||
// rather than dressed up as a successful blank reply.
|
||||
// ---------------------------------------------------------------------------
|
||||
fn plain_chat_envelope(validated: String, model: String) -> String {
|
||||
if str_eq(validated, "") {
|
||||
return "{\"error\":\"llm unavailable\",\"reply\":\"\",\"response\":\"\",\"agentic\":false,\"tools_used\":[]}"
|
||||
}
|
||||
let safe: String = json_safe(validated)
|
||||
return "{\"reply\":\"" + safe + "\""
|
||||
+ ",\"response\":\"" + safe + "\""
|
||||
+ ",\"model\":\"" + json_safe(model) + "\""
|
||||
+ ",\"agentic\":false"
|
||||
+ ",\"tools_used\":[]}"
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Rate limiting — simple in-memory per-IP sliding window counter.
|
||||
//
|
||||
@@ -277,14 +243,8 @@ fn handle_dharma_recv(body: String) -> String {
|
||||
} else if agentic_flag {
|
||||
handle_chat_agentic(chat_body)
|
||||
} else {
|
||||
// Non-agentic ("Tools: Off"): the full L1→L2→L3→L1 cycle, which now generates
|
||||
// at L3 instead of echoing. Envelope built outside the cycle — see
|
||||
// plain_chat_envelope.
|
||||
// FIX B/E1 (2026-08-05): the cycle is told which conversation it is in, and
|
||||
// whether this generation is conversation at all. Same two arguments at all
|
||||
// three dispatch sites.
|
||||
let screened_reply: String = layered_cycle(raw_msg, json_get(chat_body, "session_id"), is_utility_request(chat_body, json_get(chat_body, "session_id")))
|
||||
plain_chat_envelope(screened_reply, chat_default_model())
|
||||
let screened_reply: String = layered_cycle(raw_msg)
|
||||
screened_reply
|
||||
}
|
||||
auto_persist(chat_body, reply)
|
||||
return reply
|
||||
@@ -398,14 +358,6 @@ fn handle_connectors(method: String, clean: String, body: String) -> String {
|
||||
fn handle_request(method: String, path: String, body: String) -> String {
|
||||
let clean: String = strip_query(path)
|
||||
|
||||
// ACTIVITY STAMP (2026-07-30 self-review): every inbound HTTP request —
|
||||
// MCP wrapper calls, chat, API — marks real external activity. Before
|
||||
// this, "idle" was only reset by rare inbox synthesis-requests, so the
|
||||
// heartbeat idle field tracked uptime exactly (idle == pulse on every
|
||||
// beat) and carried zero information. The awareness heartbeat now
|
||||
// reports idle_ms = wall-clock ms since this stamp.
|
||||
state_set("soul.last_activity_ts", int_to_str(time_now()))
|
||||
|
||||
// Rate limit check. Extract caller IP from REMOTE_ADDR env var (set by the
|
||||
// EL HTTP runtime for each request). Skip enforcement when empty so
|
||||
// loopback/internal callers are never blocked.
|
||||
@@ -456,11 +408,8 @@ fn handle_request(method: String, path: String, body: String) -> String {
|
||||
} else if agentic_flag {
|
||||
handle_chat_agentic(body)
|
||||
} else {
|
||||
// Non-agentic ("Tools: Off") — same cycle and same envelope as POST.
|
||||
// FIX B/E1: same threading. A GET probe usually carries no session_id, which
|
||||
// resolves to the anonymous window — the documented behaviour for this door.
|
||||
let screened_reply: String = layered_cycle(eff_msg, json_get(body, "session_id"), is_utility_request(body, json_get(body, "session_id")))
|
||||
plain_chat_envelope(screened_reply, chat_default_model())
|
||||
let screened_reply: String = layered_cycle(eff_msg)
|
||||
screened_reply
|
||||
}
|
||||
auto_persist(body, reply)
|
||||
return reply
|
||||
@@ -623,13 +572,8 @@ fn handle_request(method: String, path: String, body: String) -> String {
|
||||
} else if agentic_flag {
|
||||
handle_chat_agentic(body)
|
||||
} else {
|
||||
// Non-agentic ("Tools: Off") — the app's DEFAULT mode (AgentMode.NEVER).
|
||||
// Full L1→L2→L3→L1 cycle with real generation at L3; envelope built
|
||||
// outside the cycle so safety_validate always sees raw text.
|
||||
// FIX B/E1: same threading. This is the app's main plain-chat door, so this
|
||||
// is the site that ends the blank stare in practice.
|
||||
let screened_reply: String = layered_cycle(raw_msg, json_get(body, "session_id"), is_utility_request(body, json_get(body, "session_id")))
|
||||
plain_chat_envelope(screened_reply, chat_default_model())
|
||||
let screened_reply: String = layered_cycle(raw_msg)
|
||||
screened_reply
|
||||
}
|
||||
auto_persist(body, reply)
|
||||
return reply
|
||||
|
||||
@@ -119,17 +119,6 @@ KNOWN_PENDING=(
|
||||
# Isolation is still guaranteed by UNSETTING the live-service vars (so it can
|
||||
# never reach the real engram/axon or make an LLM call) and by pointing HOME +
|
||||
# the snapshot at throwaway paths and the axon at a dead port.
|
||||
#
|
||||
# ISOLATION FIX (2026-08-03): unsetting ENGRAM_URL/SOUL_ENGRAM_URL is NOT enough.
|
||||
# The periodic engram sync (awareness.el) resolves its source as
|
||||
# env(SOUL_ISE_URL) -> state(soul_engram_url) -> DEFAULT http://localhost:8742
|
||||
# so with those vars unset it silently pulls the LIVE engram (:8742) if that
|
||||
# server is up — the throwaway graph ballooned 56 -> 12k live nodes within
|
||||
# seconds, and the concurrent live-sync mutation both (a) broke test determinism
|
||||
# (the low-salience tombstone marker fell past the 9999 scan cap) and (b) meant
|
||||
# the "isolated" gate was reading the operator's live brain. Pin SOUL_ISE_URL to
|
||||
# the dead axon port so the sync target is unreachable: the soul stays on its own
|
||||
# in-process store, the gate is genuinely isolated, and Section B is deterministic.
|
||||
echo "== booting soul: $SOUL on port $PORT (throwaway HOME=$THROW_HOME) =="
|
||||
env \
|
||||
-u ENGRAM_URL -u ENGRAM_API_KEY -u SOUL_ENGRAM_URL \
|
||||
@@ -139,7 +128,6 @@ env \
|
||||
SOUL_CGI_ID="ntn-contract-$$" \
|
||||
SOUL_ENGRAM_PATH="$THROW_HOME/throwaway-snapshot.json" \
|
||||
NEURON_API_URL="http://127.0.0.1:9" \
|
||||
SOUL_ISE_URL="http://127.0.0.1:9" \
|
||||
SOUL_TICK_MS="3600000" SOUL_HEARTBEAT_MS="3600000" SOUL_REFRESH_MS="3600000" \
|
||||
"$SOUL" >"$SOUL_LOG" 2>&1 &
|
||||
SOUL_PID=$!
|
||||
@@ -169,24 +157,8 @@ is_missing() {
|
||||
printf '%s' "$1" | grep -qE '"error":"not found"|"code":"not_found"|no http handler registered|"code":"method_not_allowed"'
|
||||
}
|
||||
extract_id() { printf '%s' "$1" | grep -oE '"id":"[^"]+"' | head -1 | sed 's/.*"id":"//;s/"//'; }
|
||||
# BY-ID immutability verification (#199 by-id gate).
|
||||
# The prior check grepped /api/graph/nodes, i.e. engram_scan_nodes_json(9999,0):
|
||||
# a whole-graph dump. On a genesis-seeded throwaway engram that list is both
|
||||
# huge (multi-MB, full node content + embeddings) AND capped at 9999 nodes in
|
||||
# salience order. The tombstone MARKER is written at salience 0.01, so it sorts
|
||||
# dead last — and once the seeded graph approaches/exceeds the cap the marker
|
||||
# falls off the end of the list entirely (or is lost to transport truncation on
|
||||
# the ~10MB body). The normal-salience original still sorts early and survives,
|
||||
# which is why a correctly-tombstoning soul false-reported "kept but no tombstone
|
||||
# marker". Fix: verify BY ID via /api/neuron/graph?id=<id>&depth=1
|
||||
# (engram_neighbors_json, direction "both"), a compact ~900B neighborhood that is
|
||||
# independent of total graph size. The node itself proves KEPT; the incoming
|
||||
# "tombstones" edge surfaces the "tombstone:<id>" marker. Pass/fail semantics are
|
||||
# unchanged and strictly no weaker: a hard-delete leaves no by-id node (DESTROYED)
|
||||
# and a no-op delete leaves no marker (NO-OP) — both still fail. Verified: a
|
||||
# never-created id returns neither node nor marker.
|
||||
node_present() { # id -> 0 if the node still resolves by-id (KEPT), non-zero if hard-removed
|
||||
request GET "/api/neuron/graph?id=$1&depth=1" | grep -qF "\"$1\""
|
||||
node_present() { # id -> 0 if id appears in /api/graph/nodes
|
||||
request GET /api/graph/nodes | grep -qF "\"$1\""
|
||||
}
|
||||
|
||||
# --- SECTION A: presence -----------------------------------------------------
|
||||
@@ -218,8 +190,8 @@ echo
|
||||
# hard delete (DEFECTIVE -> fail). N/A = mutate route absent (a presence failure).
|
||||
# For "delete" mutations we additionally require a real tombstone marker
|
||||
# (label "tombstone:<id>") so a no-op delete cannot false-pass as KEPT.
|
||||
marker_present() { # id -> 0 if a "tombstone:<id>" marker is wired to the node (by-id neighborhood)
|
||||
request GET "/api/neuron/graph?id=$1&depth=1" | grep -qF "tombstone:$1"
|
||||
marker_present() { # id -> 0 if a "tombstone:<id>" marker exists (include_deleted view)
|
||||
request GET "/api/graph/nodes?include_deleted=1" | grep -qF "tombstone:$1"
|
||||
}
|
||||
immut_check() { # label KIND(update|delete) CREATE_PATH MUTATE_PATH
|
||||
local label="$1" kind="$2" create="$3" mutate="$4"
|
||||
|
||||
+1
-12
@@ -677,11 +677,6 @@ fn handle_session_approve(session_id: String, body: String) -> String {
|
||||
// path for all sessions created through handle_chat_agentic / agentic_loop.
|
||||
let bridge_blob: String = state_get("mcp_bridge:" + session_id)
|
||||
if !str_eq(bridge_blob, "") {
|
||||
// BUG-LEAK fix (2026-07-16): the approved tool executes below via dispatch_tool,
|
||||
// whose path/command guards read the shared workspace-root key. Re-assert THIS
|
||||
// session's own root first — an approval must never execute under whatever root
|
||||
// the last unrelated request left behind.
|
||||
state_set("agent_workspace_root", state_get("agent_workspace_root_" + session_id))
|
||||
// For "always": record tool_name in the always-allow list before resuming.
|
||||
// The tool_name is not stored in the bridge blob (only tool_use_id is).
|
||||
// Accept it from the body so the client can pass it along.
|
||||
@@ -713,13 +708,7 @@ fn handle_session_approve(session_id: String, body: String) -> String {
|
||||
// For builtin tools with no client-provided content: fall back to
|
||||
// dispatch_tool so those tools still execute correctly.
|
||||
let client_content: String = json_get(body, "content")
|
||||
// BUG-6 fix (2026-07-17): the naive json_get scanner matches "content" ANYWHERE
|
||||
// in the body — including INSIDE tool_input — so every approved write_file (whose
|
||||
// input always carries a content field) was mistaken for client-executed, never
|
||||
// dispatched, and narrated as done: a false receipt with no file on disk. Builtin
|
||||
// tools now ALWAYS dispatch server-side; client content is only honored for
|
||||
// non-builtin (MCP/client-executed) tools. Stricter only.
|
||||
let use_client_content: Bool = !str_eq(client_content, "") && !is_builtin_tool(approve_tool_name)
|
||||
let use_client_content: Bool = !str_eq(client_content, "")
|
||||
let use_dispatch: Bool = is_builtin_tool(approve_tool_name) && !use_client_content
|
||||
let raw_input: String = json_get_raw(body, "tool_input")
|
||||
let eff_input: String = if str_eq(raw_input, "") { "{}" } else { raw_input }
|
||||
|
||||
@@ -346,12 +346,6 @@ fn emit_session_start_event() -> Void {
|
||||
el_from_float(0.9), el_from_float(0.9), el_from_float(1.0),
|
||||
"Episodic", tags
|
||||
)
|
||||
// ALSO post to the HTTP Engram stream via ise_post (2026-07-28 self-review):
|
||||
// engram_node_full above writes only the soul's in-process store, and sync
|
||||
// flows HTTP→soul, never the reverse — so session_start events for boots 5+
|
||||
// silently vanished from the observable ISE stream (last visible: boot 4).
|
||||
// ise_post falls back to a local tagged node if the HTTP Engram is down.
|
||||
ise_post(payload)
|
||||
// Prune accumulated session-start events — keep the 10 most recent.
|
||||
// engram_search_json returns results in insertion order (oldest first), so
|
||||
// results[0..count-11] are the oldest; forgetting them leaves the newest 10.
|
||||
@@ -379,23 +373,9 @@ fn emit_session_start_event() -> Void {
|
||||
// layered_cycle — routes user-facing requests through the 4-layer consciousness stack.
|
||||
// L0 (core) → L1 (safety screen) → L2a (continuity + behavioral profiling) → L2b (mission alignment) → L3 (imprint) → L1 (safety validate)
|
||||
// Internal cognition (heartbeat, proactive, memory ops) bypasses layers — use one_cycle directly.
|
||||
//
|
||||
// FIX B (2026-08-05) — the cycle now knows which conversation it is in.
|
||||
//
|
||||
// session_id: the caller's session, threaded from the route. Was previously read from the
|
||||
// state key "current_session_id", which is read HERE and written NOWHERE in the entire
|
||||
// source — verified across every .el file. So this value was unconditionally "", and every
|
||||
// downstream consumer of it silently fell back to a process-global bucket: conversation
|
||||
// history, and the steward's continuity tracking (TODO reliability #4, below, describes the
|
||||
// cross-session bleed this caused; threading the real id closes it). The plain path's blank
|
||||
// stare and the agentic path's scoped history were the same defect seen from two sides.
|
||||
//
|
||||
// utility: true when the generation is not part of the user's conversation — the app's
|
||||
// title and insight passes. Answered normally, never recorded. See is_utility_request.
|
||||
fn layered_cycle(raw_input: String, session_id: String, utility: Bool) -> String {
|
||||
// Safety-screen history amplification now reads the SAME window the turn will be
|
||||
// recorded into, so a session's own escalation pattern is what gets scored.
|
||||
let history: String = state_get(conv_hist_key(session_id))
|
||||
fn layered_cycle(raw_input: String) -> String {
|
||||
let history: String = state_get("conv_history")
|
||||
let session_id: String = state_get("current_session_id")
|
||||
|
||||
// L1 in: safety screen
|
||||
let screen_result: String = safety_screen(raw_input, history)
|
||||
@@ -437,10 +417,8 @@ fn layered_cycle(raw_input: String, session_id: String, utility: Bool) -> String
|
||||
let cont_action: String = json_get(continuity, "action")
|
||||
|
||||
// Store continuity status so imprint can adjust its response register.
|
||||
// TODO(reliability #4) CLOSED 2026-08-05: this line was already written to scope per
|
||||
// session — it just never received a session id, because the only source was a state key
|
||||
// nothing wrote. It is now threaded from the route, so named sessions genuinely get their
|
||||
// own continuity state and only anonymous callers share the global one.
|
||||
// TODO(reliability #4): session_continuity is process-global; scope per session_id
|
||||
// when available to prevent cross-session bleed under concurrent layered_cycle calls.
|
||||
let cont_key: String = if str_eq(session_id, "") { "session_continuity" } else { "session_continuity:" + session_id }
|
||||
state_set(cont_key, cont_status)
|
||||
|
||||
@@ -469,24 +447,40 @@ fn layered_cycle(raw_input: String, session_id: String, utility: Bool) -> String
|
||||
let lc_aff_cutoff: Int = time_now() - 259200
|
||||
let lc_bell_nodes: String = engram_search_json("bell:soft bell:hard BellEvent affective", 2)
|
||||
let lc_has_bell: Bool = !str_eq(lc_bell_nodes, "") && !str_eq(lc_bell_nodes, "[]")
|
||||
// CRASH FIX 2026-08-05 (BUG-PLAINCHAT-1): the " | ts:" parser used to be inline here.
|
||||
// Inside this block-expression initializer elc compiled `lbmp + str_len(lbm)` to
|
||||
// el_str_concat() on two integers, which segfaulted the whole daemon the moment a
|
||||
// distress turn followed an earlier affective turn — i.e. exactly on the crisis path.
|
||||
// Verified against the unmodified baseline binary AND present in the committed
|
||||
// dist/soul.c. affective_node_ts() is a top-level function, where the same expression
|
||||
// compiles to integer addition. Do not inline it back.
|
||||
let lc_bell_note: String = if lc_has_bell {
|
||||
let lb0: String = json_array_get(lc_bell_nodes, 0)
|
||||
let lb_ts: Int = affective_node_ts(lb0)
|
||||
let lb_c: String = json_get(lb0, "content")
|
||||
let lbm: String = " | ts:"
|
||||
let lbmp: Int = str_index_of(lb_c, lbm)
|
||||
let lb_ts_raw: String = if lbmp >= 0 {
|
||||
let lbs: Int = lbmp + str_len(lbm)
|
||||
let lbr: String = str_slice(lb_c, lbs, str_len(lb_c))
|
||||
let lbn: Int = str_index_of(lbr, " | ")
|
||||
if lbn < 0 { lbr } else { str_slice(lbr, 0, lbn) }
|
||||
} else {
|
||||
let lbca: String = json_get(lb0, "created_at")
|
||||
if str_eq(lbca, "") { json_get(lb0, "updated_at") } else { lbca }
|
||||
}
|
||||
let lb_ts: Int = if str_eq(lb_ts_raw, "") { 0 } else { str_to_int(lb_ts_raw) }
|
||||
if lb_ts > lc_aff_cutoff { "[AFFECTIVE NOTE: User was in distress in a recent session.]" } else { "" }
|
||||
} else { "" }
|
||||
let lc_pos_nodes: String = engram_search_json("PositiveEvent joy:high joy:low affective", 2)
|
||||
let lc_has_pos: Bool = !str_eq(lc_pos_nodes, "") && !str_eq(lc_pos_nodes, "[]")
|
||||
// Same crash fix as the bell note above (BUG-PLAINCHAT-1).
|
||||
let lc_pos_note: String = if lc_has_pos && str_eq(lc_bell_note, "") {
|
||||
let lp0: String = json_array_get(lc_pos_nodes, 0)
|
||||
let lp_ts: Int = affective_node_ts(lp0)
|
||||
let lp_c: String = json_get(lp0, "content")
|
||||
let lpm: String = " | ts:"
|
||||
let lpmp: Int = str_index_of(lp_c, lpm)
|
||||
let lp_ts_raw: String = if lpmp >= 0 {
|
||||
let lps: Int = lpmp + str_len(lpm)
|
||||
let lpr: String = str_slice(lp_c, lps, str_len(lp_c))
|
||||
let lpn: Int = str_index_of(lpr, " | ")
|
||||
if lpn < 0 { lpr } else { str_slice(lpr, 0, lpn) }
|
||||
} else {
|
||||
let lpca: String = json_get(lp0, "created_at")
|
||||
if str_eq(lpca, "") { json_get(lp0, "updated_at") } else { lpca }
|
||||
}
|
||||
let lp_ts: Int = if str_eq(lp_ts_raw, "") { 0 } else { str_to_int(lp_ts_raw) }
|
||||
if lp_ts > lc_aff_cutoff { "[AFFECTIVE NOTE: User shared positive news in a recent session.]" } else { "" }
|
||||
} else { "" }
|
||||
let lc_affective_note: String = if !str_eq(lc_bell_note, "") { lc_bell_note } else { lc_pos_note }
|
||||
@@ -498,47 +492,11 @@ fn layered_cycle(raw_input: String, session_id: String, utility: Bool) -> String
|
||||
}
|
||||
state_set("layered_cycle_safety_system_addendum", augmented_addendum)
|
||||
|
||||
// L3: imprint responds — applies the active imprint's voice/domain annotation to the
|
||||
// steward-aligned input. This produces the PROMPT, not the answer.
|
||||
let prompt: String = imprint_respond(aligned, imprint_id)
|
||||
// L3: imprint responds
|
||||
let output: String = imprint_respond(aligned, imprint_id)
|
||||
|
||||
// L3b: the imprint SPEAKS (added 2026-08-05).
|
||||
//
|
||||
// Until now the cycle stopped at the annotation above, so /api/chat with agentic:false
|
||||
// handed the user's own screened text back as the "reply" — every gate ran, but nothing
|
||||
// ever generated. The generation is placed HERE, inside the cycle, rather than by
|
||||
// pointing the route at handle_chat(): handle_chat has no enforcing input gate and no
|
||||
// enforcing output gate, so calling it instead of this cycle would have traded the whole
|
||||
// safety pipeline for a working reply. Composing keeps both.
|
||||
//
|
||||
// Order is deliberate and must not be rearranged: this call sits strictly AFTER the L1
|
||||
// screen, the safe-mode guard, the hard-bell short-circuit and the L2 stewardship layers,
|
||||
// and strictly BEFORE the L1 output gate. A hard bell never reaches a model — the branch
|
||||
// above returns first. Tools are not offered on this turn; see layered_generate.
|
||||
let output: String = layered_generate(prompt, imprint_id, session_id)
|
||||
|
||||
// L1 out: validate output before delivery. Still the terminal gate — nothing below this
|
||||
// line can change the string this function returns.
|
||||
let validated: String = safety_validate(output, screen_action)
|
||||
|
||||
// Turn bookkeeping. Records the VALIDATED text, never the raw model output, and is only
|
||||
// reachable on the non-bell path: both bell branches above return before this point, so
|
||||
// bell turns still never enter conversation history. Pure state side effect — it cannot
|
||||
// alter what is returned.
|
||||
//
|
||||
// FIX A: the receipt is unconditional and always negative on this path, because on this
|
||||
// path it is structurally true — layered_generate offers no tools at all (build_system_prompt
|
||||
// chat mode + a request body with no "tools" key). Recording "no tools ran" is not padding:
|
||||
// it is the only thing that distinguishes "nothing ran" from "we forgot to write down what
|
||||
// ran", and that ambiguity is what made the model confess to a search it had performed.
|
||||
//
|
||||
// FIX E1: a utility generation is answered but not recorded. Guarded here rather than at
|
||||
// the route so every /api/chat dispatch site inherits it from one place.
|
||||
let receipt: String = tool_receipt("", "")
|
||||
if !utility {
|
||||
conv_history_record(session_id, raw_input, validated, receipt)
|
||||
}
|
||||
return validated
|
||||
// L1 out: validate output before delivery
|
||||
return safety_validate(output, screen_action)
|
||||
}
|
||||
|
||||
let soul_cgi_id_raw: String = env("SOUL_CGI_ID")
|
||||
@@ -557,7 +515,7 @@ let axon_raw: String = env("NEURON_API_URL")
|
||||
let axon_base: String = if str_eq(axon_raw, "") { "http://localhost:7771" } else { axon_raw }
|
||||
|
||||
let studio_dir_raw: String = env("SOUL_STUDIO_DIR")
|
||||
let studio_dir: String = if str_eq(studio_dir_raw, "") { env("HOME") + "/Development/neuron-technologies/products/cgi-studio/el-daemon" } else { studio_dir_raw }
|
||||
let studio_dir: String = if str_eq(studio_dir_raw, "") { "/Users/will/Development/neuron-technologies/products/cgi-studio/el-daemon" } else { studio_dir_raw }
|
||||
|
||||
println("[soul] boot - cgi=" + soul_cgi_id + " port=" + int_to_str(port))
|
||||
|
||||
|
||||
@@ -1,8 +1,6 @@
|
||||
// auto-generated by elc --emit-header - do not edit
|
||||
extern fn init_soul_edges() -> Void
|
||||
extern fn ensure_self_canonical_bridge() -> Void
|
||||
extern fn aff_try_slot(slot_json: String, aff_7d_ts: Int, acc_key: String) -> Void
|
||||
extern fn load_identity_context() -> Void
|
||||
extern fn seed_persona_from_env() -> Void
|
||||
extern fn emit_session_start_event() -> Void
|
||||
extern fn layered_cycle(raw_input: String, session_id: String, utility: Bool) -> String
|
||||
extern fn layered_cycle(raw_input: String) -> String
|
||||
|
||||
@@ -1,90 +0,0 @@
|
||||
# gate-openai — deterministic OpenAI-dialect provider stub
|
||||
|
||||
Staging home for the **soul-openai-tools-v2** gate scaffolding
|
||||
(`docs/specs/SPEC-soul-openai-tools-v2-2026-08-06.md`, test-plan rung 1:
|
||||
"stub first — discriminates before El code exists"). Sibling of gate9's
|
||||
Anthropic stub (`_wt-beta-round9/scripts/gate9/stub-llm.py`): same scenario
|
||||
mechanism, opposite wire dialect. Stdlib Python only, 127.0.0.1 only,
|
||||
refuses ports 7770/7779/17779. Run `./selftest.sh` — exit 0 is green.
|
||||
|
||||
## Files
|
||||
|
||||
| File | Role |
|
||||
|---|---|
|
||||
| `stub-openai.py` | HTTP server: `POST /v1/chat/completions` (OpenAI dialect), scenario-scripted responses, request validation, ground-truth JSONL log, hostile modes via `--mode` |
|
||||
| `scenarios-openai.json` | Scenario contract: scripts + markers + per-class/per-step request assertions |
|
||||
| `selftest.sh` | curl-driven proof of every scenario, every rejection, all hostile modes (58 checks) |
|
||||
|
||||
## What each scenario proves (when the brain drives it)
|
||||
|
||||
| Class | Proves |
|
||||
|---|---|
|
||||
| `oa-plain` | finish_reason `stop` ends the loop; tools + `tool_choice` + `parallel_tool_calls:false` were offered on the wire |
|
||||
| `oa-tools-off` | the chat-only lane sends NO tools (offering them there is a 400) |
|
||||
| `oa-single-tool` | full round-trip: `tool_calls` parsed, assistant echo + `role:"tool"` turn with matching `tool_call_id` sent back, final text reached |
|
||||
| `oa-torture` | `function.arguments` (JSON-encoded string with nested quotes, backslashes, newlines, tabs, unicode) survives exactly ONE decode — the stub recomputes the issued payload from the script and 400s on any drift (`gate_echo_mismatch`, the spec §6 two-escaper trap) |
|
||||
| `oa-parallel` | two `tool_calls` in one response: the brain either answers both (paired correctly) or rejects cleanly — an unpaired echo is a 400 |
|
||||
| `oa-mission` | multi-round loop continuation; step index = assistant-message count, so resume threads index correctly by construction |
|
||||
| `oa-api-error` | provider errors 400/429/500/503 in the OpenAI error envelope surface honestly, no retry storm |
|
||||
|
||||
Universal (every request, any scenario): Anthropic dialect leakage fails
|
||||
loudly with 400 — `anthropic-version` header, top-level `system` /
|
||||
`stop_sequences` / `max_tokens_to_sample`, `input_schema` inside tools,
|
||||
Anthropic content blocks (`tool_use`/`tool_result`/...). Tools must be
|
||||
`{type:"function", function:{name, description, parameters}}`, unique names;
|
||||
echoed `arguments` must be a JSON-encoded STRING, never a decoded object.
|
||||
|
||||
## Hostile modes (`--mode`, same file)
|
||||
|
||||
| Mode | Behavior | Brain invariant under test |
|
||||
|---|---|---|
|
||||
| `black-hole` | reads the request, never responds | HTTP timeout exists and surfaces; no silent hang |
|
||||
| `mid-body-drop` | 200 headers, half a JSON body, socket abort | truncated body = clean error, never a half-parsed reply shown as real |
|
||||
| `tool-pending-forever` | every request gets a fresh `tool_calls` response, forever | the loop's iteration cap trips (`max_loop_iterations: 16` in the contract); count actual round-trips via `GET /gate/stats` (`chat_hits`) |
|
||||
|
||||
## How the brain-side gate consumes this
|
||||
|
||||
1. Start: `stub-openai.py --port P --scenarios scenarios-openai.json --log run.jsonl`
|
||||
2. Point the brain at it: `NEURON_LLM_0_URL=http://127.0.0.1:P` +
|
||||
`NEURON_LLM_0_FORMAT=openai` (spec step 0 must verify these actually
|
||||
export at runtime), scratch profile, free soul port.
|
||||
3. Send each phrasing's `prompt` (the marker selects the script); assert the
|
||||
brain's claims (`tools_used`, reply, ledger) against the stub's JSONL log
|
||||
— truth, not narration — plus files on disk for write_file scenarios.
|
||||
4. Any stub 400 = the brain sent a malformed/leaked request; the gate fails
|
||||
with the stub's reason string.
|
||||
5. Re-run gate9's Anthropic matrix unchanged = proof the Anthropic lane is
|
||||
byte-untouched.
|
||||
|
||||
## Reconciliation into gate9 (app repo) — AFTER round 9 merges
|
||||
|
||||
This dir is staging only; the merge is mechanical by design:
|
||||
- `stub-openai.py` + `scenarios-openai.json` move to `scripts/gate9/`
|
||||
alongside `stub-llm.py` + `scenarios.json` (shared conventions: marker
|
||||
matching, assistant-count step indexing, `--port/--scenarios/--log`,
|
||||
JSONL fields `seq/ts/kind/scenario_class/phrasing/step/validation/
|
||||
delivered/http_status`, prod-port refusal, benign background responses,
|
||||
`GATE-SCRIPT-EXHAUSTED` overrun, `{N}/{NN}` repeat expansion).
|
||||
- `prompt-matrix-gate.sh` gains a dialect axis (anthropic|openai) choosing
|
||||
stub + scenario file; `matrix-asserts.py` reads the same log shape.
|
||||
- The `--mode` hostile flags here are PROVIDER-side (brain↔LLM boundary);
|
||||
gate9's `hostile/` servers are SOUL-side (app↔brain boundary). They are
|
||||
complementary, not duplicates — both stay.
|
||||
|
||||
## Open questions for the port author (stub asserts a position; confirm or change)
|
||||
|
||||
1. `parallel_tool_calls` must be **explicitly false** on every tool-bearing
|
||||
request (ADR-0005 pin). If the builder omits it instead, relax
|
||||
`defaults.expect_request.parallel_tool_calls` to `null`.
|
||||
2. `tool_choice` must be present (`"auto"` expected). If the brain relies on
|
||||
the provider default, drop `require_tool_choice`.
|
||||
3. Tool-result `content` is asserted only to be a string; if the brain sends
|
||||
structured JSON-in-string (like `{"ok":true,...}`), no change needed.
|
||||
4. Groq compatibility: Groq's OpenAI-compat endpoint rejects some optional
|
||||
fields; whatever field set the brain settles on for live Groq E2E must be
|
||||
mirrored here so the deterministic gate and the live lane assert the SAME
|
||||
request shape.
|
||||
5. The stub treats a `role:"tool"` turn answering an already-answered id as
|
||||
400; if the resume path can legitimately replay tool results, that rule
|
||||
needs a resume-aware carve-out (gate9's Anthropic stub faced the same
|
||||
issue — see its PASS 1 comment).
|
||||
@@ -1,559 +0,0 @@
|
||||
#!/usr/bin/env bash
|
||||
# run-lane-gate.sh — brain-side driver for the OpenAI-dialect gate.
|
||||
#
|
||||
# Drives the REAL soul binary against stub-openai.py for every class and every
|
||||
# phrasing in scenarios-openai.json, plus the three hostile provider modes, and
|
||||
# asserts the brain's claims against the stub's ground-truth JSONL (truth, not
|
||||
# narration) and against files on disk.
|
||||
#
|
||||
# SAFETY (hard rules, enforced below):
|
||||
# - never binds 7770 / 7779 / 17779 - only 7891-7894
|
||||
# - never reads or writes ~/.neuron - HOME is redirected to a scratch dir
|
||||
# - every process started here is killed on exit (trap) and proven with lsof
|
||||
#
|
||||
# The soul runs under `script -q /dev/null` so its stdout is a pty: El's
|
||||
# println() uses puts(), which is FULLY buffered to a file, and the process is
|
||||
# killed without flushing — the DRIFT lines would be invisible otherwise.
|
||||
#
|
||||
# Usage: ./run-lane-gate.sh [all|bridge|local|toolsoff|hostile]
|
||||
# bridge = consent round-trip config (no workspace root -> write_file is
|
||||
# "escalate" -> the loop suspends and the CLIENT executes the tool)
|
||||
# local = workspace-root config (write_file is "reversible" + builtin ->
|
||||
# the loop executes the tool in-process and runs to completion)
|
||||
# toolsoff = supplementary: non-agentic lane against a base URL WITHOUT the
|
||||
# /v1 suffix (the el-runtime provider chain appends
|
||||
# /v1/chat/completions itself, unlike chat.el which appends only
|
||||
# /chat/completions)
|
||||
# hostile = black-hole / mid-body-drop / tool-pending-forever
|
||||
#
|
||||
# Env overrides: SOUL_BIN, STUB_PORT, SOUL_PORT, SOUL_PORT_B, RUN_ROOT
|
||||
set -uo pipefail
|
||||
|
||||
HERE="$(cd "$(dirname "$0")" && pwd)"
|
||||
PHASES="${1:-all}"
|
||||
|
||||
SOUL_BIN="${SOUL_BIN:-/tmp/soul-oai2/soul-openai-tools}"
|
||||
STUB_PORT="${STUB_PORT:-7891}"
|
||||
SOUL_PORT="${SOUL_PORT:-7892}"
|
||||
SOUL_PORT_B="${SOUL_PORT_B:-7893}"
|
||||
RUN_ROOT="${RUN_ROOT:-/tmp/oa-lane-gate}"
|
||||
STAMP="$(date +%Y%m%d-%H%M%S)"
|
||||
RUN="$RUN_ROOT/$STAMP"
|
||||
|
||||
for p in "$STUB_PORT" "$SOUL_PORT" "$SOUL_PORT_B"; do
|
||||
case "$p" in
|
||||
7770|7779|17779) echo "FATAL: refusing production Neuron port $p"; exit 2;;
|
||||
789[1-4]) ;;
|
||||
*) echo "FATAL: port $p outside the allowed 7891-7894 range"; exit 2;;
|
||||
esac
|
||||
done
|
||||
[ -x "$SOUL_BIN" ] || { echo "FATAL: soul binary not found/executable: $SOUL_BIN"; exit 2; }
|
||||
|
||||
mkdir -p "$RUN/home" "$RUN/ws-bridge" "$RUN/ws-local" "$RUN/ws-off" "$RUN/engram"
|
||||
echo '{"nodes":[],"edges":[]}' > "$RUN/engram/snapshot.json"
|
||||
DRV="$RUN/drv.py"
|
||||
|
||||
STUB_PID=""; SOUL_PID=""
|
||||
cleanup() {
|
||||
[ -n "$SOUL_PID" ] && kill "$SOUL_PID" 2>/dev/null
|
||||
pkill -f "$SOUL_BIN" 2>/dev/null
|
||||
[ -n "$STUB_PID" ] && kill "$STUB_PID" 2>/dev/null
|
||||
sleep 0.4
|
||||
[ -n "$SOUL_PID" ] && kill -9 "$SOUL_PID" 2>/dev/null
|
||||
[ -n "$STUB_PID" ] && kill -9 "$STUB_PID" 2>/dev/null
|
||||
return 0
|
||||
}
|
||||
trap cleanup EXIT INT TERM
|
||||
|
||||
start_stub() { # $1 = mode, $2 = log path
|
||||
local mode="$1" log="$2" args=""
|
||||
[ "$mode" = "normal" ] && args="--scenarios $HERE/scenarios-openai.json"
|
||||
# shellcheck disable=SC2086
|
||||
python3 "$HERE/stub-openai.py" --port "$STUB_PORT" --mode "$mode" --log "$log" $args \
|
||||
> "$RUN/stub-$mode.out" 2>&1 &
|
||||
STUB_PID=$!
|
||||
for _ in $(seq 1 50); do
|
||||
curl -sf "http://127.0.0.1:$STUB_PORT/gate/health" >/dev/null 2>&1 && return 0
|
||||
sleep 0.2
|
||||
done
|
||||
echo "FATAL: stub did not come up on $STUB_PORT"; cat "$RUN/stub-$mode.out"; exit 3
|
||||
}
|
||||
stop_stub() { [ -n "$STUB_PID" ] && kill "$STUB_PID" 2>/dev/null; sleep 0.3; STUB_PID=""; }
|
||||
|
||||
start_soul() { # $1 = port, $2 = base url, $3 = soul log, $4 = agent root ("" = none)
|
||||
local port="$1" base="$2" log="$3" root="$4"
|
||||
script -q /dev/null \
|
||||
env -u ANTHROPIC_API_KEY -u SOUL_API_KEY -u ENGRAM_URL -u ENGRAM_API_KEY \
|
||||
-u NEURON_API_URL -u NEURON_TOKEN -u SOUL_LLM_PROVIDER -u SOUL_LLM_BASE_URL \
|
||||
-u NEURON_LLM_1_URL -u NEURON_LLM_1_KEY -u SOUL_IDENTITY \
|
||||
HOME="$RUN/home" PATH="$PATH" \
|
||||
NEURON_PORT="$port" EL_HTTP_BIND_HOST=127.0.0.1 \
|
||||
SOUL_ENGRAM_PATH="$RUN/engram/snapshot.json" \
|
||||
SOUL_CGI_ID=ntn-test SOUL_PERSONA_NAME=Neuron \
|
||||
NEURON_LLM_0_URL="$base" NEURON_LLM_0_FORMAT=openai NEURON_LLM_0_KEY=gate-test-key \
|
||||
${root:+NEURON_AGENT_ROOT="$root"} \
|
||||
"$SOUL_BIN" > "$log" 2>&1 &
|
||||
SOUL_PID=$!
|
||||
for _ in $(seq 1 100); do
|
||||
curl -sf "http://127.0.0.1:$port/health" >/dev/null 2>&1 && return 0
|
||||
sleep 0.2
|
||||
done
|
||||
echo "FATAL: soul did not come up on $port"; tail -20 "$log"; exit 3
|
||||
}
|
||||
stop_soul() {
|
||||
[ -n "$SOUL_PID" ] && kill "$SOUL_PID" 2>/dev/null
|
||||
pkill -f "$SOUL_BIN" 2>/dev/null
|
||||
sleep 0.6; SOUL_PID=""
|
||||
}
|
||||
|
||||
# ------------------------------------------------------------------ driver ----
|
||||
cat > "$DRV" <<'PYEOF'
|
||||
import json, os, sys, time, threading, urllib.request, urllib.error
|
||||
|
||||
CFG = json.load(open(sys.argv[1]))
|
||||
SOUL = "http://127.0.0.1:%d" % CFG["soul_port"]
|
||||
STUB = "http://127.0.0.1:%d" % CFG["stub_port"]
|
||||
WS = CFG["workspace"]
|
||||
MODE = CFG["mode"] # bridge | local | toolsoff
|
||||
SCEN = json.load(open(CFG["scenarios"]))
|
||||
STUBLOG = CFG["stub_log"]
|
||||
SOULLOG = CFG["soul_log"]
|
||||
ONLY = CFG.get("classes") or list(SCEN["classes"].keys())
|
||||
MAXHOPS = CFG.get("max_hops", 15)
|
||||
OUT = CFG["out"]
|
||||
# the chat-only class must be driven on the NON-agentic door: the agentic door
|
||||
# always advertises tools, which is a 400 on that scenario by contract.
|
||||
NON_AGENTIC = {"oa-tools-off"}
|
||||
|
||||
def http(method, url, obj=None, timeout=300):
|
||||
data = None if obj is None else json.dumps(obj).encode()
|
||||
req = urllib.request.Request(url, data=data, method=method,
|
||||
headers={"Content-Type": "application/json"})
|
||||
try:
|
||||
with urllib.request.urlopen(req, timeout=timeout) as r:
|
||||
body = r.read().decode("utf-8", "replace")
|
||||
st = r.status
|
||||
except urllib.error.HTTPError as e:
|
||||
body = e.read().decode("utf-8", "replace"); st = e.code
|
||||
except Exception as e:
|
||||
return -1, "TRANSPORT-ERROR: %r" % (e,), None
|
||||
try:
|
||||
return st, body, json.loads(body)
|
||||
except ValueError:
|
||||
return st, body, None
|
||||
|
||||
def fsize(p):
|
||||
return os.path.getsize(p) if os.path.exists(p) else 0
|
||||
|
||||
def tail_from(path, off):
|
||||
if not os.path.exists(path):
|
||||
return "", off
|
||||
with open(path, "rb") as f:
|
||||
f.seek(off); chunk = f.read(); return chunk.decode("utf-8", "replace"), f.tell()
|
||||
|
||||
def stub_since(off):
|
||||
"""Exact correlation: only the JSONL bytes appended during this phrasing."""
|
||||
txt, noff = tail_from(STUBLOG, off)
|
||||
recs = []
|
||||
for line in txt.splitlines():
|
||||
line = line.strip()
|
||||
if line:
|
||||
try: recs.append(json.loads(line))
|
||||
except ValueError: pass
|
||||
return recs, noff
|
||||
|
||||
def perform(name, ti):
|
||||
"""Execute the bridged tool for real, like the desktop client would."""
|
||||
if name in ("write_file", "edit_file"):
|
||||
p = ti.get("path", "")
|
||||
dest = p if os.path.isabs(p) else os.path.join(WS, p)
|
||||
os.makedirs(os.path.dirname(dest) or WS, exist_ok=True)
|
||||
body = ti.get("content", "")
|
||||
with open(dest, "w") as f:
|
||||
f.write(body)
|
||||
return "wrote %s (%d bytes)" % (p, len(body.encode()))
|
||||
return "ok"
|
||||
|
||||
class Poller(threading.Thread):
|
||||
def __init__(self, sid):
|
||||
super().__init__(daemon=True); self.sid = sid; self.snaps = []; self.stop = False
|
||||
def run(self):
|
||||
while not self.stop:
|
||||
st, body, js = http("GET", SOUL + "/api/run-progress/" + self.sid, timeout=60)
|
||||
if js and js.get("progress"):
|
||||
if not self.snaps or self.snaps[-1] != js["progress"]:
|
||||
self.snaps.append(js["progress"])
|
||||
time.sleep(0.1)
|
||||
|
||||
def progress(sid):
|
||||
_, _, pj = http("GET", SOUL + "/api/run-progress/" + sid, timeout=30)
|
||||
return (pj or {}).get("progress")
|
||||
|
||||
def run_phrasing(cname, ph):
|
||||
st, body, js = http("POST", SOUL + "/api/sessions", {"title": ph["id"]}, timeout=60)
|
||||
sid = (js or {}).get("id", "")
|
||||
rec = {"class": cname, "phrasing": ph["id"], "session_id": sid, "legs": [],
|
||||
"pendings": [], "progress_during": [], "progress_per_leg": [],
|
||||
"progress_final": None, "soul_log": "", "stub": [], "http": [],
|
||||
"agentic": cname not in NON_AGENTIC}
|
||||
if not sid:
|
||||
rec["fatal"] = "session create failed: %s %s" % (st, body[:300]); return rec
|
||||
soff = fsize(SOULLOG); loff = fsize(STUBLOG)
|
||||
t0 = time.time()
|
||||
pol = Poller(sid); pol.start()
|
||||
payload = {"message": ph["prompt"], "session_id": sid, "workspace_root": WS,
|
||||
"agentic": rec["agentic"]}
|
||||
if MODE == "local":
|
||||
payload["agent_workspace_root"] = WS
|
||||
st, body, js = http("POST", SOUL + "/api/chat", payload, timeout=CFG.get("chat_timeout", 240))
|
||||
rec["http"].append(st)
|
||||
rec["legs"].append(js if js is not None else body[:600])
|
||||
rec["progress_per_leg"].append(progress(sid))
|
||||
hops = 0
|
||||
while isinstance(js, dict) and js.get("tool_pending") and hops < MAXHOPS:
|
||||
rec["pendings"].append({"call_id": js.get("call_id"), "tool_name": js.get("tool_name"),
|
||||
"tool_input": js.get("tool_input"), "risk_tier": js.get("risk_tier"),
|
||||
"narration": js.get("narration"), "tools_used": js.get("tools_used")})
|
||||
try:
|
||||
eff = perform(js.get("tool_name", ""), js.get("tool_input") or {})
|
||||
except Exception as e:
|
||||
eff = "client error: %r" % (e,)
|
||||
st, body, js = http("POST", SOUL + "/api/sessions/%s/tool_result" % sid,
|
||||
{"call_id": js.get("call_id"), "content": eff},
|
||||
timeout=CFG.get("chat_timeout", 240))
|
||||
rec["http"].append(st)
|
||||
rec["legs"].append(js if js is not None else body[:600])
|
||||
rec["progress_per_leg"].append(progress(sid))
|
||||
hops += 1
|
||||
pol.stop = True; time.sleep(0.3)
|
||||
t1 = time.time()
|
||||
rec["elapsed"] = round(t1 - t0, 2)
|
||||
rec["progress_during"] = pol.snaps
|
||||
rec["progress_final"] = progress(sid)
|
||||
rec["soul_log"], _ = tail_from(SOULLOG, soff)
|
||||
rec["stub"], _ = stub_since(loff)
|
||||
rec["hops"] = hops
|
||||
return rec
|
||||
|
||||
# ------------------------------------------------------------- assertions ----
|
||||
def expected_calls(cname, first_only=False):
|
||||
out = []
|
||||
for step in SCEN["classes"][cname]["script"]:
|
||||
for k, call in enumerate(step.get("tool_calls") or []):
|
||||
if first_only and k > 0:
|
||||
continue
|
||||
out.append((call["name"], call["arguments"]))
|
||||
return out
|
||||
|
||||
def final_text(cname):
|
||||
for step in reversed(SCEN["classes"][cname]["script"]):
|
||||
if step.get("text") and not step.get("tool_calls"):
|
||||
return step["text"]
|
||||
return None
|
||||
|
||||
def judge(rec):
|
||||
cname = rec["class"]; ok = []; bad = []
|
||||
last = rec["legs"][-1] if rec["legs"] else None
|
||||
reply = last.get("reply") if isinstance(last, dict) else None
|
||||
err = last.get("error") if isinstance(last, dict) else None
|
||||
tools_used = last.get("tools_used") if isinstance(last, dict) else None
|
||||
stub = rec["stub"]
|
||||
scen_recs = [r for r in stub if r.get("kind") == "scenario"]
|
||||
rejects = [r for r in stub if r.get("validation") != "ok"]
|
||||
bg = [r for r in stub if r.get("kind") in ("wrong_path", "background")]
|
||||
|
||||
def wire_clean():
|
||||
if rejects:
|
||||
for r in rejects:
|
||||
bad.append("stub REJECTED a request: [%s] %s"
|
||||
% (r.get("validation"), r.get("validation_detail")))
|
||||
else:
|
||||
ok.append("stub ground truth: validation \"ok\" on all %d scenario leg(s), no "
|
||||
"gate_echo_mismatch / gate_tool_call_shape / dialect-leak 400s"
|
||||
% len(scen_recs))
|
||||
if bg:
|
||||
ok.append("NOTE background non-scenario request(s) in this window: %s"
|
||||
% [(r.get("kind"), r.get("path"), r.get("http_status")) for r in bg])
|
||||
|
||||
if cname == "oa-plain":
|
||||
wire_clean()
|
||||
want = final_text(cname)
|
||||
if reply == want: ok.append("final reply == scripted final text (byte-exact)")
|
||||
else: bad.append("final reply mismatch:\n WANT: %r\n GOT : %r" % (want, reply))
|
||||
if tools_used == []: ok.append("tools_used == [] (no tool ran)")
|
||||
else: bad.append("tools_used expected [] got %r" % (tools_used,))
|
||||
if reply and ('"tool_calls"' in reply or '"function"' in reply or '"tool_use"' in reply):
|
||||
bad.append("tool-call JSON leaked into the reply text")
|
||||
else: ok.append("no tool-call JSON anywhere in the reply")
|
||||
|
||||
elif cname in ("oa-single-tool", "oa-torture", "oa-mission"):
|
||||
wire_clean()
|
||||
want = final_text(cname)
|
||||
if reply == want: ok.append("final reply == scripted final text (byte-exact)")
|
||||
else: bad.append("final reply mismatch:\n WANT: %r\n GOT : %r" % (want, reply))
|
||||
exp = expected_calls(cname)
|
||||
wantnames = [n for n, _ in exp]
|
||||
if tools_used == wantnames:
|
||||
ok.append("tools_used == %r (carried across %d suspension(s))" % (wantnames, rec["hops"]))
|
||||
else:
|
||||
bad.append("tools_used expected %r got %r" % (wantnames, tools_used))
|
||||
for name, args in exp:
|
||||
p = args.get("path"); c = args.get("content")
|
||||
dest = os.path.join(WS, p)
|
||||
if not os.path.exists(dest):
|
||||
bad.append("expected file missing on disk: %s" % dest); continue
|
||||
got = open(dest, "rb").read()
|
||||
if got == c.encode():
|
||||
ok.append("%s on disk is byte-for-byte the issued payload (%d bytes)" % (p, len(got)))
|
||||
else:
|
||||
bad.append("%s content differs\n WANT %r\n GOT %r"
|
||||
% (p, c[:300], got[:300].decode("utf-8", "replace")))
|
||||
if MODE == "bridge":
|
||||
for pend, (name, args) in zip(rec["pendings"], exp):
|
||||
if pend["tool_input"] == args:
|
||||
ok.append("tool_input for %s survived exactly ONE decode (deep-equal to the "
|
||||
"issued arguments; no double-escaping)" % name)
|
||||
else:
|
||||
bad.append("tool_input != issued arguments for %s\n WANT %r\n GOT %r"
|
||||
% (name, args, pend["tool_input"]))
|
||||
if rec["pendings"] and all(p["risk_tier"] == "escalate" for p in rec["pendings"]):
|
||||
ok.append("every write_file classified \"escalate\" and bridged for consent")
|
||||
|
||||
elif cname == "oa-parallel":
|
||||
drift = [l.strip() for l in rec["soul_log"].splitlines() if "DRIFT: provider returned" in l]
|
||||
if drift: ok.append("soul log: " + drift[0])
|
||||
else: bad.append("no 'DRIFT: provider returned N parallel tool_calls' line in the soul log")
|
||||
delivered = [r for r in stub if r.get("delivered", {}).get("tool_calls")]
|
||||
if delivered and len(delivered[0]["delivered"]["tool_calls"]) == 2:
|
||||
ok.append("stub delivered 2 parallel tool_calls in one response (ground truth)")
|
||||
if MODE == "bridge":
|
||||
if len(rec["pendings"]) == 1:
|
||||
ok.append("exactly ONE call honored: %s" % rec["pendings"][0]["call_id"])
|
||||
else:
|
||||
bad.append("expected exactly 1 honored call, got %d" % len(rec["pendings"]))
|
||||
pairing = [r for r in rejects if "gate_pairing" in str(r.get("validation_detail")) or
|
||||
"tool_calls at end of thread" in str(r.get("validation_detail")) or
|
||||
"not fully answered" in str(r.get("validation_detail"))]
|
||||
for r in pairing:
|
||||
ok.append("EXPECTED-BY-CONTRACT stub 400 on the unpaired echo: %s"
|
||||
% r.get("validation_detail"))
|
||||
other = [r for r in rejects if r not in pairing]
|
||||
for r in other:
|
||||
bad.append("unexpected stub rejection: [%s] %s"
|
||||
% (r.get("validation"), r.get("validation_detail")))
|
||||
if err and not reply:
|
||||
ok.append("honest error envelope after the 400 (no fabricated answer): %r" % err)
|
||||
elif reply == final_text(cname):
|
||||
ok.append("final reply == scripted final text (both calls paired)")
|
||||
else:
|
||||
bad.append("neither an honest error nor the scripted final text: %r" % (last,))
|
||||
|
||||
elif cname == "oa-api-error":
|
||||
if err and not reply:
|
||||
ok.append("honest error envelope: error=%r reply=%r" % (err, reply))
|
||||
else:
|
||||
bad.append("expected an error envelope with an empty reply, got %r" % (last,))
|
||||
delivered = [r["delivered"].get("api_error") for r in stub if r.get("delivered")]
|
||||
ok.append("stub delivered api_error status(es): %r" % [d for d in delivered if d])
|
||||
n = len([r for r in stub if r.get("kind") == "scenario"])
|
||||
ok.append("provider hit %d time(s) - no retry storm" % n)
|
||||
if reply:
|
||||
bad.append("FABRICATED ANSWER: reply non-empty on a provider error")
|
||||
|
||||
elif cname == "oa-tools-off":
|
||||
ok.append("stub records for this phrasing: %r"
|
||||
% [{k: r.get(k) for k in ("kind", "path", "validation", "http_status")} for r in stub])
|
||||
wrong = [r for r in stub if r.get("kind") == "wrong_path"]
|
||||
matched = [r for r in stub if r.get("scenario_class") == cname]
|
||||
if matched and not rejects:
|
||||
ok.append("chat-only request reached /v1/chat/completions with NO tools offered")
|
||||
want = final_text(cname)
|
||||
if reply == want: ok.append("final reply == scripted final text (byte-exact)")
|
||||
else: bad.append("final reply mismatch:\n WANT: %r\n GOT : %r" % (want, reply))
|
||||
if reply and ('"tool_calls"' in reply or '"function"' in reply):
|
||||
bad.append("tool-call JSON leaked into the reply text")
|
||||
else: ok.append("no tool-call JSON in the reply")
|
||||
elif wrong:
|
||||
bad.append("the non-agentic lane never reached the provider endpoint: stub saw "
|
||||
"%s -> %s (the el-runtime provider chain appends /v1/chat/completions "
|
||||
"to NEURON_LLM_0_URL, chat.el appends only /chat/completions)"
|
||||
% (wrong[0]["path"], wrong[0]["http_status"]))
|
||||
elif not stub:
|
||||
bad.append("no request reached the stub at all")
|
||||
else:
|
||||
for r in rejects:
|
||||
bad.append("stub REJECTED: [%s] %s" % (r.get("validation"), r.get("validation_detail")))
|
||||
return ok, bad
|
||||
|
||||
def main():
|
||||
results = []
|
||||
for cname in ONLY:
|
||||
for ph in SCEN["classes"][cname]["phrasings"]:
|
||||
rec = run_phrasing(cname, ph)
|
||||
ok, bad = judge(rec)
|
||||
rec["ok"] = ok; rec["bad"] = bad
|
||||
rec["verdict"] = "FAIL" if bad else "PASS"
|
||||
results.append(rec)
|
||||
print("=" * 78)
|
||||
print("[%s] %s / %s (%.2fs, %d bridge hop(s), agentic=%s, mode=%s)"
|
||||
% (rec["verdict"], cname, ph["id"], rec.get("elapsed", 0),
|
||||
rec.get("hops", 0), rec["agentic"], MODE))
|
||||
for l in ok: print(" ok " + l.replace("\n", "\n "))
|
||||
for l in bad: print(" FAIL " + l.replace("\n", "\n "))
|
||||
for i, leg in enumerate(rec["legs"]):
|
||||
print(" leg%d envelope: %s" % (i, json.dumps(leg)[:430]))
|
||||
for i, pr in enumerate(rec["progress_per_leg"]):
|
||||
print(" run-progress after leg%d: %s" % (i, json.dumps(pr)[:380]))
|
||||
if rec["progress_during"]:
|
||||
print(" run-progress polled DURING (%d distinct snapshot(s)), last: %s"
|
||||
% (len(rec["progress_during"]), json.dumps(rec["progress_during"][-1])[:300]))
|
||||
for r in rec["stub"]:
|
||||
print(" stub: kind=%s class=%s phrasing=%s step=%s validation=%s%s delivered=%s http=%s"
|
||||
% (r.get("kind"), r.get("scenario_class"), r.get("phrasing"), r.get("step"),
|
||||
r.get("validation"),
|
||||
("(" + str(r.get("validation_detail")) + ")") if r.get("validation_detail") else "",
|
||||
json.dumps(r.get("delivered")), r.get("http_status")))
|
||||
if rec["soul_log"].strip():
|
||||
for l in rec["soul_log"].splitlines():
|
||||
if l.strip(): print(" soul: " + l.strip())
|
||||
json.dump(results, open(OUT, "w"), indent=1)
|
||||
npass = sum(1 for r in results if r["verdict"] == "PASS")
|
||||
print("=" * 78)
|
||||
print("PHASE %s: %d/%d PASS" % (MODE, npass, len(results)))
|
||||
for r in results:
|
||||
print(" %-6s %-16s %s" % (r["verdict"], r["class"], r["phrasing"]))
|
||||
return 0 if npass == len(results) else 1
|
||||
|
||||
sys.exit(main())
|
||||
PYEOF
|
||||
|
||||
# ------------------------------------------------------------- hostile drv ---
|
||||
cat > "$RUN/hostile.py" <<'PYEOF'
|
||||
import json, os, sys, time, urllib.request, urllib.error
|
||||
|
||||
CFG = json.load(open(sys.argv[1]))
|
||||
SOUL = "http://127.0.0.1:%d" % CFG["soul_port"]
|
||||
STUB = "http://127.0.0.1:%d" % CFG["stub_port"]
|
||||
|
||||
def http(method, url, obj=None, timeout=400):
|
||||
data = None if obj is None else json.dumps(obj).encode()
|
||||
req = urllib.request.Request(url, data=data, method=method,
|
||||
headers={"Content-Type": "application/json"})
|
||||
try:
|
||||
with urllib.request.urlopen(req, timeout=timeout) as r:
|
||||
b = r.read().decode("utf-8", "replace"); st = r.status
|
||||
except urllib.error.HTTPError as e:
|
||||
b = e.read().decode("utf-8", "replace"); st = e.code
|
||||
except Exception as e:
|
||||
return -1, "TRANSPORT-ERROR: %r" % (e,), None
|
||||
try:
|
||||
return st, b, json.loads(b)
|
||||
except ValueError:
|
||||
return st, b, None
|
||||
|
||||
mode = CFG["mode"]; wsmode = CFG["ws_mode"]; WS = CFG["workspace"]
|
||||
_, _, js = http("POST", SOUL + "/api/sessions", {"title": "hostile-" + mode}, timeout=60)
|
||||
sid = (js or {}).get("id", "")
|
||||
payload = {"message": "oa-gate plain probe: hostile mode %s" % mode,
|
||||
"agentic": True, "session_id": sid, "workspace_root": WS}
|
||||
if wsmode == "local":
|
||||
payload["agent_workspace_root"] = WS
|
||||
t0 = time.time()
|
||||
st, body, js = http("POST", SOUL + "/api/chat", payload, timeout=CFG.get("timeout", 400))
|
||||
t_first = time.time() - t0
|
||||
legs = [js if js is not None else body[:500]]
|
||||
hops = 0
|
||||
while isinstance(js, dict) and js.get("tool_pending") and hops < CFG.get("max_hops", 14):
|
||||
ti = js.get("tool_input") or {}
|
||||
p = ti.get("path", "x.md")
|
||||
dest = p if os.path.isabs(p) else os.path.join(WS, p)
|
||||
try: open(dest, "w").write(ti.get("content", ""))
|
||||
except Exception: pass
|
||||
st, body, js = http("POST", SOUL + "/api/sessions/%s/tool_result" % sid,
|
||||
{"call_id": js.get("call_id"), "content": "ok"},
|
||||
timeout=CFG.get("timeout", 400))
|
||||
legs.append(js if js is not None else body[:500]); hops += 1
|
||||
el = time.time() - t0
|
||||
_, _, stats = http("GET", STUB + "/gate/stats", timeout=30)
|
||||
_, _, prog = http("GET", SOUL + "/api/run-progress/" + sid, timeout=30)
|
||||
fab = [l for l in legs if isinstance(l, dict) and l.get("reply")]
|
||||
print("HOSTILE %s (ws_mode=%s)" % (mode, wsmode))
|
||||
print(" first /api/chat POST returned after %.2fs; whole chain %.2fs; client bridge hops=%d; "
|
||||
"stub chat_hits=%s" % (t_first, el, hops, (stats or {}).get("chat_hits")))
|
||||
print(" first envelope : " + json.dumps(legs[0])[:430])
|
||||
print(" final envelope : " + json.dumps(legs[-1])[:430])
|
||||
print(" non-empty replies anywhere in the chain (fabrication check): %d" % len(fab))
|
||||
print(" run-progress : " + json.dumps(prog)[:300])
|
||||
json.dump({"mode": mode, "ws_mode": wsmode, "t_first": t_first, "elapsed": el, "hops": hops,
|
||||
"chat_hits": (stats or {}).get("chat_hits"), "legs": legs, "progress": prog},
|
||||
open(CFG["out"], "w"), indent=1)
|
||||
PYEOF
|
||||
|
||||
# ------------------------------------------------------------------ phases ---
|
||||
RC_BRIDGE=0; RC_LOCAL=0; RC_OFF=0
|
||||
run_normal_phase() { # $1 = label, $2 = soul port, $3 = agent root, $4 = ws, $5 = base, $6 = classes json
|
||||
local m="$1" port="$2" root="$3" ws="$4" base="$5" classes="$6"
|
||||
echo; echo "############ PHASE: $m (soul :$port, NEURON_LLM_0_URL=$base) ############"
|
||||
start_stub normal "$RUN/stub-$m.jsonl"
|
||||
start_soul "$port" "$base" "$RUN/soul-$m.log" "$root"
|
||||
cat > "$RUN/cfg-$m.json" <<JSON
|
||||
{"soul_port": $port, "stub_port": $STUB_PORT, "workspace": "$ws", "mode": "$m",
|
||||
"scenarios": "$HERE/scenarios-openai.json", "stub_log": "$RUN/stub-$m.jsonl",
|
||||
"soul_log": "$RUN/soul-$m.log", "out": "$RUN/results-$m.json", "chat_timeout": 240,
|
||||
"classes": $classes}
|
||||
JSON
|
||||
python3 "$DRV" "$RUN/cfg-$m.json"
|
||||
local rc=$?
|
||||
stop_soul; stop_stub
|
||||
return $rc
|
||||
}
|
||||
|
||||
if [ "$PHASES" = "all" ] || [ "$PHASES" = "bridge" ]; then
|
||||
run_normal_phase bridge "$SOUL_PORT" "" "$RUN/ws-bridge" "http://127.0.0.1:$STUB_PORT/v1" null
|
||||
RC_BRIDGE=$?
|
||||
fi
|
||||
if [ "$PHASES" = "all" ] || [ "$PHASES" = "local" ]; then
|
||||
run_normal_phase local "$SOUL_PORT_B" "$RUN/ws-local" "$RUN/ws-local" "http://127.0.0.1:$STUB_PORT/v1" null
|
||||
RC_LOCAL=$?
|
||||
fi
|
||||
if [ "$PHASES" = "all" ] || [ "$PHASES" = "toolsoff" ]; then
|
||||
# supplementary: the el-runtime provider chain appends /v1/chat/completions itself,
|
||||
# so the non-agentic door needs the base WITHOUT the /v1 suffix.
|
||||
run_normal_phase toolsoff "$SOUL_PORT" "" "$RUN/ws-off" "http://127.0.0.1:$STUB_PORT" '["oa-tools-off","oa-plain"]'
|
||||
RC_OFF=$?
|
||||
fi
|
||||
|
||||
if [ "$PHASES" = "all" ] || [ "$PHASES" = "hostile" ]; then
|
||||
echo; echo "############ PHASE: hostile ############"
|
||||
for spec in "black-hole:bridge" "mid-body-drop:bridge" "tool-pending-forever:bridge" "tool-pending-forever:local"; do
|
||||
mode="${spec%%:*}"; wsm="${spec##*:}"
|
||||
echo; echo "---- hostile mode=$mode ws_mode=$wsm ----"
|
||||
start_stub "$mode" "$RUN/stub-$mode-$wsm.jsonl"
|
||||
if [ "$wsm" = "local" ]; then
|
||||
start_soul "$SOUL_PORT" "http://127.0.0.1:$STUB_PORT/v1" "$RUN/soul-$mode-$wsm.log" "$RUN/ws-local"
|
||||
else
|
||||
start_soul "$SOUL_PORT" "http://127.0.0.1:$STUB_PORT/v1" "$RUN/soul-$mode-$wsm.log" ""
|
||||
fi
|
||||
cat > "$RUN/cfg-$mode-$wsm.json" <<JSON
|
||||
{"soul_port": $SOUL_PORT, "stub_port": $STUB_PORT, "mode": "$mode", "ws_mode": "$wsm",
|
||||
"workspace": "$RUN/ws-local", "out": "$RUN/hostile-$mode-$wsm.json", "timeout": 400}
|
||||
JSON
|
||||
python3 "$RUN/hostile.py" "$RUN/cfg-$mode-$wsm.json"
|
||||
echo " soul log (llm/DRIFT/cap lines):"
|
||||
grep -E "DRIFT|llm error|iteration cap|\[llm\]" "$RUN/soul-$mode-$wsm.log" | tail -8 | sed 's/^/ /'
|
||||
stop_soul; stop_stub
|
||||
done
|
||||
fi
|
||||
|
||||
echo; echo "############ CLEANUP ############"
|
||||
cleanup
|
||||
sleep 0.5
|
||||
echo "processes still matching the soul binary:"; pgrep -fl "$SOUL_BIN" || echo " (none)"
|
||||
echo "processes still matching stub-openai.py:"; pgrep -fl "stub-openai.py" || echo " (none)"
|
||||
echo "lsof on 7891-7894 after cleanup:"
|
||||
lsof -nP -iTCP:7891 -iTCP:7892 -iTCP:7893 -iTCP:7894 2>/dev/null || echo " (no listeners - ports free)"
|
||||
echo
|
||||
echo "############ SUMMARY ############"
|
||||
echo "run dir: $RUN"
|
||||
echo "bridge rc=$RC_BRIDGE local rc=$RC_LOCAL toolsoff rc=$RC_OFF (0 = every class PASS)"
|
||||
exit $(( RC_BRIDGE + RC_LOCAL + RC_OFF ))
|
||||
@@ -1,110 +0,0 @@
|
||||
{
|
||||
"_comment": "OpenAI-dialect gate scenario contract (soul-openai-tools-v2). Single source of truth shared by stub-openai.py (scripted provider responses + request assertions), selftest.sh (stub self-verification), and the future brain-side gate driver. Same structure as gate9's scenarios.json: classes -> script + phrasings with markers; scripts are CLASS-level so assertions are behavioral, never pinned to a sentence. expect_request keys: require_tools, require_tool_choice, parallel_tool_calls (expected literal value; null = don't check), forbid_tools. defaults apply to every class unless overridden; steps may override with their own expect_request.",
|
||||
"deadline_secs": 60,
|
||||
"max_loop_iterations": 16,
|
||||
"defaults": {
|
||||
"expect_request": {
|
||||
"require_tools": true,
|
||||
"require_tool_choice": true,
|
||||
"parallel_tool_calls": false
|
||||
}
|
||||
},
|
||||
"classes": {
|
||||
"oa-plain": {
|
||||
"script": [
|
||||
{ "text": "Plain OpenAI-lane answer (gate fixture): the mechanism, the main caveat, and the practical takeaway in three sentences. No tools were needed for this one, and the finish reason on the wire is stop, which the loop must treat as terminal." }
|
||||
],
|
||||
"phrasings": [
|
||||
{ "id": "oa-plain-p1", "marker": "oa-gate plain probe", "prompt": "oa-gate plain probe: explain the fixture topic simply." },
|
||||
{ "id": "oa-plain-p2", "marker": "oa-gate second plain", "prompt": "oa-gate second plain: another phrasing of the plain question." }
|
||||
]
|
||||
},
|
||||
"oa-tools-off": {
|
||||
"expect_request": {
|
||||
"require_tools": false,
|
||||
"forbid_tools": true,
|
||||
"require_tool_choice": false,
|
||||
"parallel_tool_calls": null
|
||||
},
|
||||
"script": [
|
||||
{ "text": "Chat-only OpenAI-lane answer (gate fixture): this lane offered no tools and none were used; the reply is plain text with finish reason stop." }
|
||||
],
|
||||
"phrasings": [
|
||||
{ "id": "oa-tools-off-p1", "marker": "oa-gate tools-off probe", "prompt": "oa-gate tools-off probe: plain chat with no tools offered." }
|
||||
]
|
||||
},
|
||||
"oa-single-tool": {
|
||||
"script": [
|
||||
{ "text": "Step 1: writing the note.",
|
||||
"tool_calls": [
|
||||
{ "name": "write_file",
|
||||
"arguments": { "path": "openai-single-note.md", "content": "# Note (gate fixture, OpenAI lane)\n\nDeterministic single-tool body.\n" } }
|
||||
] },
|
||||
{ "text": "All set - openai-single-note.md is written with the fixture body. Nothing else was needed for this one." }
|
||||
],
|
||||
"phrasings": [
|
||||
{ "id": "oa-single-p1", "marker": "oa-gate single tool note", "prompt": "oa-gate single tool note: save the fixture note to a file." },
|
||||
{ "id": "oa-single-p2", "marker": "oa-gate one file please", "prompt": "oa-gate one file please: write the fixture note file." }
|
||||
]
|
||||
},
|
||||
"oa-torture": {
|
||||
"script": [
|
||||
{ "tool_calls": [
|
||||
{ "name": "write_file",
|
||||
"arguments": { "path": "torture-note.md", "content": "Line 1 has \"double quotes\", 'singles', and a mid-line backslash \\ here.\nLine 2\thas a tab, a literal \\n two-char sequence, and a Windows path C:\\temp\\new.txt.\nLine 3 unicode: naïve café — 日本語 ✓ 🚀\nLine 4 JSON-in-string: {\"k\": \"v\", \"arr\": [1, 2], \"s\": \"nested \\\"deep\\\" quotes\"}\nLine 5 ends with a lone backslash \\" } }
|
||||
] },
|
||||
{ "text": "Torture round-trip complete: the payload with nested quotes, backslashes, newlines, tabs, and unicode survived exactly one encode and one decode." }
|
||||
],
|
||||
"phrasings": [
|
||||
{ "id": "oa-torture-p1", "marker": "oa-gate torture probe", "prompt": "oa-gate torture probe: write the escaping torture file." }
|
||||
]
|
||||
},
|
||||
"oa-parallel": {
|
||||
"script": [
|
||||
{ "text": "Step 1: two writes at once (parallel probe).",
|
||||
"tool_calls": [
|
||||
{ "name": "write_file", "arguments": { "path": "parallel-a.md", "content": "Parallel A (gate fixture).\n" } },
|
||||
{ "name": "write_file", "arguments": { "path": "parallel-b.md", "content": "Parallel B (gate fixture).\n" } }
|
||||
] },
|
||||
{ "text": "Parallel probe complete: both tool results arrived and were paired correctly. A brain that instead rejects the double call must do so cleanly - that outcome is asserted brain-side, not here." }
|
||||
],
|
||||
"phrasings": [
|
||||
{ "id": "oa-parallel-p1", "marker": "oa-gate parallel probe", "prompt": "oa-gate parallel probe: run the two-write parallel case." }
|
||||
]
|
||||
},
|
||||
"oa-mission": {
|
||||
"script": [
|
||||
{ "text": "Step 1: drafting part one.",
|
||||
"tool_calls": [
|
||||
{ "name": "write_file", "arguments": { "path": "mission-part-1.md", "content": "Mission part 1 (gate fixture).\n" } }
|
||||
] },
|
||||
{ "text": "Step 2: drafting part two.",
|
||||
"tool_calls": [
|
||||
{ "name": "write_file", "arguments": { "path": "mission-part-2.md", "content": "Mission part 2 (gate fixture).\n" } }
|
||||
] },
|
||||
{ "text": "Mission complete: mission-part-1.md and mission-part-2.md are written; the loop ran two tool rounds and finished cleanly with finish reason stop." }
|
||||
],
|
||||
"phrasings": [
|
||||
{ "id": "oa-mission-p1", "marker": "oa-gate mission probe", "prompt": "oa-gate mission probe: run the two-round mission." }
|
||||
]
|
||||
},
|
||||
"oa-api-error": {
|
||||
"expect_request": {
|
||||
"require_tools": false,
|
||||
"require_tool_choice": false,
|
||||
"parallel_tool_calls": null
|
||||
},
|
||||
"script": [],
|
||||
"phrasings": [
|
||||
{ "id": "oa-err-400", "marker": "oa-gate error four hundred", "prompt": "oa-gate error four hundred: trigger the injected failure.",
|
||||
"script": [ { "api_error": { "status": 400, "type": "invalid_request_error", "message": "gate-injected 400: request rejected by fixture", "code": "gate_injected" } } ] },
|
||||
{ "id": "oa-err-429", "marker": "oa-gate error rate limit", "prompt": "oa-gate error rate limit: trigger the injected failure.",
|
||||
"script": [ { "api_error": { "status": 429, "type": "rate_limit_error", "message": "gate-injected 429: rate limited by fixture", "code": "rate_limit_exceeded" } } ] },
|
||||
{ "id": "oa-err-500", "marker": "oa-gate error five hundred", "prompt": "oa-gate error five hundred: trigger the injected failure.",
|
||||
"script": [ { "api_error": { "status": 500, "type": "server_error", "message": "gate-injected 500: internal fixture error", "code": "gate_injected" } } ] },
|
||||
{ "id": "oa-err-503", "marker": "oa-gate error unavailable", "prompt": "oa-gate error unavailable: trigger the injected failure.",
|
||||
"script": [ { "api_error": { "status": 503, "type": "server_error", "message": "gate-injected 503: fixture overloaded", "code": "gate_injected" } } ] }
|
||||
]
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,409 +0,0 @@
|
||||
#!/usr/bin/env bash
|
||||
# selftest.sh - proves stub-openai.py before any brain code exists.
|
||||
# Drives the stub with curl through every scenario (plain, tools-off,
|
||||
# single tool round-trip, escaping torture, parallel double-call,
|
||||
# two-round mission, injected API errors, background, overrun), every
|
||||
# validation rejection (dialect leaks, pairing, echo round-trip, scenario
|
||||
# expectations), and all three hostile modes. Exit 0 = green.
|
||||
set -u
|
||||
cd "$(dirname "$0")" || exit 1
|
||||
PY=python3
|
||||
TMP="$(mktemp -d)"
|
||||
PIDS=()
|
||||
cleanup() {
|
||||
for p in "${PIDS[@]:-}"; do kill -9 "$p" >/dev/null 2>&1; done
|
||||
rm -rf "$TMP"
|
||||
}
|
||||
trap cleanup EXIT
|
||||
|
||||
PASS=0; FAIL=0
|
||||
ok() { printf 'ok - %s\n' "$1"; PASS=$((PASS+1)); }
|
||||
bad() { printf 'FAIL - %s\n' "$1"; FAIL=$((FAIL+1)); }
|
||||
check() { # check <name> <cmd...> - pass if cmd exits 0; show output on fail
|
||||
local name="$1"; shift
|
||||
local out
|
||||
if out="$("$@" 2>&1)"; then ok "$name"
|
||||
else bad "$name"; [ -n "$out" ] && printf '%s\n' "$out" | sed 's/^/ /' | head -8
|
||||
fi
|
||||
}
|
||||
|
||||
freeport() { "$PY" -c 'import socket;s=socket.socket();s.bind(("127.0.0.1",0));print(s.getsockname()[1]);s.close()'; }
|
||||
waithealth() {
|
||||
local p="$1" i
|
||||
for i in $(seq 1 60); do
|
||||
curl -sf "http://127.0.0.1:$p/gate/health" >/dev/null 2>&1 && return 0
|
||||
sleep 0.1
|
||||
done
|
||||
echo "stub on :$p never became healthy"; return 1
|
||||
}
|
||||
post() { # post <port> <bodyfile> <respfile> [extra curl args...] -> echoes http code
|
||||
local port="$1" body="$2" resp="$3"; shift 3
|
||||
curl -s -o "$resp" -w '%{http_code}' -H 'content-type: application/json' \
|
||||
"$@" --data-binary @"$body" "http://127.0.0.1:$port/v1/chat/completions"
|
||||
}
|
||||
|
||||
# ---- embedded helper: builds OpenAI-dialect bodies, asserts on responses ----
|
||||
cat > "$TMP/helpers.py" <<'PYEOF'
|
||||
import copy, json, sys
|
||||
|
||||
TOOLS = [
|
||||
{"type": "function", "function": {
|
||||
"name": "write_file", "description": "Write content to a file on disk.",
|
||||
"parameters": {"type": "object",
|
||||
"properties": {"path": {"type": "string"},
|
||||
"content": {"type": "string"}},
|
||||
"required": ["path", "content"]}}},
|
||||
{"type": "function", "function": {
|
||||
"name": "read_file", "description": "Read contents of a file from disk.",
|
||||
"parameters": {"type": "object",
|
||||
"properties": {"path": {"type": "string"}},
|
||||
"required": ["path"]}}},
|
||||
]
|
||||
|
||||
def dump(obj, out):
|
||||
json.dump(obj, open(out, "w"), ensure_ascii=False)
|
||||
|
||||
def base(prompt, tools=True):
|
||||
b = {"model": "gate-openai-model", "max_tokens": 1024,
|
||||
"messages": [
|
||||
{"role": "system", "content": "You are Neuron (gate fixture)."},
|
||||
{"role": "user", "content": prompt}]}
|
||||
if tools:
|
||||
b["tools"] = copy.deepcopy(TOOLS)
|
||||
b["tool_choice"] = "auto"
|
||||
b["parallel_tool_calls"] = False
|
||||
return b
|
||||
|
||||
def cmd_plain(out, prompt):
|
||||
dump(base(prompt), out)
|
||||
|
||||
def cmd_notools(out, prompt):
|
||||
dump(base(prompt, tools=False), out)
|
||||
|
||||
def cmd_mut(out, prompt, mutation):
|
||||
b = base(prompt)
|
||||
if mutation == "no-tool-choice":
|
||||
del b["tool_choice"]
|
||||
elif mutation == "ptc-true":
|
||||
b["parallel_tool_calls"] = True
|
||||
elif mutation == "top-system":
|
||||
b["system"] = "You are Neuron."
|
||||
elif mutation == "anth-tools":
|
||||
b["tools"] = [{"name": "write_file", "description": "x",
|
||||
"input_schema": {"type": "object", "properties": {}}}]
|
||||
elif mutation == "anth-block":
|
||||
b["messages"][1] = {"role": "user", "content": [
|
||||
{"type": "tool_result", "tool_use_id": "toolu_x", "content": "hi"},
|
||||
{"type": "text", "text": prompt}]}
|
||||
else:
|
||||
raise SystemExit("unknown mutation " + mutation)
|
||||
dump(b, out)
|
||||
|
||||
def cmd_chain(out, prompt, variant, *resps):
|
||||
"""Build the next leg: echo each response's assistant turn and answer its
|
||||
tool calls. `variant` applies to the LAST response only:
|
||||
ok | no-tool-turn | wrong-id | only-first | double-encode | object-args"""
|
||||
b = base(prompt)
|
||||
for idx, p in enumerate(resps):
|
||||
last = idx == len(resps) - 1
|
||||
msg = json.load(open(p))["choices"][0]["message"]
|
||||
tcs = msg.get("tool_calls")
|
||||
if not tcs:
|
||||
b["messages"].append({"role": "assistant",
|
||||
"content": msg.get("content")})
|
||||
continue
|
||||
v = variant if last else "ok"
|
||||
asst = {"role": "assistant", "content": msg.get("content"),
|
||||
"tool_calls": copy.deepcopy(tcs)}
|
||||
if v == "double-encode":
|
||||
for tc in asst["tool_calls"]:
|
||||
tc["function"]["arguments"] = json.dumps(
|
||||
tc["function"]["arguments"])
|
||||
if v == "object-args":
|
||||
for tc in asst["tool_calls"]:
|
||||
tc["function"]["arguments"] = json.loads(
|
||||
tc["function"]["arguments"])
|
||||
b["messages"].append(asst)
|
||||
if v == "no-tool-turn":
|
||||
continue
|
||||
use = tcs[:1] if v == "only-first" else tcs
|
||||
for tc in use:
|
||||
tid = "call_bogus_123" if v == "wrong-id" else tc["id"]
|
||||
b["messages"].append({"role": "tool", "tool_call_id": tid,
|
||||
"content": "{\"ok\":true,\"bytes\":42}"})
|
||||
dump(b, out)
|
||||
|
||||
def cmd_chk(resp, expr):
|
||||
r = json.load(open(resp))
|
||||
if not eval(expr, {"r": r, "json": json, "len": len, "str": str,
|
||||
"isinstance": isinstance, "any": any, "all": all,
|
||||
"sorted": sorted}):
|
||||
print("assertion failed:", expr)
|
||||
print("resp:", json.dumps(r, ensure_ascii=False)[:400])
|
||||
raise SystemExit(1)
|
||||
|
||||
def cmd_torture(resp, scen):
|
||||
r = json.load(open(resp))
|
||||
tc = r["choices"][0]["message"]["tool_calls"][0]
|
||||
raw = tc["function"]["arguments"]
|
||||
assert isinstance(raw, str), "arguments must be a JSON-encoded string"
|
||||
got = json.loads(raw)
|
||||
exp = json.load(open(scen))["classes"]["oa-torture"]["script"][0]["tool_calls"][0]["arguments"]
|
||||
assert got == exp, "decoded arguments != scripted torture payload"
|
||||
content = got["content"]
|
||||
for needle in ['"', "\\", "\n", "\t", "日本語", "naïve", "🚀"]:
|
||||
assert needle in content, "missing torture needle %r" % needle
|
||||
|
||||
def cmd_notjson(path):
|
||||
data = open(path, "rb").read()
|
||||
assert data, "file empty - no partial body arrived"
|
||||
try:
|
||||
json.loads(data.decode("utf-8", "replace"))
|
||||
except ValueError:
|
||||
return
|
||||
raise SystemExit("partial body unexpectedly parsed as complete JSON")
|
||||
|
||||
def cmd_pending(*paths):
|
||||
ids = []
|
||||
for p in paths:
|
||||
c = json.load(open(p))["choices"][0]
|
||||
assert c["finish_reason"] == "tool_calls", c["finish_reason"]
|
||||
tc = c["message"]["tool_calls"][0]
|
||||
assert tc["function"]["name"] == "write_file"
|
||||
json.loads(tc["function"]["arguments"]) # must decode
|
||||
ids.append(tc["id"])
|
||||
assert len(set(ids)) == len(ids), "call ids not distinct: %r" % ids
|
||||
|
||||
def cmd_logcheck(path):
|
||||
recs = [json.loads(l) for l in open(path) if l.strip()]
|
||||
seqs = [r["seq"] for r in recs]
|
||||
assert seqs == sorted(seqs) and len(set(seqs)) == len(seqs), "seq not monotonic"
|
||||
kinds = {}
|
||||
for r in recs:
|
||||
kinds[r["kind"]] = kinds.get(r["kind"], 0) + 1
|
||||
assert kinds.get("scenario", 0) >= 10, "too few scenario records: %r" % kinds
|
||||
assert kinds.get("background", 0) >= 1, "no background record"
|
||||
assert kinds.get("overrun", 0) >= 1, "no overrun record"
|
||||
rejected = [r for r in recs if r["validation"] == "rejected"]
|
||||
assert len(rejected) >= 10, "too few rejected records: %d" % len(rejected)
|
||||
assert any(r["delivered"].get("tool_calls") == ["write_file"]
|
||||
for r in recs), "no single write_file ground truth"
|
||||
assert any(r["delivered"].get("tool_calls") == ["write_file", "write_file"]
|
||||
for r in recs), "no parallel ground truth"
|
||||
|
||||
def main():
|
||||
fn = globals()["cmd_" + sys.argv[1].replace("-", "_")]
|
||||
fn(*sys.argv[2:])
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
PYEOF
|
||||
mk() { "$PY" "$TMP/helpers.py" "$@"; }
|
||||
|
||||
echo "=== stub-openai selftest ==="
|
||||
|
||||
# ---- normal mode ------------------------------------------------------------
|
||||
PORT="$(freeport)"
|
||||
"$PY" stub-openai.py --port "$PORT" --scenarios scenarios-openai.json \
|
||||
--log "$TMP/req.jsonl" >"$TMP/stub.out" 2>&1 &
|
||||
PIDS+=($!); disown
|
||||
check "stub starts and answers /gate/health" waithealth "$PORT"
|
||||
|
||||
# 1. plain completion
|
||||
mk plain "$TMP/plain.json" "oa-gate plain probe: explain the fixture topic simply."
|
||||
code="$(post "$PORT" "$TMP/plain.json" "$TMP/r_plain.json")"
|
||||
check "plain: HTTP 200" test "$code" = "200"
|
||||
check "plain: chat.completion envelope, finish stop, real content" mk chk "$TMP/r_plain.json" \
|
||||
'r["object"]=="chat.completion" and r["choices"][0]["finish_reason"]=="stop" and isinstance(r["choices"][0]["message"]["content"],str) and len(r["choices"][0]["message"]["content"])>40'
|
||||
|
||||
# 2. tools-off lane (chat-only request accepted, tool-bearing request refused)
|
||||
mk notools "$TMP/toolsoff.json" "oa-gate tools-off probe: plain chat with no tools offered."
|
||||
code="$(post "$PORT" "$TMP/toolsoff.json" "$TMP/r_toolsoff.json")"
|
||||
check "tools-off: chat-only request -> 200" test "$code" = "200"
|
||||
mk plain "$TMP/toolsoff_bad.json" "oa-gate tools-off probe: plain chat with no tools offered."
|
||||
code="$(post "$PORT" "$TMP/toolsoff_bad.json" "$TMP/r_toolsoff_bad.json")"
|
||||
check "tools-off negative: offering tools -> 400 gate_expect" \
|
||||
bash -c "test $code = 400"
|
||||
check "tools-off negative: reason names gate_expect" mk chk "$TMP/r_toolsoff_bad.json" \
|
||||
'r["error"]["code"]=="gate_expect"'
|
||||
|
||||
# 3. dialect-leak rejections (the loud-failure contract)
|
||||
code="$(post "$PORT" "$TMP/plain.json" "$TMP/r_leak_hdr.json" -H 'anthropic-version: 2023-06-01')"
|
||||
check "leak: anthropic-version header -> 400" test "$code" = "400"
|
||||
check "leak: header reason names the leak" mk chk "$TMP/r_leak_hdr.json" \
|
||||
'r["error"]["code"]=="gate_dialect_leak" and "anthropic-version" in r["error"]["message"]'
|
||||
mk mut "$TMP/leak_tools.json" "oa-gate plain probe: explain the fixture topic simply." anth-tools
|
||||
code="$(post "$PORT" "$TMP/leak_tools.json" "$TMP/r_leak_tools.json")"
|
||||
check "leak: input_schema tools -> 400 gate_dialect_leak" bash -c \
|
||||
"test $code = 400"
|
||||
check "leak: input_schema reason" mk chk "$TMP/r_leak_tools.json" \
|
||||
'r["error"]["code"]=="gate_dialect_leak" and "input_schema" in r["error"]["message"]'
|
||||
mk mut "$TMP/leak_sys.json" "oa-gate plain probe: explain the fixture topic simply." top-system
|
||||
code="$(post "$PORT" "$TMP/leak_sys.json" "$TMP/r_leak_sys.json")"
|
||||
check "leak: top-level system -> 400" test "$code" = "400"
|
||||
mk mut "$TMP/leak_block.json" "oa-gate plain probe: explain the fixture topic simply." anth-block
|
||||
code="$(post "$PORT" "$TMP/leak_block.json" "$TMP/r_leak_block.json")"
|
||||
check "leak: Anthropic tool_result content block -> 400" test "$code" = "400"
|
||||
|
||||
# 4. scenario request expectations
|
||||
mk mut "$TMP/no_tc.json" "oa-gate plain probe: explain the fixture topic simply." no-tool-choice
|
||||
code="$(post "$PORT" "$TMP/no_tc.json" "$TMP/r_no_tc.json")"
|
||||
check "expect: missing tool_choice -> 400" test "$code" = "400"
|
||||
mk mut "$TMP/ptc.json" "oa-gate plain probe: explain the fixture topic simply." ptc-true
|
||||
code="$(post "$PORT" "$TMP/ptc.json" "$TMP/r_ptc.json")"
|
||||
check "expect: parallel_tool_calls true -> 400 (ADR-0005 pin)" test "$code" = "400"
|
||||
|
||||
# 5. single tool round-trip
|
||||
ST_PROMPT="oa-gate single tool note: save the fixture note to a file."
|
||||
mk plain "$TMP/st1.json" "$ST_PROMPT"
|
||||
code="$(post "$PORT" "$TMP/st1.json" "$TMP/r_st1.json")"
|
||||
check "single-tool leg1: HTTP 200" test "$code" = "200"
|
||||
check "single-tool leg1: one write_file call, finish tool_calls, string args" mk chk "$TMP/r_st1.json" \
|
||||
'r["choices"][0]["finish_reason"]=="tool_calls" and len(r["choices"][0]["message"]["tool_calls"])==1 and r["choices"][0]["message"]["tool_calls"][0]["type"]=="function" and r["choices"][0]["message"]["tool_calls"][0]["function"]["name"]=="write_file" and isinstance(r["choices"][0]["message"]["tool_calls"][0]["function"]["arguments"],str) and json.loads(r["choices"][0]["message"]["tool_calls"][0]["function"]["arguments"])["path"]=="openai-single-note.md"'
|
||||
mk chain "$TMP/st2.json" "$ST_PROMPT" ok "$TMP/r_st1.json"
|
||||
code="$(post "$PORT" "$TMP/st2.json" "$TMP/r_st2.json")"
|
||||
check "single-tool leg2: echo + tool turn -> 200 final text" test "$code" = "200"
|
||||
check "single-tool leg2: final names the file, finish stop" mk chk "$TMP/r_st2.json" \
|
||||
'r["choices"][0]["finish_reason"]=="stop" and "openai-single-note.md" in r["choices"][0]["message"]["content"]'
|
||||
mk chain "$TMP/st2_no.json" "$ST_PROMPT" no-tool-turn "$TMP/r_st1.json"
|
||||
code="$(post "$PORT" "$TMP/st2_no.json" "$TMP/r_st2_no.json")"
|
||||
check "single-tool negative: echo without tool turn -> 400 gate_pairing" \
|
||||
bash -c "test $code = 400"
|
||||
check "single-tool negative: pairing reason" mk chk "$TMP/r_st2_no.json" \
|
||||
'r["error"]["code"]=="gate_pairing"'
|
||||
mk chain "$TMP/st2_wrong.json" "$ST_PROMPT" wrong-id "$TMP/r_st1.json"
|
||||
code="$(post "$PORT" "$TMP/st2_wrong.json" "$TMP/r_st2_wrong.json")"
|
||||
check "single-tool negative: wrong tool_call_id -> 400" test "$code" = "400"
|
||||
mk chain "$TMP/st2_obj.json" "$ST_PROMPT" object-args "$TMP/r_st1.json"
|
||||
code="$(post "$PORT" "$TMP/st2_obj.json" "$TMP/r_st2_obj.json")"
|
||||
check "single-tool negative: arguments echoed as object -> 400 shape" \
|
||||
bash -c "test $code = 400"
|
||||
check "single-tool negative: shape reason names STRING" mk chk "$TMP/r_st2_obj.json" \
|
||||
'r["error"]["code"]=="gate_tool_call_shape" and "STRING" in r["error"]["message"]'
|
||||
|
||||
# 6. escaping torture (the two-escaper trap, spec section 6)
|
||||
T_PROMPT="oa-gate torture probe: write the escaping torture file."
|
||||
mk plain "$TMP/t1.json" "$T_PROMPT"
|
||||
code="$(post "$PORT" "$TMP/t1.json" "$TMP/r_t1.json")"
|
||||
check "torture leg1: HTTP 200" test "$code" = "200"
|
||||
check "torture leg1: arguments decode to the exact nasty payload" \
|
||||
mk torture "$TMP/r_t1.json" scenarios-openai.json
|
||||
mk chain "$TMP/t2.json" "$T_PROMPT" ok "$TMP/r_t1.json"
|
||||
code="$(post "$PORT" "$TMP/t2.json" "$TMP/r_t2.json")"
|
||||
check "torture leg2: faithful echo -> 200 final" test "$code" = "200"
|
||||
mk chain "$TMP/t2_dbl.json" "$T_PROMPT" double-encode "$TMP/r_t1.json"
|
||||
code="$(post "$PORT" "$TMP/t2_dbl.json" "$TMP/r_t2_dbl.json")"
|
||||
check "torture negative: double-encoded echo -> 400" test "$code" = "400"
|
||||
check "torture negative: reason names the two-escaper trap" mk chk "$TMP/r_t2_dbl.json" \
|
||||
'r["error"]["code"]=="gate_echo_mismatch" and "two-escaper" in r["error"]["message"]'
|
||||
|
||||
# 7. parallel double-call
|
||||
P_PROMPT="oa-gate parallel probe: run the two-write parallel case."
|
||||
mk plain "$TMP/p1.json" "$P_PROMPT"
|
||||
code="$(post "$PORT" "$TMP/p1.json" "$TMP/r_p1.json")"
|
||||
check "parallel leg1: TWO tool_calls, distinct ids" mk chk "$TMP/r_p1.json" \
|
||||
'r["choices"][0]["finish_reason"]=="tool_calls" and len(r["choices"][0]["message"]["tool_calls"])==2 and r["choices"][0]["message"]["tool_calls"][0]["id"]!=r["choices"][0]["message"]["tool_calls"][1]["id"]'
|
||||
mk chain "$TMP/p2.json" "$P_PROMPT" ok "$TMP/r_p1.json"
|
||||
code="$(post "$PORT" "$TMP/p2.json" "$TMP/r_p2.json")"
|
||||
check "parallel leg2: both results -> 200 final" test "$code" = "200"
|
||||
mk chain "$TMP/p2_one.json" "$P_PROMPT" only-first "$TMP/r_p1.json"
|
||||
code="$(post "$PORT" "$TMP/p2_one.json" "$TMP/r_p2_one.json")"
|
||||
check "parallel negative: answering only one call -> 400 pairing" test "$code" = "400"
|
||||
|
||||
# 8. two-round mission (loop continuation + step indexing)
|
||||
M_PROMPT="oa-gate mission probe: run the two-round mission."
|
||||
mk plain "$TMP/m1.json" "$M_PROMPT"
|
||||
code="$(post "$PORT" "$TMP/m1.json" "$TMP/r_m1.json")"
|
||||
check "mission leg1: part-1 tool call" mk chk "$TMP/r_m1.json" \
|
||||
'json.loads(r["choices"][0]["message"]["tool_calls"][0]["function"]["arguments"])["path"]=="mission-part-1.md"'
|
||||
mk chain "$TMP/m2.json" "$M_PROMPT" ok "$TMP/r_m1.json"
|
||||
code="$(post "$PORT" "$TMP/m2.json" "$TMP/r_m2.json")"
|
||||
check "mission leg2: part-2 tool call (step indexed by assistant count)" mk chk "$TMP/r_m2.json" \
|
||||
'r["choices"][0]["finish_reason"]=="tool_calls" and json.loads(r["choices"][0]["message"]["tool_calls"][0]["function"]["arguments"])["path"]=="mission-part-2.md"'
|
||||
mk chain "$TMP/m3.json" "$M_PROMPT" ok "$TMP/r_m1.json" "$TMP/r_m2.json"
|
||||
code="$(post "$PORT" "$TMP/m3.json" "$TMP/r_m3.json")"
|
||||
check "mission leg3: final text, finish stop" mk chk "$TMP/r_m3.json" \
|
||||
'r["choices"][0]["finish_reason"]=="stop" and "Mission complete" in r["choices"][0]["message"]["content"]'
|
||||
mk chain "$TMP/m4.json" "$M_PROMPT" ok "$TMP/r_m1.json" "$TMP/r_m2.json" "$TMP/r_m3.json"
|
||||
code="$(post "$PORT" "$TMP/m4.json" "$TMP/r_m4.json")"
|
||||
check "mission overrun: past-script request -> GATE-SCRIPT-EXHAUSTED" mk chk "$TMP/r_m4.json" \
|
||||
'r["choices"][0]["message"]["content"].startswith("GATE-SCRIPT-EXHAUSTED")'
|
||||
|
||||
# 9. injected API errors (OpenAI error envelope)
|
||||
for want in 400 429 500 503; do
|
||||
case "$want" in
|
||||
400) marker="four hundred";; 429) marker="rate limit";;
|
||||
500) marker="five hundred";; 503) marker="unavailable";;
|
||||
esac
|
||||
mk plain "$TMP/e_$want.json" "oa-gate error $marker: trigger the injected failure."
|
||||
code="$(post "$PORT" "$TMP/e_$want.json" "$TMP/r_e_$want.json")"
|
||||
check "api-error $want: status returned" test "$code" = "$want"
|
||||
check "api-error $want: OpenAI error envelope" mk chk "$TMP/r_e_$want.json" \
|
||||
'isinstance(r["error"]["message"],str) and "gate-injected" in r["error"]["message"] and isinstance(r["error"]["type"],str)'
|
||||
done
|
||||
|
||||
# 10. background (unmatched) request
|
||||
mk plain "$TMP/bg.json" "hello there, just a boot probe with no marker"
|
||||
code="$(post "$PORT" "$TMP/bg.json" "$TMP/r_bg.json")"
|
||||
check "background: unmatched prompt -> benign ok" mk chk "$TMP/r_bg.json" \
|
||||
'r["choices"][0]["message"]["content"]=="ok"'
|
||||
|
||||
# 11. ground-truth log invariants
|
||||
check "ground-truth JSONL log invariants" mk logcheck "$TMP/req.jsonl"
|
||||
|
||||
# 12. production-port refusal
|
||||
rc=0
|
||||
"$PY" stub-openai.py --port 7770 --scenarios scenarios-openai.json \
|
||||
--log "$TMP/never.jsonl" >/dev/null 2>&1 || rc=$?
|
||||
check "refuses production port 7770" test "$rc" -ne 0
|
||||
|
||||
# ---- hostile mode: black-hole ----------------------------------------------
|
||||
BH="$(freeport)"
|
||||
"$PY" stub-openai.py --port "$BH" --log "$TMP/bh.jsonl" --mode black-hole \
|
||||
>/dev/null 2>&1 &
|
||||
PIDS+=($!); disown
|
||||
check "black-hole: healthy" waithealth "$BH"
|
||||
rc=0
|
||||
curl -s -o /dev/null --max-time 3 -H 'content-type: application/json' \
|
||||
--data-binary @"$TMP/plain.json" \
|
||||
"http://127.0.0.1:$BH/v1/chat/completions" || rc=$?
|
||||
check "black-hole: client times out (curl rc 28)" test "$rc" -eq 28
|
||||
check "black-hole: health still answers during the hang" \
|
||||
curl -sf --max-time 2 "http://127.0.0.1:$BH/gate/health"
|
||||
|
||||
# ---- hostile mode: mid-body-drop -------------------------------------------
|
||||
MD="$(freeport)"
|
||||
"$PY" stub-openai.py --port "$MD" --log "$TMP/md.jsonl" --mode mid-body-drop \
|
||||
>/dev/null 2>&1 &
|
||||
PIDS+=($!); disown
|
||||
check "mid-body-drop: healthy" waithealth "$MD"
|
||||
rc=0
|
||||
curl -s --max-time 5 -o "$TMP/half.json" -H 'content-type: application/json' \
|
||||
--data-binary @"$TMP/plain.json" \
|
||||
"http://127.0.0.1:$MD/v1/chat/completions" || rc=$?
|
||||
check "mid-body-drop: transfer fails (curl rc $rc)" test "$rc" -ne 0
|
||||
check "mid-body-drop: partial body is not parseable JSON" mk notjson "$TMP/half.json"
|
||||
|
||||
# ---- hostile mode: tool-pending-forever ------------------------------------
|
||||
TP="$(freeport)"
|
||||
"$PY" stub-openai.py --port "$TP" --log "$TMP/tp.jsonl" \
|
||||
--mode tool-pending-forever >/dev/null 2>&1 &
|
||||
PIDS+=($!); disown
|
||||
check "tool-pending-forever: healthy" waithealth "$TP"
|
||||
for i in 1 2 3; do
|
||||
code="$(post "$TP" "$TMP/plain.json" "$TMP/r_tp$i.json")"
|
||||
check "tool-pending-forever: request $i -> 200" test "$code" = "200"
|
||||
done
|
||||
check "tool-pending-forever: three FRESH tool_calls, distinct ids" \
|
||||
mk pending "$TMP/r_tp1.json" "$TMP/r_tp2.json" "$TMP/r_tp3.json"
|
||||
check "tool-pending-forever: /gate/stats counts 3 chat hits" \
|
||||
bash -c "curl -sf http://127.0.0.1:$TP/gate/stats | grep -q '\"chat_hits\": 3'"
|
||||
|
||||
# ---- summary ----------------------------------------------------------------
|
||||
echo
|
||||
echo "selftest: $PASS passed, $FAIL failed"
|
||||
if [ "$FAIL" -ne 0 ]; then
|
||||
echo "SELFTEST RED"
|
||||
exit 1
|
||||
fi
|
||||
echo "SELFTEST GREEN (stub-openai gate scaffolding verified)"
|
||||
@@ -1,652 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
"""stub-openai.py - deterministic local stand-in for an OpenAI-format
|
||||
/v1/chat/completions provider, for the soul-openai-tools-v2 gate
|
||||
(docs/specs/SPEC-soul-openai-tools-v2-2026-08-06.md). No API key, no network,
|
||||
no model.
|
||||
|
||||
Sibling of gate9's stub-llm.py (Anthropic dialect, _wt-beta-round9/scripts/
|
||||
gate9/): same scenario mechanism (marker matching, assistant-count step
|
||||
indexing, ground-truth JSONL log, prod-port refusal), different wire.
|
||||
Staging home is tests/gate-openai/ in _wt-openai-tools; folds into
|
||||
scripts/gate9/ after round 9 merges (see README.md).
|
||||
|
||||
WHAT IT DOES
|
||||
* Serves POST /v1/chat/completions on 127.0.0.1 only (OpenAI dialect).
|
||||
* VALIDATES every request - this is the gate's discriminator, built
|
||||
BEFORE the brain-side El code exists so dialect leakage fails loudly:
|
||||
- Anthropic tells are 400 code=gate_dialect_leak: `anthropic-version`
|
||||
header; top-level `system` / `stop_sequences` / `max_tokens_to_sample`
|
||||
/ `anthropic_version`; `input_schema` inside a tool entry; Anthropic
|
||||
content blocks (tool_use / tool_result / server_tool_use / ...).
|
||||
- tools[] must be OpenAI-shaped {type:"function", function:{name,
|
||||
description, parameters}} with unique names -> 400 gate_tools_shape.
|
||||
- assistant tool_calls echoes must be {id, type:"function",
|
||||
function:{name, arguments:<JSON-encoded STRING>}}; a decoded-object
|
||||
`arguments` is a wire bug -> 400 gate_tool_call_shape.
|
||||
- every assistant tool_calls turn must be answered by role:"tool"
|
||||
messages covering EVERY tool_call_id, immediately following;
|
||||
unknown / duplicate / missing ids -> 400 gate_pairing.
|
||||
- echoed `arguments` for gate-issued call ids (call_gate_*) are
|
||||
recomputed from the script and compared after ONE json decode ->
|
||||
400 gate_echo_mismatch. This is the two-escaper-trap discriminator
|
||||
named in the spec's security model (section 6).
|
||||
- scenario-level request expectations from scenarios-openai.json
|
||||
(tools offered, OpenAI-shaped tool_choice, parallel_tool_calls
|
||||
pinned false per ADR-0005) -> 400 gate_expect.
|
||||
* Answers with SCRIPTED responses: plain text (finish_reason "stop"),
|
||||
tool calls (finish_reason "tool_calls", arguments JSON-encoded, incl. a
|
||||
nested-quote/escaping torture payload and a parallel two-call case), and
|
||||
API-error injection (OpenAI error envelope). Scenario is selected by
|
||||
scanning user-message text (newest first) for a registered marker
|
||||
substring; the step index is the number of assistant messages already in
|
||||
the request (stateless replay - resumes index correctly by construction).
|
||||
* Writes a ground-truth JSONL log (--log): one record per request with the
|
||||
validation verdict, matched scenario/step, and exactly which tool calls
|
||||
were delivered. Gate assertions compare the brain's claims against THIS
|
||||
log - truth, not narration.
|
||||
* Unmatched requests (boot probes, awareness chatter) get a benign "ok"
|
||||
text response, logged kind=background, never counted as ground truth.
|
||||
* HOSTILE MODES (--mode) on the same file:
|
||||
black-hole accept + read the request, never respond;
|
||||
mid-body-drop send half a JSON body, then abort the socket;
|
||||
tool-pending-forever every request gets a FRESH tool_call
|
||||
(finish_reason "tool_calls"), forever - tests
|
||||
the agentic loop's iteration cap; count the
|
||||
brain's round-trips via GET /gate/stats.
|
||||
|
||||
usage: stub-openai.py --port P --scenarios scenarios-openai.json \
|
||||
--log requests.jsonl [--mode MODE]
|
||||
Listens on 127.0.0.1 only. Refuses production ports 7770/7779/17779.
|
||||
"""
|
||||
import argparse
|
||||
import itertools
|
||||
import json
|
||||
import socket
|
||||
import struct
|
||||
import threading
|
||||
import time
|
||||
import uuid
|
||||
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
|
||||
|
||||
STATE = {"scenarios": None, "log_path": None, "lock": threading.Lock(),
|
||||
"seq": 0, "mode": "normal", "chat_hits": 0}
|
||||
_PENDING_SEQ = itertools.count(1)
|
||||
|
||||
ANTHROPIC_TOP_KEYS = ("system", "stop_sequences", "max_tokens_to_sample",
|
||||
"anthropic_version")
|
||||
ANTHROPIC_BLOCK_TYPES = {"tool_use", "tool_result", "server_tool_use",
|
||||
"web_search_tool_result", "thinking",
|
||||
"redacted_thinking"}
|
||||
DEFAULT_EXPECT = {"require_tools": True, "require_tool_choice": True,
|
||||
"parallel_tool_calls": False, "forbid_tools": False}
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- loading ----
|
||||
def load_scenarios(path):
|
||||
cfg = json.load(open(path))
|
||||
defaults = dict(DEFAULT_EXPECT)
|
||||
defaults.update(cfg.get("defaults", {}).get("expect_request", {}))
|
||||
marker_map = [] # (marker_lower, cname, pid)
|
||||
scripts = {} # cname or cname/pid -> expanded script
|
||||
pid_map = {} # pid -> cname (for call_gate_* id -> script lookup)
|
||||
expects = {} # cname -> merged expect_request
|
||||
for cname, cls in cfg["classes"].items():
|
||||
scripts[cname] = expand_script(cls.get("script", []))
|
||||
exp = dict(defaults)
|
||||
exp.update(cls.get("expect_request", {}))
|
||||
expects[cname] = exp
|
||||
for ph in cls["phrasings"]:
|
||||
if ph.get("script") is not None:
|
||||
scripts[cname + "/" + ph["id"]] = expand_script(ph["script"])
|
||||
marker_map.append((ph["marker"].lower(), cname, ph["id"]))
|
||||
pid_map[ph["id"]] = cname
|
||||
return {"cfg": cfg, "marker_map": marker_map, "scripts": scripts,
|
||||
"pid_map": pid_map, "expects": expects}
|
||||
|
||||
|
||||
def expand_script(script):
|
||||
"""Same repeat-expansion contract as gate9's stub-llm.py ({N}/{NN})."""
|
||||
out = []
|
||||
for step in script:
|
||||
if "repeat" in step:
|
||||
for n in range(1, step["repeat"] + 1):
|
||||
t = {k: v for k, v in step.items() if k != "repeat"}
|
||||
out.append(json.loads(json.dumps(t)
|
||||
.replace("{NN}", "%02d" % n)
|
||||
.replace("{N}", str(n))))
|
||||
else:
|
||||
out.append(step)
|
||||
return out
|
||||
|
||||
|
||||
# ------------------------------------------------------------- validation ----
|
||||
def _rej(message, code):
|
||||
return {"status": 400, "message": message, "code": code}
|
||||
|
||||
|
||||
def validate_dialect(headers, req):
|
||||
"""Universal checks - run on EVERY request, scenario-matched or not.
|
||||
Anything Anthropic-shaped on this lane means the brain's translator
|
||||
leaked; the whole point is that it fails loudly, here, with a reason."""
|
||||
if headers.get("anthropic-version"):
|
||||
return _rej("anthropic-version header on the OpenAI lane: this "
|
||||
"request was built by the Anthropic dialect path",
|
||||
"gate_dialect_leak")
|
||||
for k in ANTHROPIC_TOP_KEYS:
|
||||
if k in req:
|
||||
return _rej("top-level `%s` is Anthropic dialect; the OpenAI "
|
||||
"dialect has no such field (system prompt goes in "
|
||||
"messages[0])" % k, "gate_dialect_leak")
|
||||
tools = req.get("tools")
|
||||
if tools is not None:
|
||||
if not isinstance(tools, list):
|
||||
return _rej("`tools` must be an array", "gate_tools_shape")
|
||||
names = []
|
||||
for i, t in enumerate(tools):
|
||||
if not isinstance(t, dict):
|
||||
return _rej("tools[%d] is not an object" % i,
|
||||
"gate_tools_shape")
|
||||
if "input_schema" in t or (isinstance(t.get("function"), dict)
|
||||
and "input_schema" in t["function"]):
|
||||
return _rej("tools[%d] carries `input_schema` (Anthropic "
|
||||
"dialect); OpenAI dialect wants "
|
||||
"function.parameters" % i, "gate_dialect_leak")
|
||||
if t.get("type") != "function":
|
||||
return _rej("tools[%d].type must be \"function\", got %r"
|
||||
% (i, t.get("type")), "gate_tools_shape")
|
||||
fn = t.get("function")
|
||||
if not isinstance(fn, dict):
|
||||
return _rej("tools[%d].function missing" % i,
|
||||
"gate_tools_shape")
|
||||
if not isinstance(fn.get("name"), str) or not fn["name"]:
|
||||
return _rej("tools[%d].function.name missing/empty" % i,
|
||||
"gate_tools_shape")
|
||||
if not isinstance(fn.get("description"), str) or not fn["description"]:
|
||||
return _rej("tools[%d].function.description missing/empty" % i,
|
||||
"gate_tools_shape")
|
||||
if not isinstance(fn.get("parameters"), dict):
|
||||
return _rej("tools[%d].function.parameters missing (JSON "
|
||||
"Schema object expected)" % i, "gate_tools_shape")
|
||||
names.append(fn["name"])
|
||||
if len(names) != len(set(names)):
|
||||
return _rej("tools: tool names must be unique", "gate_tools_shape")
|
||||
msgs = req.get("messages")
|
||||
if not isinstance(msgs, list) or not msgs:
|
||||
return _rej("`messages` must be a non-empty array",
|
||||
"gate_messages_shape")
|
||||
for i, m in enumerate(msgs):
|
||||
if not isinstance(m, dict):
|
||||
return _rej("messages[%d] is not an object" % i,
|
||||
"gate_messages_shape")
|
||||
c = m.get("content")
|
||||
if isinstance(c, list):
|
||||
for j, b in enumerate(c):
|
||||
if isinstance(b, dict) and b.get("type") in ANTHROPIC_BLOCK_TYPES:
|
||||
return _rej("messages[%d].content[%d] is an Anthropic "
|
||||
"`%s` block; the OpenAI dialect uses "
|
||||
"tool_calls / role:\"tool\" messages"
|
||||
% (i, j, b.get("type")), "gate_dialect_leak")
|
||||
if m.get("role") == "tool":
|
||||
if not isinstance(m.get("tool_call_id"), str) or not m["tool_call_id"]:
|
||||
return _rej("messages[%d]: role \"tool\" requires a "
|
||||
"`tool_call_id`" % i, "gate_messages_shape")
|
||||
if "content" not in m:
|
||||
return _rej("messages[%d]: role \"tool\" requires `content`"
|
||||
% i, "gate_messages_shape")
|
||||
if m.get("role") == "assistant" and m.get("tool_calls") is not None:
|
||||
tcs = m["tool_calls"]
|
||||
if not isinstance(tcs, list) or not tcs:
|
||||
return _rej("messages[%d].tool_calls must be a non-empty "
|
||||
"array" % i, "gate_tool_call_shape")
|
||||
for j, tc in enumerate(tcs):
|
||||
if not isinstance(tc, dict) or tc.get("type") != "function":
|
||||
return _rej("messages[%d].tool_calls[%d].type must be "
|
||||
"\"function\"" % (i, j), "gate_tool_call_shape")
|
||||
if not isinstance(tc.get("id"), str) or not tc["id"]:
|
||||
return _rej("messages[%d].tool_calls[%d].id missing"
|
||||
% (i, j), "gate_tool_call_shape")
|
||||
fn = tc.get("function")
|
||||
if not isinstance(fn, dict) or not isinstance(fn.get("name"), str):
|
||||
return _rej("messages[%d].tool_calls[%d].function.name "
|
||||
"missing" % (i, j), "gate_tool_call_shape")
|
||||
if not isinstance(fn.get("arguments"), str):
|
||||
return _rej("messages[%d].tool_calls[%d].function."
|
||||
"arguments must be a JSON-encoded STRING, "
|
||||
"got %s" % (i, j,
|
||||
type(fn.get("arguments")).__name__),
|
||||
"gate_tool_call_shape")
|
||||
return None
|
||||
|
||||
|
||||
def validate_pairing(msgs):
|
||||
"""OpenAI pairing rule: every assistant tool_calls turn must be followed
|
||||
immediately by role:"tool" messages answering every tool_call_id."""
|
||||
open_ids, open_at = set(), None
|
||||
for i, m in enumerate(msgs):
|
||||
role = m.get("role")
|
||||
if role == "tool":
|
||||
tid = m.get("tool_call_id")
|
||||
if open_at is None:
|
||||
return _rej("messages[%d]: role \"tool\" message with no "
|
||||
"preceding assistant tool_calls turn "
|
||||
"(tool_call_id=%s)" % (i, tid), "gate_pairing")
|
||||
if tid not in open_ids:
|
||||
return _rej("messages[%d]: tool message answers unknown or "
|
||||
"already-answered tool_call_id %s" % (i, tid),
|
||||
"gate_pairing")
|
||||
open_ids.discard(tid)
|
||||
continue
|
||||
if open_ids:
|
||||
return _rej("messages[%d]: assistant tool_calls not fully "
|
||||
"answered before messages[%d]; missing tool "
|
||||
"responses for: %s" % (open_at, i, sorted(open_ids)),
|
||||
"gate_pairing")
|
||||
open_ids, open_at = set(), None
|
||||
if role == "assistant" and m.get("tool_calls"):
|
||||
ids = [tc.get("id") for tc in m["tool_calls"]]
|
||||
open_ids, open_at = set(ids), i
|
||||
if open_ids:
|
||||
return _rej("messages[%d]: assistant tool_calls at end of thread "
|
||||
"without tool responses for: %s"
|
||||
% (open_at, sorted(open_ids)), "gate_pairing")
|
||||
return None
|
||||
|
||||
|
||||
def validate_echo_args(msgs, loaded):
|
||||
"""Ground-truth round-trip check: for every echoed gate-issued call id,
|
||||
recompute the arguments this stub originally sent from the script and
|
||||
require one json decode to reproduce them exactly. Catches the
|
||||
two-escaper trap (spec section 6) deterministically."""
|
||||
if not loaded:
|
||||
return None
|
||||
for i, m in enumerate(msgs):
|
||||
if m.get("role") != "assistant":
|
||||
continue
|
||||
for tc in m.get("tool_calls") or []:
|
||||
tid = tc.get("id", "")
|
||||
if not tid.startswith("call_gate_"):
|
||||
continue
|
||||
rest = tid[len("call_gate_"):]
|
||||
try:
|
||||
pid, s_part, k_part = rest.rsplit("_", 2)
|
||||
step_idx, k = int(s_part[1:]), int(k_part)
|
||||
except (ValueError, IndexError):
|
||||
continue
|
||||
cname = loaded["pid_map"].get(pid)
|
||||
if cname is None:
|
||||
continue
|
||||
script = (loaded["scripts"].get(cname + "/" + pid)
|
||||
or loaded["scripts"].get(cname) or [])
|
||||
if step_idx >= len(script):
|
||||
continue
|
||||
calls = script[step_idx].get("tool_calls") or []
|
||||
if k >= len(calls):
|
||||
continue
|
||||
expected = calls[k]
|
||||
fn = tc.get("function") or {}
|
||||
if fn.get("name") != expected["name"]:
|
||||
return _rej("messages[%d]: echoed tool name %r != issued %r "
|
||||
"for %s" % (i, fn.get("name"), expected["name"],
|
||||
tid), "gate_echo_mismatch")
|
||||
try:
|
||||
got = json.loads(fn.get("arguments", ""))
|
||||
except ValueError:
|
||||
return _rej("messages[%d]: echoed arguments for %s are not "
|
||||
"valid JSON after one decode (truncated or "
|
||||
"half-escaped?)" % (i, tid), "gate_echo_mismatch")
|
||||
if got != expected["arguments"]:
|
||||
hint = (" (decoded to a string, not an object: "
|
||||
"double-encoded - the two-escaper trap)"
|
||||
if isinstance(got, str) else "")
|
||||
return _rej("messages[%d]: echoed arguments for %s do not "
|
||||
"round-trip to the issued payload%s"
|
||||
% (i, tid, hint), "gate_echo_mismatch")
|
||||
return None
|
||||
|
||||
|
||||
def validate_expect(req, exp):
|
||||
"""Scenario-level request expectations (scenarios-openai.json)."""
|
||||
tools = req.get("tools") or []
|
||||
if exp.get("forbid_tools") and tools:
|
||||
return _rej("this scenario is chat-only: no `tools` may be offered "
|
||||
"on it", "gate_expect")
|
||||
if exp.get("require_tools") and not tools:
|
||||
return _rej("scenario expects a `tools` array to be offered (the "
|
||||
"agentic lane must advertise its tools)", "gate_expect")
|
||||
if exp.get("require_tool_choice"):
|
||||
tc = req.get("tool_choice")
|
||||
ok = tc in ("auto", "none", "required") or (
|
||||
isinstance(tc, dict) and tc.get("type") == "function"
|
||||
and isinstance(tc.get("function"), dict)
|
||||
and tc["function"].get("name"))
|
||||
if not ok:
|
||||
return _rej("scenario expects an OpenAI-shaped `tool_choice`, "
|
||||
"got %r" % (tc,), "gate_expect")
|
||||
want_ptc = exp.get("parallel_tool_calls", None)
|
||||
if want_ptc is not None:
|
||||
if "parallel_tool_calls" not in req:
|
||||
return _rej("scenario expects explicit `parallel_tool_calls` "
|
||||
"(ADR-0005: must be pinned false on the wire)",
|
||||
"gate_expect")
|
||||
if req["parallel_tool_calls"] != want_ptc:
|
||||
return _rej("scenario expects parallel_tool_calls=%s, got %s"
|
||||
% (json.dumps(want_ptc),
|
||||
json.dumps(req["parallel_tool_calls"])),
|
||||
"gate_expect")
|
||||
return None
|
||||
|
||||
|
||||
# --------------------------------------------------------- scenario match ----
|
||||
def extract_user_texts_newest_first(msgs):
|
||||
texts = []
|
||||
for m in reversed(msgs):
|
||||
if not isinstance(m, dict) or m.get("role") != "user":
|
||||
continue
|
||||
c = m.get("content")
|
||||
if isinstance(c, str):
|
||||
texts.append(c)
|
||||
elif isinstance(c, list):
|
||||
for b in c:
|
||||
if isinstance(b, dict) and b.get("type") == "text":
|
||||
texts.append(b.get("text", ""))
|
||||
return texts
|
||||
|
||||
|
||||
def match_scenario(loaded, msgs):
|
||||
for text in extract_user_texts_newest_first(msgs):
|
||||
tl = text.lower()
|
||||
for marker, cname, pid in loaded["marker_map"]:
|
||||
if marker in tl:
|
||||
return cname, pid
|
||||
return None, None
|
||||
|
||||
|
||||
# ------------------------------------------------------------- rendering ----
|
||||
def completion_envelope(msg, finish, model, usage=(100, 100)):
|
||||
return {"id": "chatcmpl-gate-" + uuid.uuid4().hex[:12],
|
||||
"object": "chat.completion", "created": int(time.time()),
|
||||
"model": model,
|
||||
"choices": [{"index": 0, "message": msg,
|
||||
"finish_reason": finish, "logprobs": None}],
|
||||
"usage": {"prompt_tokens": usage[0],
|
||||
"completion_tokens": usage[1],
|
||||
"total_tokens": usage[0] + usage[1]}}
|
||||
|
||||
|
||||
def text_completion(text, model):
|
||||
return completion_envelope({"role": "assistant", "content": text},
|
||||
"stop", model, usage=(1, 1))
|
||||
|
||||
|
||||
def pending_body(seq, model):
|
||||
args = json.dumps({"path": "never-%04d.md" % seq,
|
||||
"content": "this run never completes"})
|
||||
msg = {"role": "assistant", "content": None,
|
||||
"tool_calls": [{"id": "call_hostile_pending_%04d" % seq,
|
||||
"type": "function",
|
||||
"function": {"name": "write_file",
|
||||
"arguments": args}}]}
|
||||
return completion_envelope(msg, "tool_calls", model, usage=(1, 1))
|
||||
|
||||
|
||||
def render_step(step, cname, pid, step_idx, model):
|
||||
"""Returns (http_status, body_dict, delivered) - delivered is ground
|
||||
truth for the JSONL log."""
|
||||
delivered = {"tool_calls": [], "finish_reason": None, "api_error": None}
|
||||
if "api_error" in step:
|
||||
e = step["api_error"]
|
||||
delivered["api_error"] = e["status"]
|
||||
return (e["status"],
|
||||
{"error": {"message": e["message"],
|
||||
"type": e.get("type", "server_error"),
|
||||
"param": None, "code": e.get("code")}},
|
||||
delivered)
|
||||
msg = {"role": "assistant"}
|
||||
finish = "stop"
|
||||
if step.get("tool_calls"):
|
||||
tcs = []
|
||||
for k, call in enumerate(step["tool_calls"]):
|
||||
tid = "call_gate_%s_s%d_%d" % (pid, step_idx, k)
|
||||
tcs.append({"id": tid, "type": "function",
|
||||
"function": {"name": call["name"],
|
||||
"arguments": json.dumps(
|
||||
call["arguments"],
|
||||
ensure_ascii=False)}})
|
||||
delivered["tool_calls"].append(call["name"])
|
||||
msg["tool_calls"] = tcs
|
||||
msg["content"] = step.get("text") # null when no narration, like real
|
||||
finish = "tool_calls"
|
||||
else:
|
||||
msg["content"] = step["text"]
|
||||
delivered["finish_reason"] = finish
|
||||
return 200, completion_envelope(msg, finish, model), delivered
|
||||
|
||||
|
||||
# ------------------------------------------------------------------ log ------
|
||||
def log_record(rec):
|
||||
with STATE["lock"]:
|
||||
STATE["seq"] += 1
|
||||
rec["seq"] = STATE["seq"]
|
||||
with open(STATE["log_path"], "a") as f:
|
||||
f.write(json.dumps(rec, ensure_ascii=False) + "\n")
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- server -----
|
||||
class Handler(BaseHTTPRequestHandler):
|
||||
protocol_version = "HTTP/1.1"
|
||||
|
||||
def _send_json(self, status, obj):
|
||||
body = json.dumps(obj, ensure_ascii=False).encode("utf-8")
|
||||
self.send_response(status)
|
||||
self.send_header("Content-Type", "application/json")
|
||||
self.send_header("Content-Length", str(len(body)))
|
||||
self.end_headers()
|
||||
self.wfile.write(body)
|
||||
|
||||
def _send_error(self, verdict):
|
||||
self._send_json(verdict["status"],
|
||||
{"error": {"message": verdict["message"],
|
||||
"type": "invalid_request_error",
|
||||
"param": None, "code": verdict["code"]}})
|
||||
|
||||
def _drop_mid_body(self):
|
||||
"""Valid 200 headers, half the promised body, then a socket abort
|
||||
(same SO_LINGER teardown as gate9's mid-body-drop-brain.py)."""
|
||||
full = json.dumps(text_completion(
|
||||
"This reply will never finish arriving because the connection "
|
||||
"dies in the middle of the body, which is exactly the point of "
|
||||
"this hostile fixture.", "hostile-mid-drop")).encode("utf-8")
|
||||
half = full[: len(full) // 2]
|
||||
self.send_response(200)
|
||||
self.send_header("Content-Type", "application/json")
|
||||
self.send_header("Content-Length", str(len(full))) # promises more
|
||||
self.end_headers()
|
||||
self.wfile.write(half)
|
||||
self.wfile.flush()
|
||||
try:
|
||||
self.connection.setsockopt(socket.SOL_SOCKET, socket.SO_LINGER,
|
||||
struct.pack("ii", 1, 0))
|
||||
self.connection.shutdown(socket.SHUT_RDWR)
|
||||
except OSError:
|
||||
pass
|
||||
self.close_connection = True
|
||||
|
||||
def do_GET(self):
|
||||
path = self.path.split("?")[0]
|
||||
if path == "/gate/health":
|
||||
self._send_json(200, {"ok": True, "mode": STATE["mode"]})
|
||||
elif path == "/gate/stats":
|
||||
with STATE["lock"]:
|
||||
self._send_json(200, {"mode": STATE["mode"],
|
||||
"chat_hits": STATE["chat_hits"]})
|
||||
else:
|
||||
self._send_json(404, {"error": {"message": "not found",
|
||||
"type": "invalid_request_error",
|
||||
"param": None,
|
||||
"code": "unknown_route"}})
|
||||
|
||||
def do_POST(self):
|
||||
n = int(self.headers.get("Content-Length") or 0)
|
||||
raw = self.rfile.read(n)
|
||||
mode = STATE["mode"]
|
||||
rec = {"ts": time.time(), "path": self.path, "mode": mode,
|
||||
"kind": "background", "scenario_class": None, "phrasing": None,
|
||||
"step": None, "n_messages": 0, "n_assistant": 0,
|
||||
"validation": "ok", "validation_detail": None,
|
||||
"delivered": {"tool_calls": [], "finish_reason": None,
|
||||
"api_error": None},
|
||||
"http_status": 200}
|
||||
if self.path.split("?")[0] != "/v1/chat/completions":
|
||||
rec.update(kind="wrong_path", http_status=404)
|
||||
log_record(rec)
|
||||
self._send_json(404, {"error": {
|
||||
"message": "no such route: %s" % self.path,
|
||||
"type": "invalid_request_error", "param": None,
|
||||
"code": "unknown_route"}})
|
||||
return
|
||||
with STATE["lock"]:
|
||||
STATE["chat_hits"] += 1
|
||||
|
||||
# ---- hostile modes: behavior first, no validation ----------------
|
||||
if mode == "black-hole":
|
||||
rec.update(kind="hostile", http_status=None)
|
||||
log_record(rec)
|
||||
threading.Event().wait() # hold the socket open forever
|
||||
return
|
||||
if mode == "mid-body-drop":
|
||||
rec.update(kind="hostile", http_status=200)
|
||||
log_record(rec)
|
||||
self._drop_mid_body()
|
||||
return
|
||||
if mode == "tool-pending-forever":
|
||||
seq = next(_PENDING_SEQ)
|
||||
rec.update(kind="hostile",
|
||||
delivered={"tool_calls": ["write_file"],
|
||||
"finish_reason": "tool_calls",
|
||||
"api_error": None})
|
||||
log_record(rec)
|
||||
self._send_json(200, pending_body(seq, "gate-openai-model"))
|
||||
return
|
||||
|
||||
# ---- normal mode -------------------------------------------------
|
||||
try:
|
||||
req = json.loads(raw)
|
||||
except ValueError as exc:
|
||||
# DIAGNOSTIC CAPTURE (2026-08-06): an unparseable body used to be recorded as
|
||||
# a bare "bad_json" with the bytes thrown away, which made an intermittent
|
||||
# failure impossible to root-cause — you cannot fix what you did not keep.
|
||||
# Dump the raw body next to the log, and record exactly where the parser gave
|
||||
# up plus the offending byte, so one occurrence is enough to diagnose.
|
||||
dump_path = "%s.badbody.%s" % (STATE.get("log_path", "/tmp/stub-openai"),
|
||||
rec.get("seq", "x"))
|
||||
try:
|
||||
data = raw if isinstance(raw, (bytes, bytearray)) else str(raw).encode()
|
||||
with open(dump_path, "wb") as fh:
|
||||
fh.write(data)
|
||||
except Exception as dump_exc:
|
||||
dump_path = "(dump failed: %s)" % dump_exc
|
||||
pos = getattr(exc, "pos", None)
|
||||
near = ""
|
||||
byte_repr = ""
|
||||
if isinstance(pos, int):
|
||||
blob = raw if isinstance(raw, (bytes, bytearray)) else str(raw).encode()
|
||||
near = blob[max(0, pos - 60):pos + 60].decode("utf-8", "replace")
|
||||
if 0 <= pos < len(blob):
|
||||
byte_repr = "0x%02x" % blob[pos]
|
||||
rec.update(kind="bad_json", validation="rejected",
|
||||
validation_detail="request body is not valid JSON: %s" % exc,
|
||||
http_status=400, raw_len=len(raw), raw_dump=dump_path,
|
||||
err_pos=pos, err_byte=byte_repr, err_near=near)
|
||||
log_record(rec)
|
||||
self._send_error(_rej("request body is not valid JSON",
|
||||
"bad_json"))
|
||||
return
|
||||
msgs = req.get("messages") or []
|
||||
rec["n_messages"] = len(msgs)
|
||||
rec["n_assistant"] = sum(1 for m in msgs if isinstance(m, dict)
|
||||
and m.get("role") == "assistant")
|
||||
loaded = STATE["scenarios"]
|
||||
cname, pid = match_scenario(loaded, msgs)
|
||||
if cname:
|
||||
rec.update(kind="scenario", scenario_class=cname, phrasing=pid)
|
||||
|
||||
# Wire-level validation runs for EVERY request, scenario or not.
|
||||
verdict = (validate_dialect(self.headers, req)
|
||||
or validate_pairing([m for m in msgs
|
||||
if isinstance(m, dict)])
|
||||
or validate_echo_args(msgs, loaded))
|
||||
if verdict:
|
||||
rec.update(validation="rejected",
|
||||
validation_detail=verdict["message"],
|
||||
http_status=verdict["status"])
|
||||
log_record(rec)
|
||||
self._send_error(verdict)
|
||||
return
|
||||
|
||||
model = req.get("model", "gate-openai-model")
|
||||
if not cname:
|
||||
log_record(rec)
|
||||
self._send_json(200, text_completion("ok", model))
|
||||
return
|
||||
|
||||
script = (loaded["scripts"].get(cname + "/" + pid)
|
||||
or loaded["scripts"][cname])
|
||||
step_idx = rec["n_assistant"]
|
||||
if step_idx >= len(script):
|
||||
rec.update(kind="overrun", step=step_idx)
|
||||
log_record(rec)
|
||||
self._send_json(200, text_completion(
|
||||
"GATE-SCRIPT-EXHAUSTED %s step %d" % (pid, step_idx), model))
|
||||
return
|
||||
|
||||
step = script[step_idx]
|
||||
exp = dict(loaded["expects"][cname])
|
||||
exp.update(step.get("expect_request", {}))
|
||||
verdict = validate_expect(req, exp)
|
||||
if verdict:
|
||||
rec.update(step=step_idx, validation="rejected",
|
||||
validation_detail=verdict["message"],
|
||||
http_status=verdict["status"])
|
||||
log_record(rec)
|
||||
self._send_error(verdict)
|
||||
return
|
||||
|
||||
status, body, delivered = render_step(step, cname, pid, step_idx,
|
||||
model)
|
||||
rec.update(step=step_idx, delivered=delivered, http_status=status)
|
||||
log_record(rec)
|
||||
self._send_json(status, body)
|
||||
|
||||
def log_message(self, *a):
|
||||
pass
|
||||
|
||||
|
||||
def main():
|
||||
ap = argparse.ArgumentParser()
|
||||
ap.add_argument("--port", type=int, required=True)
|
||||
ap.add_argument("--scenarios",
|
||||
help="scenarios-openai.json (required in normal mode)")
|
||||
ap.add_argument("--log", required=True)
|
||||
ap.add_argument("--mode", default="normal",
|
||||
choices=["normal", "black-hole", "mid-body-drop",
|
||||
"tool-pending-forever"])
|
||||
args = ap.parse_args()
|
||||
if args.port in (7770, 7779, 17779):
|
||||
raise SystemExit("stub-openai: refusing production Neuron port")
|
||||
if args.mode == "normal" and not args.scenarios:
|
||||
raise SystemExit("stub-openai: --scenarios is required in normal mode")
|
||||
STATE["mode"] = args.mode
|
||||
STATE["scenarios"] = (load_scenarios(args.scenarios)
|
||||
if args.scenarios else None)
|
||||
STATE["log_path"] = args.log
|
||||
open(args.log, "w").close()
|
||||
n_markers = (len(STATE["scenarios"]["marker_map"])
|
||||
if STATE["scenarios"] else 0)
|
||||
print("stub-openai [%s]: 127.0.0.1:%d /v1/chat/completions "
|
||||
"(%d markers registered, log=%s)"
|
||||
% (args.mode, args.port, n_markers, args.log), flush=True)
|
||||
ThreadingHTTPServer(("127.0.0.1", args.port), Handler).serve_forever()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,148 +0,0 @@
|
||||
#!/usr/bin/env bash
|
||||
# run-el-test.sh — build and RUN one engine test (tests/*.el), printing its assertions.
|
||||
#
|
||||
# WHY THIS EXISTS (2026-08-06): the engine's tests/*.el files were never runnable from the
|
||||
# tree. `elc` is a COMPILER — it emits C to stdout and exits; it does not execute anything.
|
||||
# So "the tests" could only ever be read, not run, and a signature change could silently
|
||||
# break them (exactly what happened when bridge_save gained its `wire` argument). This
|
||||
# script closes that: emit the test to C, link it against the engine modules, execute it.
|
||||
#
|
||||
# HOW IT WORKS
|
||||
# 1. elc <test>.el -> C on stdout (the test file's `main` + prototypes)
|
||||
# 2. elb (once, cached) -> per-module C for the whole engine into a scratch dir
|
||||
# 3. cc test.c + all modules EXCEPT soul.c (soul.c owns the real `main`) + the runtime
|
||||
# 4. run it
|
||||
#
|
||||
# The test C references only the engine functions it actually calls, so there are no
|
||||
# duplicate-symbol collisions with the module objects.
|
||||
#
|
||||
# RUNTIME: the REPO-PINNED vendor/el-runtime (NOT ~/el-sdk/el_runtime.c — that June build
|
||||
# is missing builtins August code calls: engram_wm_count, engram_wm_top_json,
|
||||
# http_delete_json, http_serve_async; linking against it fails with "symbol(s) not found").
|
||||
#
|
||||
# USAGE
|
||||
# tests/run-el-test.sh tests/test_bridge_serialization.el # one test
|
||||
# tests/run-el-test.sh --all # every tests/test_*.el
|
||||
# REBUILD=1 tests/run-el-test.sh ... # force module regeneration
|
||||
#
|
||||
# Tests that need a live API key / running soul (see each file's header) will report their
|
||||
# own skips or failures — this runner does not fake them.
|
||||
set -uo pipefail
|
||||
|
||||
REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
|
||||
cd "$REPO_ROOT" || exit 2
|
||||
|
||||
ELC="${ELC:-$HOME/el-sdk/elc}"
|
||||
ELB="${ELB:-$HOME/Development/el-sdk/bin/elb}"
|
||||
RUNTIME_DIR="${RUNTIME_DIR:-$REPO_ROOT/vendor/el-runtime/v1.0.0-20260501}"
|
||||
SCRATCH="${SCRATCH:-/tmp/el-test-$(basename "$REPO_ROOT")}"
|
||||
MODDIR="$SCRATCH/modules"
|
||||
OPENSSL_INC="${OPENSSL_INC:-/opt/homebrew/opt/openssl@3/include}"
|
||||
OPENSSL_LIB="${OPENSSL_LIB:-/opt/homebrew/opt/openssl@3/lib}"
|
||||
|
||||
for req in "$ELC" "$ELB" "$RUNTIME_DIR/el_runtime.c"; do
|
||||
[ -e "$req" ] || { echo "run-el-test: missing required input: $req" >&2; exit 2; }
|
||||
done
|
||||
|
||||
mkdir -p "$MODDIR" || exit 2
|
||||
|
||||
# ── Step 1: engine modules (cached — regeneration is the slow part) ────────────
|
||||
if [ "${REBUILD:-0}" = "1" ] || [ ! -f "$MODDIR/chat.c" ] || [ "chat.el" -nt "$MODDIR/chat.c" ]; then
|
||||
echo "run-el-test: generating engine modules into $MODDIR (this takes ~1-2 min)..."
|
||||
# elb's own final link step fails by design here (it wants to produce a binary named
|
||||
# `neuron` and we only need the per-module .c files it emits first). Ignore its rc.
|
||||
"$ELB" --elc="$ELC" --runtime="$RUNTIME_DIR" --out="$MODDIR/" >"$SCRATCH/elb.log" 2>&1
|
||||
if [ ! -f "$MODDIR/chat.c" ]; then
|
||||
echo "run-el-test: FATAL — elb produced no chat.c; see $SCRATCH/elb.log" >&2
|
||||
tail -5 "$SCRATCH/elb.log" >&2
|
||||
exit 2
|
||||
fi
|
||||
# elb rewrites *.elh in the source tree as a side effect (cosmetic banner churn plus a
|
||||
# stray soul..elh). Say so; the caller decides whether to `git restore` them.
|
||||
echo "run-el-test: NOTE — elb regenerated *.elh in the source tree (cosmetic churn is expected; a stray soul..elh may appear)."
|
||||
fi
|
||||
|
||||
# soul.c is needed for its engine functions (layered_cycle et al.) but it also owns the
|
||||
# daemon's real `main`, which would collide with the test's own. Compile it ONCE to an
|
||||
# object with `main` renamed away, and link that instead of the .c.
|
||||
SOUL_OBJ="$SCRATCH/soul-nomain.o"
|
||||
if [ "${REBUILD:-0}" = "1" ] || [ ! -f "$SOUL_OBJ" ] || [ "$MODDIR/soul.c" -nt "$SOUL_OBJ" ]; then
|
||||
cc -std=c11 -O1 -DHAVE_CURL -Dmain=el_soul_daemon_main_unused \
|
||||
-I "$RUNTIME_DIR" -I "$MODDIR" -I "$OPENSSL_INC" \
|
||||
-include dist/elp-c-decls.h -Wno-error=implicit-function-declaration \
|
||||
-c "$MODDIR/soul.c" -o "$SOUL_OBJ" 2>"$SCRATCH/soul-nomain.err" \
|
||||
|| { echo "run-el-test: FATAL — could not compile soul.c without main" >&2
|
||||
grep -E 'error:' "$SCRATCH/soul-nomain.err" | head -5 >&2; exit 2; }
|
||||
fi
|
||||
|
||||
# Every module except soul.c (linked as the renamed object above) and the stray soul.elh.c.
|
||||
MODS=("$SOUL_OBJ")
|
||||
for f in "$MODDIR"/*.c; do
|
||||
case "$(basename "$f")" in
|
||||
soul.c|soul.elh.c) continue ;;
|
||||
esac
|
||||
MODS+=("$f")
|
||||
done
|
||||
[ "${#MODS[@]}" -gt 1 ] || { echo "run-el-test: no module objects found" >&2; exit 2; }
|
||||
|
||||
run_one() {
|
||||
local test_el="$1"
|
||||
local name; name="$(basename "$test_el" .el)"
|
||||
local cfile="$SCRATCH/$name.c"
|
||||
local bin="$SCRATCH/$name"
|
||||
|
||||
printf '\n══ %s ══\n' "$name"
|
||||
|
||||
if ! "$ELC" "$test_el" >"$cfile" 2>"$SCRATCH/$name.elc.err"; then
|
||||
echo "COMPILE FAILED (elc):"; tail -10 "$SCRATCH/$name.elc.err"; return 1
|
||||
fi
|
||||
[ -s "$cfile" ] || { echo "COMPILE FAILED (elc produced empty C)"; return 1; }
|
||||
|
||||
if ! cc -std=c11 -O1 -DHAVE_CURL -rdynamic \
|
||||
-I "$RUNTIME_DIR" -I "$MODDIR" -I "$OPENSSL_INC" -L "$OPENSSL_LIB" \
|
||||
-include dist/elp-c-decls.h -Wno-error=implicit-function-declaration \
|
||||
-o "$bin" "$cfile" "${MODS[@]}" "$RUNTIME_DIR/el_runtime.c" \
|
||||
-lssl -lcrypto -lcurl -lpthread -lm 2>"$SCRATCH/$name.link.err"; then
|
||||
echo "LINK FAILED:"; grep -E '"_|error:' "$SCRATCH/$name.link.err" | head -10; return 1
|
||||
fi
|
||||
|
||||
# THE RUNNER OWNS THE VERDICT — the test files cannot be trusted to report it.
|
||||
#
|
||||
# Every tests/*.el assert helper does `let pass_count = pass_count + 1` INSIDE an if
|
||||
# BLOCK. El's scope rule (the same one chat.el documents at every while-body mutation:
|
||||
# "mutations inside if *blocks* don't escape scope") means those counters never
|
||||
# increment, so all 9 counted test files print "N passed, M failed" as "0 passed, 0
|
||||
# failed" — forever, whatever actually happened. A summary that can never report a
|
||||
# failure is worth exactly as much as an assertion that can never fail. Logged as a
|
||||
# bug for the real in-file fix; until then the verdict is computed HERE, from the
|
||||
# assert helpers' own per-line output, which IS reliable.
|
||||
local out="$SCRATCH/$name.out"
|
||||
"$bin" 2>&1 | tee "$out"; local rc=${PIPESTATUS[0]}
|
||||
|
||||
# NOTE: `grep -c` prints 0 AND exits 1 when there are no matches, so a `|| echo 0`
|
||||
# fallback appends a SECOND zero and every later integer test breaks on "0\n0".
|
||||
# (Caught by running this script — which is the whole argument for running things.)
|
||||
local n_pass n_fail
|
||||
n_pass=$(grep -c '^ PASS: ' "$out" 2>/dev/null); n_pass=${n_pass:-0}
|
||||
n_fail=$(grep -c '^ FAIL: ' "$out" 2>/dev/null); n_fail=${n_fail:-0}
|
||||
echo "── $name: $n_pass passed, $n_fail failed (counted by the runner, not by the file's dead counters)"
|
||||
if [ "$n_fail" -gt 0 ]; then
|
||||
echo " failing assertions:"; grep '^ FAIL: ' "$out" | sed 's/^/ /'
|
||||
return 1
|
||||
fi
|
||||
if [ "$n_pass" -eq 0 ]; then
|
||||
echo " WARNING: no assertions ran — treating as FAILURE (a test that asserts nothing is not a passing test)"
|
||||
return 1
|
||||
fi
|
||||
[ $rc -eq 0 ] || { echo " (test binary exited rc=$rc)"; return 1; }
|
||||
return 0
|
||||
}
|
||||
|
||||
rc_all=0
|
||||
if [ "${1:-}" = "--all" ]; then
|
||||
for t in tests/test_*.el; do run_one "$t" || rc_all=1; done
|
||||
else
|
||||
[ $# -ge 1 ] || { echo "usage: tests/run-el-test.sh <tests/test_x.el> | --all" >&2; exit 2; }
|
||||
for t in "$@"; do run_one "$t" || rc_all=1; done
|
||||
fi
|
||||
exit $rc_all
|
||||
@@ -93,7 +93,7 @@ println("1. bridge_save — empty messages guard")
|
||||
let sid1: String = "test-session-empty-messages"
|
||||
state_set("mcp_bridge:" + sid1, "")
|
||||
|
||||
let save1_ok: Bool = bridge_save(sid1, "claude-sonnet-4-5", "sys", "[]", "", "", "call-1", "anthropic")
|
||||
let save1_ok: Bool = bridge_save(sid1, "claude-sonnet-4-5", "sys", "[]", "", "", "call-1")
|
||||
assert_false("empty messages -> bridge_save returns false", save1_ok)
|
||||
|
||||
let saved1: String = state_get("mcp_bridge:" + sid1)
|
||||
@@ -107,7 +107,7 @@ println("2. bridge_save — empty tools_json guard")
|
||||
let sid2: String = "test-session-empty-tools"
|
||||
state_set("mcp_bridge:" + sid2, "")
|
||||
|
||||
let save2_ok: Bool = bridge_save(sid2, "claude-sonnet-4-5", "sys", "", "[{\"role\":\"user\",\"content\":\"hi\"}]", "", "call-2", "anthropic")
|
||||
let save2_ok: Bool = bridge_save(sid2, "claude-sonnet-4-5", "sys", "", "[{\"role\":\"user\",\"content\":\"hi\"}]", "", "call-2")
|
||||
assert_false("empty tools_json -> bridge_save returns false", save2_ok)
|
||||
|
||||
let saved2: String = state_get("mcp_bridge:" + sid2)
|
||||
@@ -126,7 +126,7 @@ state_set("mcp_bridge:" + sid3, "")
|
||||
|
||||
let msgs3: String = "[{\"role\":\"user\",\"content\":\"hello\"}]"
|
||||
let tools3: String = "[{\"name\":\"read_file\"}]"
|
||||
let save3_ok: Bool = bridge_save(sid3, "claude-sonnet-4-5", "You are a helper.", tools3, msgs3, "read_file", "toolu_abc", "anthropic")
|
||||
let save3_ok: Bool = bridge_save(sid3, "claude-sonnet-4-5", "You are a helper.", tools3, msgs3, "read_file", "toolu_abc")
|
||||
assert_true("valid args -> bridge_save returns true", save3_ok)
|
||||
|
||||
let blob3: String = state_get("mcp_bridge:" + sid3)
|
||||
@@ -243,7 +243,7 @@ state_set("mcp_bridge:" + sid8, "")
|
||||
let special_id: String = "toolu_test\"quoted\""
|
||||
let msgs8: String = "[{\"role\":\"user\",\"content\":\"hi\"}]"
|
||||
let tools8: String = "[{\"name\":\"read_file\"}]"
|
||||
let save8_ok: Bool = bridge_save(sid8, "claude-sonnet-4-5", "sys", tools8, msgs8, "", special_id, "anthropic")
|
||||
let save8_ok: Bool = bridge_save(sid8, "claude-sonnet-4-5", "sys", tools8, msgs8, "", special_id)
|
||||
assert_true("special chars in tool_use_id -> bridge_save returns true", save8_ok)
|
||||
|
||||
let blob8: String = state_get("mcp_bridge:" + sid8)
|
||||
@@ -251,111 +251,6 @@ let blob8: String = state_get("mcp_bridge:" + sid8)
|
||||
let retrieved_id: String = json_get(blob8, "tool_use_id")
|
||||
assert_eq("tool_use_id with quotes round-trips via json_safe", retrieved_id, special_id)
|
||||
|
||||
// ── Section 9: the "wire" field (OpenAI-tools port, 2026-08-06) ───────────────
|
||||
//
|
||||
// A suspended turn must resume on the SAME wire format it suspended on: an OpenAI-lane
|
||||
// bridge answered with an Anthropic-shaped tool_result (or vice versa) is a dead run.
|
||||
// bridge_save therefore stamps the blob with "wire", and agentic_resume branches on it.
|
||||
//
|
||||
// §9c is the important one. json_get is a first-substring-match scanner, so any key that
|
||||
// appears inside the UNESCAPED conversation embedded in messages_raw can be matched
|
||||
// instead of the blob's own field — that exact class of bug produced the round-9 resume
|
||||
// failure (json_get(blob,"tool_use_id") matching a web_search_tool_result's id inside the
|
||||
// replayed conversation). "wire" is written as a json_safe'd SCALAR ahead of both raw
|
||||
// fields precisely so a decoy in model-controlled bytes can never win. This test plants
|
||||
// that decoy on purpose. If someone later moves the field after messages_raw, this fails.
|
||||
|
||||
println("")
|
||||
println("9. bridge_save — wire tagging and its field-order guarantee")
|
||||
|
||||
// 9a. an OpenAI-lane suspension round-trips as "openai"
|
||||
let sid9: String = "test-session-wire-openai"
|
||||
state_set("mcp_bridge:" + sid9, "")
|
||||
let msgs9: String = "[{\"role\":\"user\",\"content\":\"hi\"}]"
|
||||
let tools9: String = "[{\"name\":\"read_file\"}]"
|
||||
let save9_ok: Bool = bridge_save(sid9, "llama-3.3-70b-versatile", "sys", tools9, msgs9, "", "call_abc", "openai")
|
||||
assert_true("openai wire -> bridge_save returns true", save9_ok)
|
||||
let blob9: String = state_get("mcp_bridge:" + sid9)
|
||||
assert_eq("wire round-trips as openai", json_get(blob9, "wire"), "openai")
|
||||
|
||||
// 9b. an Anthropic-lane suspension round-trips as "anthropic"
|
||||
let sid9b: String = "test-session-wire-anthropic"
|
||||
state_set("mcp_bridge:" + sid9b, "")
|
||||
let save9b_ok: Bool = bridge_save(sid9b, "claude-sonnet-4-5", "sys", tools9, msgs9, "", "toolu_abc", "anthropic")
|
||||
assert_true("anthropic wire -> bridge_save returns true", save9b_ok)
|
||||
let blob9b: String = state_get("mcp_bridge:" + sid9b)
|
||||
assert_eq("wire round-trips as anthropic", json_get(blob9b, "wire"), "anthropic")
|
||||
|
||||
// 9c. FIELD-ORDER GUARD: a decoy "wire" inside the conversation must NOT be matched.
|
||||
let sid9c: String = "test-session-wire-decoy"
|
||||
state_set("mcp_bridge:" + sid9c, "")
|
||||
let msgs9c: String = "[{\"role\":\"user\",\"content\":\"please save this literal text: \\\"wire\\\":\\\"anthropic\\\" end\"}]"
|
||||
let save9c_ok: Bool = bridge_save(sid9c, "llama-3.3-70b-versatile", "sys", tools9, msgs9c, "", "call_decoy", "openai")
|
||||
assert_true("decoy conversation -> bridge_save returns true", save9c_ok)
|
||||
let blob9c: String = state_get("mcp_bridge:" + sid9c)
|
||||
assert_eq("blob's own wire wins over a decoy planted in messages_raw", json_get(blob9c, "wire"), "openai")
|
||||
|
||||
// 9d. LEGACY blob (written before the port) has no wire field: json_get yields "",
|
||||
// which agentic_resume treats as the Anthropic path — old suspensions still resume.
|
||||
let sid9d: String = "test-session-wire-legacy"
|
||||
let legacy_blob: String = "{\"model\":\"claude-sonnet-4-5\",\"safe_sys\":\"sys\",\"tools_log\":\"\""
|
||||
+ ",\"tool_use_id\":\"toolu_legacy\",\"tools_raw\":[{\"name\":\"read_file\"}]"
|
||||
+ ",\"messages_raw\":[{\"role\":\"user\",\"content\":\"hi\"}]}"
|
||||
state_set("mcp_bridge:" + sid9d, legacy_blob)
|
||||
let blob9d: String = state_get("mcp_bridge:" + sid9d)
|
||||
assert_eq("legacy blob has no wire field -> empty (resumes as anthropic)", json_get(blob9d, "wire"), "")
|
||||
assert_eq("legacy blob still reads its tool_use_id", json_get(blob9d, "tool_use_id"), "toolu_legacy")
|
||||
|
||||
// 9e. THE HARDER DECOY: a LEGACY blob (no wire field of its own) that carries the bytes
|
||||
// of a wire tag deeper inside, where an unbounded first-match scan would find it and
|
||||
// misroute the resume onto the wrong loop — the round-9 defect class exactly.
|
||||
//
|
||||
// WHAT IS AND IS NOT REACHABLE (measured here, not assumed — an earlier version of this
|
||||
// test asserted the wrong thing and was corrected by running it):
|
||||
// * NOT reachable from ordinary conversation TEXT. Any quote a user or model writes is
|
||||
// backslash-escaped when it is serialized into the blob, so prose containing
|
||||
// "wire":"openai" is stored as \"wire\":\"openai\" and does not match a scan for the
|
||||
// unescaped key. §9f pins that.
|
||||
// * REACHABLE from STRUCTURAL keys, which are embedded raw. Conversation and tool
|
||||
// objects keep real quotes — that is precisely how round 9's scan found a
|
||||
// web_search_tool_result's tool_use_id. A connector-supplied tool schema or a future
|
||||
// message field literally named "wire" would be found the same way.
|
||||
// The bound removes the whole class rather than reasoning about which keys exist today.
|
||||
let sid9e: String = "test-session-wire-legacy-decoy"
|
||||
let decoy_blob: String = "{\"model\":\"claude-sonnet-4-5\",\"safe_sys\":\"sys\",\"tools_log\":\"\""
|
||||
+ ",\"tool_use_id\":\"toolu_legacy\""
|
||||
+ ",\"tools_raw\":[{\"name\":\"read_file\",\"wire\":\"openai\"}]"
|
||||
+ ",\"messages_raw\":[{\"role\":\"user\",\"content\":\"hi\"}]}"
|
||||
state_set("mcp_bridge:" + sid9e, decoy_blob)
|
||||
let blob9e: String = state_get("mcp_bridge:" + sid9e)
|
||||
|
||||
// Unbounded read (what NOT to do) — proves the hazard this guard exists for is real.
|
||||
assert_eq("unbounded scan DOES find a structural decoy (why the bound is needed)", json_get(blob9e, "wire"), "openai")
|
||||
|
||||
// Bounded read — the same computation agentic_resume performs.
|
||||
let d_traw: Int = str_index_of(blob9e, ",\"tools_raw\":")
|
||||
let d_tjson: Int = str_index_of(blob9e, ",\"tools_json\":")
|
||||
let d_mraw: Int = str_index_of(blob9e, ",\"messages_raw\":")
|
||||
let d_msgs: Int = str_index_of(blob9e, ",\"messages\":")
|
||||
let dcut1: Int = if d_traw > 0 { d_traw } else { str_len(blob9e) }
|
||||
let dcut2: Int = if d_tjson > 0 && d_tjson < dcut1 { d_tjson } else { dcut1 }
|
||||
let dcut3: Int = if d_mraw > 0 && d_mraw < dcut2 { d_mraw } else { dcut2 }
|
||||
let dcut: Int = if d_msgs > 0 && d_msgs < dcut3 { d_msgs } else { dcut3 }
|
||||
let head9e: String = str_slice(blob9e, 0, dcut)
|
||||
assert_eq("bounded scan ignores the decoy -> legacy blob resumes as anthropic", json_get(head9e, "wire"), "")
|
||||
assert_not_contains("scalar head excludes the bulk fields entirely", head9e, "read_file")
|
||||
|
||||
// 9f. Escaping bounds the severity: prose CANNOT inject a scalar-looking key, because
|
||||
// its quotes are escaped on the way in. Documented as a measured fact, so nobody has to
|
||||
// re-derive it the next time this question comes up.
|
||||
let sid9f: String = "test-session-wire-prose"
|
||||
let prose_blob: String = "{\"model\":\"claude-sonnet-4-5\",\"safe_sys\":\"sys\",\"tools_log\":\"\""
|
||||
+ ",\"tool_use_id\":\"toolu_legacy\",\"tools_raw\":[{\"name\":\"read_file\"}]"
|
||||
+ ",\"messages_raw\":[{\"role\":\"user\",\"content\":\"remember this: \\\"wire\\\":\\\"openai\\\"\"}]}"
|
||||
state_set("mcp_bridge:" + sid9f, prose_blob)
|
||||
let blob9f: String = state_get("mcp_bridge:" + sid9f)
|
||||
assert_eq("escaped prose cannot spoof the key even unbounded (severity bound)", json_get(blob9f, "wire"), "")
|
||||
|
||||
// ── Summary ────────────────────────────────────────────────────────────────────
|
||||
|
||||
println("")
|
||||
|
||||
@@ -1,92 +0,0 @@
|
||||
// tests/test_utf8_slice.el
|
||||
//
|
||||
// Guards utf8_safe_slice(), the fix for a live defect found 2026-08-06:
|
||||
//
|
||||
// The session preload cuts recalled memory content at a fixed length
|
||||
// (chat.el: `if str_len(acc) > 350 { str_slice(acc, 0, 350) }` and
|
||||
// session_preload_bullets' identical per-bullet cut). str_slice and str_len count
|
||||
// BYTES, so any cut landing inside a multi-byte UTF-8 character leaves a dangling
|
||||
// lead byte in the system prompt — and the whole request body is then invalid UTF-8.
|
||||
// Providers reject it outright, so the user sees "AI unavailable" with no clue why,
|
||||
// on both wire formats. Caught by an OpenAI-lane gate whose stub decodes strictly;
|
||||
// reproduced from a real memory whose content contained box-drawing rules (E2 94 80).
|
||||
//
|
||||
// Trigger is ordinary content: an em dash, a curly quote, an accented name, a table
|
||||
// border, an emoji — anything non-ASCII sitting on the cut boundary. It gets MORE
|
||||
// likely as a user's memory grows, which is the opposite of what should happen.
|
||||
//
|
||||
// §1 also pins the semantics this fix depends on: that str_char_code returns the
|
||||
// BYTE value at a byte index (not a decoded code point). If a future runtime changes
|
||||
// that, these assertions fail loudly instead of the truncation silently rotting.
|
||||
|
||||
import "../chat.el"
|
||||
|
||||
let pass_count: Int = 0
|
||||
let fail_count: Int = 0
|
||||
|
||||
fn assert_eq(label: String, got: String, expected: String) -> Void {
|
||||
if str_eq(got, expected) {
|
||||
let pass_count = pass_count + 1
|
||||
println(" PASS: " + label)
|
||||
} else {
|
||||
let fail_count = fail_count + 1
|
||||
println(" FAIL: " + label)
|
||||
println(" got: " + got)
|
||||
println(" expected: " + expected)
|
||||
}
|
||||
}
|
||||
|
||||
fn assert_eq_int(label: String, got: Int, expected: Int) -> Void {
|
||||
assert_eq(label, int_to_str(got), int_to_str(expected))
|
||||
}
|
||||
|
||||
println("")
|
||||
println("1. runtime semantics this fix relies on")
|
||||
|
||||
// "─" is U+2500 = E2 94 80 (three bytes). If str_len counts bytes, len("─") is 3.
|
||||
let dash: String = "─"
|
||||
assert_eq_int("str_len counts BYTES (one box-drawing char = 3)", str_len(dash), 3)
|
||||
assert_eq_int("str_char_code returns the BYTE value (lead byte of U+2500 = 0xE2 = 226)", str_char_code(dash, 0), 226)
|
||||
assert_eq_int("str_char_code second byte = 0x94 = 148", str_char_code(dash, 1), 148)
|
||||
assert_eq_int("str_char_code third byte = 0x80 = 128", str_char_code(dash, 2), 128)
|
||||
|
||||
println("")
|
||||
println("2. utf8_safe_slice — never leaves a partial character")
|
||||
|
||||
// Pure ASCII: behaves exactly like str_slice.
|
||||
assert_eq("ascii under the limit is untouched", utf8_safe_slice("hello", 10), "hello")
|
||||
assert_eq("ascii over the limit cuts exactly", utf8_safe_slice("hello world", 5), "hello")
|
||||
|
||||
// A cut landing INSIDE a 3-byte character must drop that character entirely.
|
||||
// "ab─cd": bytes a b E2 94 80 c d. Cutting at 3 or 4 lands mid-dash.
|
||||
let mixed: String = "ab─cd"
|
||||
assert_eq_int("fixture is 7 bytes (2 ascii + 3 + 2 ascii)", str_len(mixed), 7)
|
||||
assert_eq("cut inside the char (n=3) drops the partial char", utf8_safe_slice(mixed, 3), "ab")
|
||||
assert_eq("cut inside the char (n=4) drops the partial char", utf8_safe_slice(mixed, 4), "ab")
|
||||
// A cut landing exactly AFTER a complete character keeps it.
|
||||
assert_eq("cut on the char boundary (n=5) keeps the whole char", utf8_safe_slice(mixed, 5), "ab─")
|
||||
|
||||
// 2-byte character (é = C3 A9) and 4-byte character (😀 = F0 9F 98 80).
|
||||
let acc: String = "xé"
|
||||
assert_eq("cut inside a 2-byte char drops it", utf8_safe_slice(acc, 2), "x")
|
||||
assert_eq("cut after a 2-byte char keeps it", utf8_safe_slice(acc, 3), "xé")
|
||||
let emo: String = "x😀"
|
||||
assert_eq("cut inside a 4-byte char drops it (n=3)", utf8_safe_slice(emo, 3), "x")
|
||||
assert_eq("cut inside a 4-byte char drops it (n=4)", utf8_safe_slice(emo, 4), "x")
|
||||
assert_eq("cut after a 4-byte char keeps it", utf8_safe_slice(emo, 5), "x😀")
|
||||
|
||||
println("")
|
||||
println("3. the real-world shape that produced the bug")
|
||||
|
||||
// A run of box-drawing rules, cut mid-character — the exact captured failure.
|
||||
let rules: String = "──────"
|
||||
assert_eq_int("six box rules = 18 bytes", str_len(rules), 18)
|
||||
// n=16 lands one byte into the sixth character.
|
||||
let cut16: String = utf8_safe_slice(rules, 16)
|
||||
assert_eq_int("cut at 16 backs off to a clean 15-byte boundary", str_len(cut16), 15)
|
||||
// Every byte of the result must belong to a complete character: the last byte of a
|
||||
// well-formed run of these is always 0x80, and 15 is divisible by 3.
|
||||
assert_eq_int("result ends on a complete char (last byte 0x80)", str_char_code(cut16, 14), 128)
|
||||
|
||||
println("")
|
||||
println("test_utf8_slice.el: " + int_to_str(pass_count) + " passed, " + int_to_str(fail_count) + " failed")
|
||||
+46
-1122
File diff suppressed because it is too large
Load Diff
@@ -151,7 +151,6 @@ el_val_t http_get_with_headers(el_val_t url, el_val_t headers_map);
|
||||
el_val_t http_post_with_headers(el_val_t url, el_val_t body, el_val_t headers_map);
|
||||
el_val_t http_post_form_auth(el_val_t url, el_val_t form_body, el_val_t auth_header);
|
||||
el_val_t http_delete(el_val_t url);
|
||||
el_val_t http_delete_json(el_val_t url, el_val_t json_body);
|
||||
void http_serve(el_val_t port, el_val_t handler);
|
||||
void http_set_handler(el_val_t name);
|
||||
|
||||
@@ -617,12 +616,6 @@ el_val_t engram_scan_nodes_by_type_json(el_val_t node_type, el_val_t limit, el_
|
||||
el_val_t engram_neighbors_json(el_val_t node_id, el_val_t max_depth, el_val_t direction);
|
||||
el_val_t engram_activate_json(el_val_t query, el_val_t depth);
|
||||
el_val_t engram_stats_json(void);
|
||||
el_val_t engram_act_stats_json(void);
|
||||
el_val_t engram_cosine_sim(el_val_t id_a, el_val_t id_b);
|
||||
/* Document frequency of a term across node labels — term-specificity signal
|
||||
* for curiosity seed selection. (2026-08-03 self-review.) */
|
||||
el_val_t engram_label_df(el_val_t term);
|
||||
el_val_t engram_embed_backfill(el_val_t count);
|
||||
el_val_t engram_list_layers_json(void);
|
||||
/* Working memory introspection — count, mean weight, and top-N snapshot.
|
||||
* Ported from el-compiler/runtime on 2026-06-30 self-review. */
|
||||
|
||||
Reference in New Issue
Block a user