el/engram/test/test_interoception_p2_chrono.c

/* test_interoception_p2_chrono.c — M-INTEROCEPTION Priority 2.
 * Chronoception: engram_age_field(delta_ms) + reboot catch-up
 * (ENGRAM_CHRONOCEPTION, default OFF).
 *
 * Uses loaded snapshots with KNOWN working_memory_weight / background_activation
 * so the field is deterministic without depending on activation. (engram_load
 * halves WM on boot — the laundering step — so snapshot wm 1.0 -> 0.5 resident.)
 *
 * Modes:
 *   once  <dir> <dt_ms>          — age the field once by dt; save field.json.
 *   split <dir> <dt_ms> <N>      — age by dt/N, N times; save field.json.
 *                                  (once vs split must match: scale-invariance.)
 *   catchup <dir> <gap_ms>       — write a last-tick gap_ms in the past, then
 *                                  engram_age_field_catchup(); print MAGNITUDE.
 *   offcheck <dir> <dt_ms>       — flag OFF: age returns 0 and field is untouched.
 */
#include "el_runtime.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>

static el_val_t S(const char* s){ return EL_STR(s); }

static void write_seed(const char* dir){
    char p[1024]; snprintf(p,sizeof p,"%s/seed.json",dir);
    FILE* f=fopen(p,"w");
    fprintf(f,"{\"nodes\":["
      "{\"id\":\"f1\",\"content\":\"field node 1\",\"node_type\":\"Concept\",\"label\":\"f1\","
        "\"salience\":0.9,\"confidence\":1.0,\"working_memory_weight\":1.0,\"background_activation\":0.5},"
      "{\"id\":\"f2\",\"content\":\"field node 2\",\"node_type\":\"Concept\",\"label\":\"f2\","
        "\"salience\":0.8,\"confidence\":1.0,\"working_memory_weight\":0.8,\"background_activation\":0.4},"
      "{\"id\":\"f3\",\"content\":\"field node 3\",\"node_type\":\"Concept\",\"label\":\"f3\","
        "\"salience\":0.7,\"confidence\":1.0,\"working_memory_weight\":0.6,\"background_activation\":0.3}"
      "],\"edges\":[]}");
    fclose(f);
}
static void load_seed(const char* dir){
    char p[1024]; snprintf(p,sizeof p,"%s/seed.json",dir);
    write_seed(dir);
    if(!engram_load(S(p))){ fprintf(stderr,"load failed\n"); exit(2); }
}
static void save_field(const char* dir){
    char p[1024]; snprintf(p,sizeof p,"%s/field.json",dir);
    engram_save(S(p));
}

int main(int argc,char** argv){
    if(argc<3){ fprintf(stderr,"usage: %s <once|split|catchup|offcheck> <dir> ...\n",argv[0]); return 2; }
    const char* mode=argv[1];
    const char* dir =argv[2];

    if(!strcmp(mode,"once")){
        double dt=atof(argv[3]);
        load_seed(dir);
        el_val_t mag=engram_age_field((el_val_t)(int64_t)dt);
        printf("MAGNITUDE %.10f\n", el_to_float(mag));
        save_field(dir);
        return 0;
    }
    if(!strcmp(mode,"split")){
        double dt=atof(argv[3]); int N=atoi(argv[4]); if(N<1)N=1;
        load_seed(dir);
        double sub=dt/(double)N;
        for(int i=0;i<N;i++) engram_age_field((el_val_t)(int64_t)sub);
        save_field(dir);
        printf("SPLIT dt=%.0f N=%d sub=%.4f\n", dt, N, sub);
        return 0;
    }
    if(!strcmp(mode,"catchup")){
        double gap=atof(argv[3]);
        load_seed(dir);
        /* Write a last-tick gap_ms in the past. ENGRAM_DATA_DIR is set == dir by
         * the runner, so the sidecar the runtime reads is <dir>/chrono_last_tick. */
        struct timeval tv; gettimeofday(&tv,NULL);
        long long now_ms=(long long)tv.tv_sec*1000+tv.tv_usec/1000;
        long long last=now_ms-(long long)gap;
        char p[1200]; snprintf(p,sizeof p,"%s/chrono_last_tick",dir);
        FILE* f=fopen(p,"w"); fprintf(f,"%lld\n",last); fclose(f);
        el_val_t mag=engram_age_field_catchup();
        printf("CATCHUP_MAGNITUDE %.10f\n", el_to_float(mag));
        save_field(dir);
        return 0;
    }
    if(!strcmp(mode,"offcheck")){
        double dt=atof(argv[3]);
        load_seed(dir);
        el_val_t mag=engram_age_field((el_val_t)(int64_t)dt);
        el_val_t magc=engram_age_field_catchup();
        printf("OFF age_mag=%.10f catchup_mag=%.10f\n", el_to_float(mag), el_to_float(magc));
        save_field(dir);
        return 0;
    }
    fprintf(stderr,"unknown mode %s\n",mode); return 2;
}