function result = run_gpt5_6_4_validation()
%RUN_GPT5_6_4_VALIDATION Validate and export the GPT-5.6.4 proposal.

here = fileparts(mfilename('fullpath'));
project = fileparts(fileparts(fileparts(here)));
addpath(here)
addpath(fullfile(project, 'research', 'gpt5_6'))
addpath(fullfile(project, 'research', 'fable_2'))
addpath(fullfile(project, 'OSI_tests', 'fable'))
addpath(genpath(fullfile(project, 'control_and_HS', 'OSI')))
addpath(genpath(fullfile(project, 'helpers')))

results_dir = fullfile(here, 'results');
if ~exist(results_dir, 'dir'), mkdir(results_dir), end

baseline = load(fullfile(project, 'research', 'fable_2', 'results', ...
    'fabby_results.mat'));
original_suite = baseline.suite_gpt;
original_score = baseline.score_gpt;

temporary_suite = fullfile(project, 'OSI_tests', 'fable', 'results', ...
    'suite_gpt5_6_4_codex.mat');
[had_temporary_suite, temporary_bytes] = readBytes(temporary_suite);
restore_guard = onCleanup(@()restoreBytes(temporary_suite, ...
    had_temporary_suite, temporary_bytes));
proposed_suite = fable_synthetic_suite('method', gpt5_6_4_method(), ...
    'plot', false);
proposed_score = fabby_score(proposed_suite, project);
clear restore_guard

gdb_file = fullfile(project, 'saved_results', 'tests', 'tsting_osi', ...
    'GDBqFpKb.mat');
gdb_data = load(gdb_file, 'result');
gdb_record = gdb_data.result;
gdb_model = load(fullfile(project, 'saved_results', 'exp_tf', ...
    'tf_sp1_5000_20260627_233333.mat'));
gdb_loop = makeLoop(gdb_model, gdb_record.dt);
gdb_original = replayOriginal(gdb_record, gdb_loop, 0.55, 0.08);
gdb_proposed = replayProposed(gdb_record, gdb_loop, 0.55, struct(), ...
    struct());
gdb_gain = updateSignal(gdb_record.Results(:, 21), gdb_proposed.index);
gdb_original_metrics = recordMetrics(gdb_original, gdb_gain, 45, 75.5);
gdb_proposed_metrics = recordMetrics(gdb_proposed, gdb_gain, 45, 75.5);

calibration_file = fullfile(project, 'saved_results', 'tests', ...
    'gpt5_6_tests', 'osi_calibration_test.mat');
calibration_data = load(calibration_file, 'result');
calibration_record = calibration_data.result;
calibration_loop = makeLoop(calibration_record.dependencies.exp_tf, ...
    calibration_record.dt);
recorded_target = calibration_record.hs.target_outer_ncf;
recorded_minimum = calibration_record.hs.osi_gain_min;
calibration_original = replayOriginal(calibration_record, calibration_loop, ...
    recorded_target, recorded_minimum);
profile = gpt5_6_4_calibration_profile();
calibration_proposed = replayProposed(calibration_record, calibration_loop, ...
    profile.auth.target, profile.osi, profile.auth);
calibration_gain = updateSignal(calibration_record.Results(:, 21), ...
    calibration_proposed.index);
calibration_original_metrics = recordMetrics(calibration_original, ...
    calibration_gain, NaN, NaN);
calibration_proposed_metrics = recordMetrics(calibration_proposed, ...
    calibration_gain, NaN, NaN);

synthetic_reliability = reliabilityMetrics(proposed_suite);
gdb_pass = gdb_proposed_metrics.continuous ...
    && gdb_proposed_metrics.no_idle_shed ...
    && gdb_proposed_metrics.quake_pass ...
    && all(gdb_proposed_metrics.indicator_pass) ...
    && gdb_proposed_metrics.recovery_pass;
calibration_edges = calibration_proposed_metrics.indicator_latency_s(2:3);
logged_authority = updateSignal(calibration_record.auth, ...
    calibration_proposed.index);
late = calibration_proposed.tc >= 45;
calibration_smooth = max(abs(diff(calibration_proposed.a))) <= ...
    calibration_proposed.prm.max_step+1e-12 ...
    && totalTravel(calibration_proposed.a(late)) < totalTravel(logged_authority(late)) ...
    && reversalCount(calibration_proposed.a) <= reversalCount(logged_authority);
calibration_performance = calibration_proposed.a(end) >= 0.75 ...
    && calibration_proposed.a(end) < 0.95;
calibration_pass = all(isfinite(calibration_edges) & calibration_edges <= 2) ...
    && calibration_smooth && calibration_performance;

acceptance = struct( ...
    'canonical_pass', proposed_suite.all_pass, ...
    'canonical_pass_count', nnz([proposed_suite.cases.pass]), ...
    'fabby_score', proposed_score.mean_score, ...
    'fabby_score_pass', proposed_score.mean_score > 92, ...
    'reliability', synthetic_reliability, ...
    'reliability_pass', synthetic_reliability.pass, ...
    'gdb_pass', gdb_pass, ...
    'calibration_pass', calibration_pass, ...
    'all_pass', false);
acceptance.all_pass = acceptance.canonical_pass ...
    && acceptance.fabby_score_pass && acceptance.reliability_pass ...
    && acceptance.gdb_pass && acceptance.calibration_pass;

result = struct( ...
    'generated_at', char(datetime('now', ...
        'Format', 'yyyy-MM-dd HH:mm:ss')), ...
    'method', 'GPT-5.6.4 Codex', ...
    'original_suite', original_suite, ...
    'proposed_suite', proposed_suite, ...
    'original_score', original_score, ...
    'proposed_score', proposed_score, ...
    'gdb', struct('file', gdb_file, 'gain', gdb_gain, ...
        'original', gdb_original, 'proposed', gdb_proposed, ...
        'original_metrics', gdb_original_metrics, ...
        'proposed_metrics', gdb_proposed_metrics), ...
    'calibration', struct('file', calibration_file, ...
        'recorded_target', recorded_target, 'profile', profile, ...
        'gain', calibration_gain, 'original', calibration_original, ...
        'proposed', calibration_proposed, ...
        'original_metrics', calibration_original_metrics, ...
        'proposed_metrics', calibration_proposed_metrics, ...
        'logged_authority', logged_authority), ...
    'acceptance', acceptance);

saveResult(fullfile(results_dir, 'gpt5_6_4_validation.mat'), result)
writeSummary(fullfile(results_dir, 'summary.txt'), result)
writeReportData(fullfile(here, 'report_data.js'), result, ...
    gdb_record, calibration_record)
printSummary(result)
assert(result.acceptance.all_pass, ...
    'gpt5_6_4:Acceptance', 'GPT-5.6.4 acceptance did not pass.')
end

function replay = replayOriginal(record, loop_tf, target, a_min)
cfg = gpt_osi('config', record.dt, loop_tf, struct());
prm = gpt_auth('params', struct('target', target, 'a_min', a_min, ...
    'dt_update', cfg.step_s));
ost = gpt_osi('state', cfg);
ast = gpt_auth('state', prm);
replay = emptyReplay(record, cfg);
for k = 1:numel(replay.tc)
    ii = (k-1)*cfg.step_n+(1:cfg.step_n);
    ost.a_cmd = record.auth(ii(1));
    [replay.b(k), ost, oi] = gpt_osi(record.u_osi(ii), record.dm(ii), ...
        cfg, ost);
    [replay.a(k), ast] = gpt_auth(replay.b(k), oi.full_margin, ...
        oi.residual_weight, ast, prm);
    replay = storeUpdate(replay, k, record.t(ii(end)), oi, rms(ost.u));
end
replay.cfg = cfg;
replay.prm = prm;
end

function replay = replayProposed(record, loop_tf, target, osi_override, ...
        auth_override)
cfg = gpt5_6_4_osi('config', record.dt, loop_tf, osi_override);
auth_override.target = target;
auth_override.dt_update = cfg.step_s;
prm = gpt5_6_4_auth('params', auth_override);
ost = gpt5_6_4_osi('state', cfg);
ast = gpt5_6_4_auth('state', prm);
replay = emptyReplay(record, cfg);
for k = 1:numel(replay.tc)
    ii = (k-1)*cfg.step_n+(1:cfg.step_n);
    ost.a_cmd = record.auth(ii(1));
    [replay.b(k), ost, oi] = gpt5_6_4_osi(record.u_osi(ii), ...
        record.dm(ii), cfg, ost);
    [replay.a(k), ast] = gpt5_6_4_auth(replay.b(k), oi.full_margin, ...
        oi.residual_weight, ast, prm);
    replay = storeUpdate(replay, k, record.t(ii(end)), oi, rms(ost.u));
end
replay.cfg = cfg;
replay.prm = prm;
end

function replay = emptyReplay(record, cfg)
n = floor(min([numel(record.t), numel(record.u_osi), ...
    numel(record.dm), numel(record.auth)])/cfg.step_n);
replay = struct('tc', NaN(n, 1), 'b', NaN(n, 1), ...
    'b_st', NaN(n, 1), 'b_res', NaN(n, 1), ...
    'b_full', NaN(n, 1), 'residual_weight', NaN(n, 1), ...
    'activity', NaN(n, 1), 'rho', NaN(n, 1), 'a', NaN(n, 1), ...
    'tap_rms', NaN(n, 1), 'index', (1:n)'*cfg.step_n, ...
    'cfg', [], 'prm', []);
end

function replay = storeUpdate(replay, k, tc, oi, tap_rms)
replay.tc(k) = tc;
replay.b_st(k) = oi.b_st;
replay.b_res(k) = oi.b_res;
replay.b_full(k) = oi.full_margin;
replay.residual_weight(k) = oi.residual_weight;
if isfield(oi, 'activity'), replay.activity(k) = oi.activity; end
if isfield(oi, 'rho'), replay.rho(k) = oi.rho; end
replay.tap_rms(k) = tap_rms;
end

function metrics = recordMetrics(replay, gain, quake_start, repair_start)
[edge_time, gain_before, gain_after, latency] = ...
    indicatorLatencies(replay.tc, gain, replay.b);
metrics = struct( ...
    'continuous', all(isfinite(replay.b)) && all(isfinite(replay.a)), ...
    'edge_time_s', edge_time, 'gain_before', gain_before, ...
    'gain_after', gain_after, 'indicator_latency_s', latency, ...
    'indicator_pass', isfinite(latency) & latency <= 2, ...
    'max_step', max(abs(diff(replay.a))), ...
    'total_travel', totalTravel(replay.a), ...
    'reversals', reversalCount(replay.a), ...
    'no_idle_shed', true, 'quake_latency_s', NaN, ...
    'quake_pass', true, 'recovery_cross_s', NaN, ...
    'recovery_latency_s', NaN, 'recovery_tail_min', NaN, ...
    'recovery_pass', true);
if isfinite(quake_start)
    idle = replay.tc < quake_start-1;
    metrics.no_idle_shed = all(abs(replay.a(idle)-replay.prm.a_init) <= 1e-12);
    onset = find(replay.tc >= quake_start & replay.tap_rms > 0.05, 1);
    hit = [];
    if ~isempty(onset)
        hit = find(replay.tc >= replay.tc(onset) & ...
            replay.b < replay.prm.target, 1);
    end
    metrics.quake_latency_s = latencyBetween(replay.tc, onset, hit);
    metrics.quake_pass = isfinite(metrics.quake_latency_s) ...
        && metrics.quake_latency_s <= 2;
end
if isfinite(repair_start)
    cross = find(replay.tc >= repair_start & ...
        replay.b >= replay.prm.target+replay.prm.guard, 1);
    hit = [];
    if ~isempty(cross)
        hit = find(replay.tc >= replay.tc(cross) & replay.a >= 0.95, 1);
    end
    metrics.recovery_cross_s = timeAt(replay.tc, cross);
    metrics.recovery_latency_s = latencyBetween(replay.tc, cross, hit);
    if ~isempty(hit), metrics.recovery_tail_min = min(replay.a(hit:end)); end
    metrics.recovery_pass = isfinite(metrics.recovery_latency_s) ...
        && metrics.recovery_latency_s <= 3 ...
        && metrics.recovery_tail_min >= 0.95;
end
end

function [edge_time, before, after, latency] = indicatorLatencies(t, gain, b)
edges = find(diff(gain) > 0.05)+1;
edge_time = t(edges);
before = gain(edges-1);
after = gain(edges);
latency = NaN(numel(edges), 1);
for j = 1:numel(edges)
    k = edges(j);
    last = numel(t);
    if j < numel(edges), last = edges(j+1)-1; end
    pre = t >= t(k)-1 & t < t(k);
    hit = find((1:numel(t))' >= k & (1:numel(t))' <= last ...
        & b <= median(b(pre), 'omitnan')-0.04, 1);
    if ~isempty(hit), latency(j) = t(hit)-t(k); end
end
end

function metrics = reliabilityMetrics(suite)
max_step = 0;
max_backtrack = 0;
max_tail_step = 0;
for k = 1:numel(suite.cases)
    a = suite.cases(k).sim.a(:);
    t = suite.cases(k).sim.tc(:);
    da = diff(a);
    max_step = max(max_step, max(abs(da)));
    reverse = da(1:end-1).*da(2:end) < 0;
    if any(reverse)
        max_backtrack = max(max_backtrack, ...
            max(min(abs(da(1:end-1)), abs(da(2:end))).*reverse));
    end
    tail = a(t >= t(end)-30);
    max_tail_step = max(max_tail_step, max(abs(diff(tail))));
end
metrics = struct('max_step', max_step, ...
    'max_immediate_backtrack', max_backtrack, ...
    'max_tail_step', max_tail_step, ...
    'pass', max_step <= 0.05+1e-12 ...
        && max_backtrack <= 0.05+1e-12 ...
        && max_tail_step <= 0.05+1e-12);
end

function loop_tf = makeLoop(model_data, dt)
pv = model_data.pid_values;
controller = pid(pv.P, pv.I, pv.D, 1/pv.derivative_filter_N, dt, ...
    'IFormula', 'ForwardEuler', 'DFormula', 'ForwardEuler');
plant = model_data.H_dc_dm;
if get(plant, 'Ts') == 0
    plant = c2d(plant, dt, 'zoh');
elseif abs(get(plant, 'Ts')-dt) > 10*eps(dt)
    plant = d2d(plant, dt, 'zoh');
end
loop_tf = controller*plant;
end

function writeReportData(file, result, gdb_record, calibration_record)
D = struct('generated_at', result.generated_at, 'summary', struct(), ...
    'cases', struct([]));
cal = result.calibration;
gdb = result.gdb;
late = cal.proposed.tc >= 45;
D.summary = struct( ...
    'canonical_pass_count', result.acceptance.canonical_pass_count, ...
    'canonical_total', numel(result.proposed_suite.cases), ...
    'fabby_score', round(result.proposed_score.mean_score, 3), ...
    'score_threshold', 92, 'gdb_pass', result.acceptance.gdb_pass, ...
    'gdb_edge_latency_s', round(gdb.proposed_metrics.indicator_latency_s, 3), ...
    'calibration_pass', result.acceptance.calibration_pass, ...
    'calibration_edge_latency_s', ...
        round(cal.proposed_metrics.indicator_latency_s(2:3), 3), ...
    'original_max_step', round(cal.original_metrics.max_step, 4), ...
    'proposed_max_step', round(cal.proposed_metrics.max_step, 4), ...
    'original_late_travel', round(totalTravel(cal.logged_authority(late)), 3), ...
    'proposed_late_travel', round(totalTravel(cal.proposed.a(late)), 3), ...
    'proposed_final_authority', round(cal.proposed.a(end), 3), ...
    'all_pass', result.acceptance.all_pass);

for k = 1:numel(result.proposed_suite.cases)
    proposed = result.proposed_suite.cases(k);
    original = result.original_suite.cases(strcmp( ...
        {result.original_suite.cases.name}, proposed.name));
    oscore = result.original_score.cases(strcmp( ...
        {result.original_score.cases.name}, proposed.name));
    pscore = result.proposed_score.cases(strcmp( ...
        {result.proposed_score.cases.name}, proposed.name));
    c = baseCase(proposed.name, strrep(proposed.name, '_', ' '), ...
        'synthetic', ['canonical/' proposed.name], result.proposed_suite.target);
    c.tracking = struct('t', row(proposed.sim.t), ...
        'dm_original', row(original.sim.dm), ...
        'dm_proposed', row(proposed.sim.dm));
    c.osi = struct('t', row(proposed.sim.tc), ...
        'original', row(original.sim.b_est), ...
        'proposed', row(proposed.sim.b_est), ...
        'true_b', row(proposed.sim.b_true), ...
        'proposed_st', row(proposed.sim.b_st), ...
        'proposed_res', row(proposed.sim.b_res));
    c.authority = struct('t', row(proposed.sim.tc), ...
        'original', row(original.sim.a), 'proposed', row(proposed.sim.a));
    c.metrics = struct('original_pass', original.pass, ...
        'proposed_pass', proposed.pass, 'original_score', round(oscore.score, 2), ...
        'proposed_score', round(pscore.score, 2));
    if isempty(D.cases)
        D.cases = c;
    else
        D.cases(end+1) = c;
    end
end

D.cases(end+1) = actualCase('GDBqFpKb', 'GDBqFpKb', gdb_record, ...
    gdb.original, gdb.proposed, gdb.gain, gdb.proposed_metrics, 0.55, ...
    gdb.file);
D.cases(end+1) = actualCase('osi_calibration_test', ...
    'osi calibration test', calibration_record, cal.original, cal.proposed, ...
    cal.gain, cal.proposed_metrics, cal.profile.auth.target, cal.file);
payload = jsonencode(D);
fid = fopen(file, 'w');
assert(fid >= 0, 'Could not open report_data.js for writing.')
cleanup = onCleanup(@()fclose(fid));
fprintf(fid, 'window.GPT564_REPORT = %s;\n', payload);
clear cleanup
end

function c = actualCase(id, label, record, original, proposed, gain, ...
        metrics, target, source)
c = baseCase(id, label, 'record', source, target);
[t, pick] = downsampleSignal(record.t, 5000);
c.tracking = struct('t', row(t), 'dd', row(record.dd(pick)), ...
    'dc', row(record.dc(pick)), 'dm', row(record.dm(pick)));
c.osi = struct('t', row(proposed.tc), 'original', row(original.b), ...
    'proposed', row(proposed.b), 'proposed_st', row(proposed.b_st), ...
    'proposed_res', row(proposed.b_res));
c.authority = struct('t', row(proposed.tc), 'original', row(original.a), ...
    'proposed', row(proposed.a), ...
    'logged', row(updateSignal(record.auth, proposed.index)), ...
    'diag_gain', row(gain));
edges = find(abs(diff(gain)) > 0.05)+1;
c.events = struct('t', num2cell(proposed.tc(edges)), ...
    'label', arrayfun(@(x)sprintf('gain %.3g', x), gain(edges), ...
        'UniformOutput', false));
c.metrics = struct('edge_latency_s', round(metrics.indicator_latency_s, 3), ...
    'max_step', round(metrics.max_step, 4), ...
    'total_travel', round(metrics.total_travel, 3), ...
    'final_authority', round(proposed.a(end), 3));
end

function c = baseCase(id, label, kind, source, target)
c = struct('id', id, 'label', label, 'kind', kind, 'source', source, ...
    'target', target, 'events', struct([]), 'tracking', struct(), ...
    'osi', struct(), 'authority', struct(), 'metrics', struct());
end

function writeSummary(file, result)
fid = fopen(file, 'w');
assert(fid >= 0, 'Could not open summary.txt for writing.')
cleanup = onCleanup(@()fclose(fid));
fprintf(fid, 'GPT-5.6.4 Codex validation\n');
fprintf(fid, 'Generated: %s\n', result.generated_at);
fprintf(fid, 'FABLE: %d/10 pass\n', ...
    result.acceptance.canonical_pass_count);
fprintf(fid, 'Fabby score: %.3f (> 92)\n', ...
    result.proposed_score.mean_score);
fprintf(fid, 'GDB pass: %d | edge latencies: %s s | recovery %.3f s\n', ...
    result.acceptance.gdb_pass, ...
    mat2str(result.gdb.proposed_metrics.indicator_latency_s', 4), ...
    result.gdb.proposed_metrics.recovery_latency_s);
fprintf(fid, 'Calibration pass: %d | requested-edge latencies: %s s\n', ...
    result.acceptance.calibration_pass, mat2str( ...
    result.calibration.proposed_metrics.indicator_latency_s(2:3)', 4));
fprintf(fid, 'Calibration max authority step: original %.3f, proposed %.3f\n', ...
    result.calibration.original_metrics.max_step, ...
    result.calibration.proposed_metrics.max_step);
fprintf(fid, 'Calibration final proposed authority: %.3f\n', ...
    result.calibration.proposed.a(end));
fprintf(fid, 'All pass: %d\n', result.acceptance.all_pass);
clear cleanup
end

function printSummary(result)
fprintf('\nGPT-5.6.4: %d/10 FABLE | Fabby %.3f | GDB %s | calibration %s\n', ...
    result.acceptance.canonical_pass_count, result.proposed_score.mean_score, ...
    passText(result.acceptance.gdb_pass), ...
    passText(result.acceptance.calibration_pass))
fprintf('GDB edges %s s, recovery %.3f s\n', mat2str( ...
    result.gdb.proposed_metrics.indicator_latency_s', 4), ...
    result.gdb.proposed_metrics.recovery_latency_s)
fprintf('Calibration requested edges %s s, max step %.3f, final a %.3f\n', ...
    mat2str(result.calibration.proposed_metrics.indicator_latency_s(2:3)', 4), ...
    result.calibration.proposed_metrics.max_step, ...
    result.calibration.proposed.a(end))
end

function x = updateSignal(raw, index)
index = min(index, numel(raw));
x = raw(index);
end

function [t, pick] = downsampleSignal(t, limit)
stride = max(1, ceil(numel(t)/limit));
pick = (1:stride:numel(t))';
t = t(pick);
end

function x = row(x)
x = reshape(x, 1, []);
end

function x = totalTravel(a)
x = sum(abs(diff(a)));
end

function n = reversalCount(a)
da = diff(a);
n = nnz(da(1:end-1).*da(2:end) < 0);
end

function value = latencyBetween(t, first, second)
value = NaN;
if ~isempty(first) && ~isempty(second), value = t(second)-t(first); end
end

function value = timeAt(t, index)
value = NaN;
if ~isempty(index), value = t(index); end
end

function text = passText(value)
if value, text = 'PASS'; else, text = 'FAIL'; end
end

function [exists, bytes] = readBytes(file)
exists = isfile(file);
bytes = uint8([]);
if exists
    fid = fopen(file, 'r');
    assert(fid >= 0, 'Could not preserve temporary suite file.')
    cleanup = onCleanup(@()fclose(fid));
    bytes = fread(fid, inf, '*uint8');
    clear cleanup
end
end

function restoreBytes(file, existed, bytes)
if existed
    fid = fopen(file, 'w');
    if fid >= 0
        cleanup = onCleanup(@()fclose(fid));
        fwrite(fid, bytes, 'uint8');
        clear cleanup
    end
elseif isfile(file)
    delete(file)
end
end

function saveResult(file, result)
temporary = [tempname(fileparts(file)) '.mat'];
cleanup = onCleanup(@()deleteIfPresent(temporary));
save(temporary, 'result', '-v7.3')
[ok, message] = movefile(temporary, file, 'f');
assert(ok, 'gpt5_6_4:SaveResult', '%s', message)
clear cleanup
end

function deleteIfPresent(file)
if isfile(file), delete(file), end
end