Jyotisha/frontend/tests/database-adopted-birth-date.test.ts

import assert from "node:assert/strict";
import { randomUUID } from "node:crypto";
import { spawnSync } from "node:child_process";
import { fileURLToPath } from "node:url";
import test from "node:test";
import { closeLocalPostgresDataPool, createLocalPostgresDataClient } from "../src/lib/db/local-postgres-client-core.ts";
import { startPostgresFixture } from "./helpers/postgres-fixture.ts";

const docker = spawnSync("docker", ["version"], { stdio: "ignore" }).status === 0;
const runner = fileURLToPath(new URL("../scripts/db-migrate.mjs", import.meta.url));

// Fictional SQL boundary fixture. Permission booleans are controlled setup, not evidence
// that any real engine sample passed confirmation/holdout gates.
for (const declaration of [{ date: "2000-06-15", time: "00:10", offset: -1 }, { date: "2000-06-14", time: "23:59", offset: 0 }]) {
test(`dated adoption ${declaration.time} persists date/spec atomically and rejects malformed candidates`, { skip: !docker && "docker unavailable" }, async () => {
  const fixture = startPostgresFixture();
  const url = fixture.connectionUrl("service_runtime", "service-runtime-test-password");
  try {
    const migration = spawnSync(process.execPath, [runner], { encoding: "utf8", env: {
      ...process.env, SCHEMA_DATABASE_URL: fixture.connectionUrl("schema_owner", "schema-owner-test-password"),
    } });
    assert.equal(migration.status, 0, migration.stderr);
    const userId = randomUUID(), sessionId = randomUUID(), caseId = randomUUID();
    const snapshot = {
      birth_date: declaration.date, reported_birth_time: declaration.time, active_birth_time: null,
      birth_time_source: "family_exact", birth_time_period: null,
      uncertainty_before_minutes: 15, uncertainty_after_minutes: 15,
      latitude: 40, longitude: -74, timezone_id: "America/New_York", timezone_offset: -4,
    };
    const intervals = [{ start_at: "2000-06-14T23:55", end_at: "2000-06-15T00:25" }];
    const range = { start_time: "23:55", end_time: "00:25", candidate_intervals: intervals };
    const cluster = [{ segment_index: 0, start_index: 0, end_index: 16, start_offset_minutes: 0,
      end_offset_minutes: 16, start_at: "2000-06-14T23:55", end_at: "2000-06-15T00:11" }];
    const candidates = [
      { time: "23:55", candidate_date: "2000-06-14", window_index: 0, window_offset_minutes: 0, segment_index: 0 },
      { time: "00:11", candidate_date: "2000-06-15", window_index: 16, window_offset_minutes: 16, segment_index: 0 },
    ].map((row, i) => ({ ...row, id: row.time, rank: i + 1, relative_support: 50, tied_minute_count: 1,
      probability: i ? 0.4 : 0.6, posterior_score: i ? 55 : 60, status: "active",
      cluster_range: [row.time, row.time], cluster_intervals: [{ segment_index: 0,
        start_index: row.window_index, end_index: row.window_index,
        start_offset_minutes: row.window_offset_minutes, end_offset_minutes: row.window_offset_minutes,
        start_at: `${row.candidate_date}T${row.time}`, end_at: `${row.candidate_date}T${row.time}` }] }));
    const inference = {
      revision: 0, range_start: "23:55", range_end: "00:25",
      candidate_set_id: "dated-v1:23:55-00:25:2000-06-14T23:55@0@0@0,2000-06-15T00:11@16@16@0",
      candidates, representative_time: "23:55", credible_range: ["23:55", "00:11"], credible_intervals: cluster,
    };
    fixture.psqlAs("identity_runtime", "identity-runtime-test-password", `
      insert into identity.users(id,name,email,email_verified) values ('${userId}','Synthetic Midnight Fixture','${userId}@example.invalid',true);
    `);
    fixture.psql(`
      update public.profiles set birth_date='${declaration.date}',reported_birth_time='${declaration.time}',birth_time_source='family_exact',
        birth_time_status='reported',uncertainty_before_minutes=15,uncertainty_after_minutes=15,
        latitude=40,longitude=-74,timezone_id='America/New_York',timezone_offset=-4 where id='${userId}';
      insert into public.chat_sessions(id,user_id,title,theme,session_type,messages)
        values('${sessionId}','${userId}','Synthetic boundary','general','birth_time_rectification','[]');
      insert into public.agentic_rectification_cases(id,user_id,session_id,status,skill_name,skill_version,
        baseline_profile_fingerprint,baseline_birth_snapshot,candidate_range)
        values('${caseId}','${userId}','${sessionId}','candidate_ready','jyotish-birth-time-rectification','9.0.0',
        '${"a".repeat(64)}','${JSON.stringify(snapshot)}','${JSON.stringify(range)}');
    `);
    const service = createLocalPostgresDataClient(url, null, "service_role");
    const persisted = await service.rpc("persist_agentic_rectification_candidate_v2", {
      p_user_id: userId, p_case_id: caseId, p_engine_result_id: "synthetic-dated-boundary",
      p_evidence_ledger_fingerprint: "b".repeat(64), p_candidate_range_fingerprint: "c".repeat(64),
      p_skill_version: "9.0.0", p_algorithm_version: "synthetic-boundary-v1",
      p_event_contract_version: "rectification-event-contract-v2", p_decision_policy_version: "rectification-candidate-policy-v2",
      p_candidate_range: range, p_candidates: candidates,
      p_decision_receipt: { display_allowed: true, accept_allowed: true, confirm_allowed: true,
        representative_time: "23:55", overall_confidence: "low", margin_percent: 1,
        candidate_window_contract: "dated-v1", candidate_intervals: intervals,
        candidate_timezone_offset: -4, candidate_timezone_id: "America/New_York", inference_state: inference },
      p_execution_ledger: [{ phase: "candidate.score", status: "completed", engine: "synthetic-boundary" }],
    });
    assert.equal(persisted.error, null, JSON.stringify(persisted.error));
    const row = persisted.data as { result_id: string; candidates: { time: string; candidate_id: string }[] };
    const candidateId = row.candidates.find(c => c.time === "23:55")!.candidate_id;
    const nextId = row.candidates.find(c => c.time === "00:11")!.candidate_id;
    const accept = (id = candidateId, requestId = randomUUID()) => service.rpc("accept_agentic_rectification_candidate_for_case_v2", {
      p_user_id: userId, p_case_id: caseId, p_result_id: row.result_id, p_candidate_id: id, p_request_id: requestId,
    });
    assert.ok((await service.rpc("accept_agentic_rectification_candidate_for_case_v2", {
      p_user_id: randomUUID(), p_case_id: caseId, p_result_id: row.result_id, p_candidate_id: candidateId, p_request_id: randomUUID(),
    })).error, "dated candidate remains ownership scoped");
    fixture.psql(`update public.profiles set reported_birth_time='00:12' where id='${userId}'`);
    assert.ok((await accept()).error, "changed declaration invalidates dated candidates");
    fixture.psql(`update public.profiles set reported_birth_time='${declaration.time}' where id='${userId}';
      update public.agentic_rectification_results set invalidated_at=null where id='${row.result_id}';
      update public.agentic_rectification_cases set status='candidate_ready' where id='${caseId}'`);
    fixture.psql(`update public.agentic_rectification_candidates set candidate_payload=candidate_payload-'candidate_date' where id='${candidateId}'`);
    assert.ok((await accept()).error, "dated payload without date must fail closed");
    fixture.psql(`update public.agentic_rectification_candidates set candidate_payload=candidate_payload || '{"candidate_date":"2000-06-14"}' where id='${candidateId}'`);
    for (const patch of [
      { candidate_date: "2000-06-16" }, { window_offset_minutes: 500 }, { segment_index: 7 },
    ]) {
      fixture.psql(`update public.agentic_rectification_candidates set candidate_payload=candidate_payload || '${JSON.stringify(patch)}' where id='${candidateId}'`);
      assert.ok((await accept()).error, "candidate membership cannot be forged");
      fixture.psql(`update public.agentic_rectification_candidates set candidate_payload='${JSON.stringify(candidates[0])}' where id='${candidateId}'`);
    }
    fixture.psql(`update public.agentic_rectification_results set decision_receipt=jsonb_set(decision_receipt,'{candidate_timezone_offset}','-5') where id='${row.result_id}'`);
    assert.ok((await accept()).error, "candidate offset must match frozen calculation baseline");
    fixture.psql(`update public.agentic_rectification_results set decision_receipt=jsonb_set(decision_receipt,'{candidate_timezone_offset}','-4') where id='${row.result_id}'`);
    for (const patch of [{ segment_index: 7 }, { start_index: 3 }, { end_offset_minutes: 500 }]) {
      const malformed = { ...inference, credible_intervals: [{ ...cluster[0], ...patch }] };
      fixture.psql(`update public.agentic_rectification_results set decision_receipt=jsonb_set(decision_receipt,'{inference_state}','${JSON.stringify(malformed)}') where id='${row.result_id}'`);
      assert.ok((await accept()).error, "credible metadata must match the dated cluster envelope");
    }
    fixture.psql(`update public.agentic_rectification_results set decision_receipt=jsonb_set(decision_receipt,'{inference_state}','${JSON.stringify(inference)}') where id='${row.result_id}'`);
    const originalReceipt = fixture.psql(`select decision_receipt from public.agentic_rectification_results where id='${row.result_id}'`);
    fixture.psql(`update public.agentic_rectification_results set algorithm_version='rectification-v5-matrix-scoring-9',
      decision_receipt=decision_receipt-'candidate_window_contract'-'candidate_intervals'-'inference_state' where id='${row.result_id}';
      update public.agentic_rectification_candidates set candidate_payload=candidate_payload-'candidate_date'-'window_index'-'window_offset_minutes'-'segment_index'-'cluster_intervals' where result_id='${row.result_id}'`);
    const rejectsNewIdentity = fixture.psql(`do $$ begin
      begin
        perform public.validate_dated_rectification_candidate(c,r,p,null)
          from public.agentic_rectification_cases c, public.agentic_rectification_results r, public.agentic_rectification_candidates p
          where c.id='${caseId}' and r.id='${row.result_id}' and p.id='${candidateId}';
        raise exception 'expected_rejection_missing';
      exception when others then
        if sqlerrm <> 'agentic_rectification_candidate_state_inconsistent' then raise; end if;
      end;
    end $$; select 'rejected';`);
    assert.match(rejectsNewIdentity, /rejected/);
    // BUG-1181: scoring-10 (and later) keeps the dated contract; a stripped receipt is rejected,
    // while a pre-dated generation (scoring-8) stays a legacy same-day result (null).
    const setVersion = (version: string) => fixture.psql(`update public.agentic_rectification_results set algorithm_version='${version}' where id='${row.result_id}'`);
    const rejects = () => fixture.psql(`do $$ begin
      begin
        perform public.validate_dated_rectification_candidate(c,r,p,null)
          from public.agentic_rectification_cases c, public.agentic_rectification_results r, public.agentic_rectification_candidates p
          where c.id='${caseId}' and r.id='${row.result_id}' and p.id='${candidateId}';
        raise exception 'expected_rejection_missing';
      exception when others then
        if sqlerrm <> 'agentic_rectification_candidate_state_inconsistent' then raise; end if;
      end;
    end $$; select 'rejected';`);
    for (const version of ["rectification-v5-matrix-scoring-10", "rectification-v5-matrix-scoring-11"]) {
      setVersion(version);
      assert.match(rejects(), /rejected/, `${version} must not pass as legacy`);
    }
    setVersion("rectification-v5-matrix-scoring-8");
    const legacy = fixture.psql(`select coalesce(public.validate_dated_rectification_candidate(c,r,p,null)::text, 'legacy-null')
      from public.agentic_rectification_cases c, public.agentic_rectification_results r, public.agentic_rectification_candidates p
      where c.id='${caseId}' and r.id='${row.result_id}' and p.id='${candidateId}'`);
    assert.match(legacy, /legacy-null/, "pre-dated generations stay legacy same-day results");
    fixture.psql(`update public.agentic_rectification_results set algorithm_version='synthetic-boundary-v1',decision_receipt='${originalReceipt}' where id='${row.result_id}';
      update public.agentic_rectification_candidates set candidate_payload='${JSON.stringify(candidates[0])}' where id='${candidateId}';
      update public.agentic_rectification_candidates set candidate_payload='${JSON.stringify(candidates[1])}' where id='${nextId}'`);
    const splitWindows = [
      { start_at: "2000-06-14T23:55", end_at: "2000-06-14T23:59" },
      { start_at: "2000-06-15T00:05", end_at: "2000-06-15T00:25" },
    ];
    const splitCandidates = candidates.map((c, i) => ({ ...c, segment_index: i,
      cluster_intervals: c.cluster_intervals.map(part => ({ ...part, segment_index: i })) }));
    const splitInference = { ...inference, candidates: splitCandidates, credible_range: null,
      credible_intervals: splitCandidates.flatMap(c => c.cluster_intervals),
      candidate_set_id: inference.candidate_set_id.replace("00:11@16@16@0", "00:11@16@16@1") };
    fixture.psql(`update public.agentic_rectification_cases set candidate_range=jsonb_set(candidate_range,'{candidate_intervals}','${JSON.stringify(splitWindows)}') where id='${caseId}';
      update public.agentic_rectification_results set decision_receipt=jsonb_set(jsonb_set(decision_receipt,'{candidate_intervals}','${JSON.stringify(splitWindows)}'),'{inference_state}','${JSON.stringify({ ...splitInference, credible_intervals: cluster })}') where id='${row.result_id}';
      update public.agentic_rectification_candidates set candidate_payload='${JSON.stringify(splitCandidates[1])}' where id='${nextId}'`);
    assert.ok((await accept()).error, "credible envelope must not bridge separate declared segments");
    fixture.psql(`update public.agentic_rectification_results set decision_receipt=jsonb_set(decision_receipt,'{inference_state}','${JSON.stringify(splitInference)}') where id='${row.result_id}'`);
    assert.equal((await accept()).error, null, "separate credible segments remain adoptable");
    const reportRange = await service.rpc("read_report_candidate_range", { p_user_id: userId, p_rectification_case_id: caseId });
    assert.equal(reportRange.error, null);
    assert.deepEqual((reportRange.data as Record<string, unknown>).candidate_intervals, splitInference.credible_intervals);
    fixture.psql(`update public.agentic_rectification_cases set candidate_range='${JSON.stringify(range)}' where id='${caseId}';
      update public.agentic_rectification_results set decision_receipt='${originalReceipt}' where id='${row.result_id}';
      update public.agentic_rectification_candidates set candidate_payload='${JSON.stringify(candidates[1])}' where id='${nextId}'`);
    // A still-active candidate outside the existing separation lead is not in the credible union.
    const weakInference = { ...inference, candidates: candidates.map((c, i) => i ? { ...c, posterior_score: 40 } : c),
      credible_intervals: candidates[0].cluster_intervals, credible_range: ["23:55", "23:55"] };
    fixture.psql(`update public.agentic_rectification_results set decision_receipt=jsonb_set(decision_receipt,'{inference_state}','${JSON.stringify(weakInference)}') where id='${row.result_id}'`);
    assert.equal((await accept()).error, null, "separation lead excludes weak active candidate");
    fixture.psql(`update public.agentic_rectification_results set decision_receipt=jsonb_set(decision_receipt,'{inference_state}','${JSON.stringify(inference)}') where id='${row.result_id}'`);
    const requestId = randomUUID();
    const accepted = await accept(candidateId, requestId);
    assert.equal(accepted.error, null, JSON.stringify(accepted.error));
    assert.equal((accepted.data as Record<string, unknown>).saved_date, "2000-06-14");
    assert.equal((accepted.data as Record<string, unknown>).day_offset, declaration.offset);
    assert.equal(fixture.psql(`select birth_date || ':' || active_birth_date || ':' || active_birth_timezone_offset from public.profiles where id='${userId}'`), `${declaration.date}:2000-06-14:-4`);
    assert.equal((await accept(candidateId, requestId)).error, null);
    const switched = await accept(nextId);
    assert.equal(switched.error, null, JSON.stringify(switched.error));
    assert.equal((switched.data as Record<string, unknown>).saved_date, "2000-06-15");
    assert.equal((switched.data as Record<string, unknown>).day_offset, declaration.offset + 1);
    assert.equal(fixture.psql(`select adopted_credible_range->>'representative_date' || 'T' || (adopted_credible_range->>'representative_time') from public.agentic_rectification_cases where id='${caseId}'`), "2000-06-15T00:11");
    assert.equal((await accept()).error, null);
    const turnId = randomUUID();
    fixture.psql(`insert into public.agentic_rectification_turns(id,case_id,model_name,user_message,assistant_message,status)
      values('${turnId}','${caseId}','synthetic','Confirm synthetic boundary','Synthetic acknowledgment','completed')`);
    const confirmed = await service.rpc("confirm_agentic_rectification_candidate_for_case_v2", {
      p_user_id: userId, p_case_id: caseId, p_result_id: row.result_id, p_candidate_id: candidateId,
      p_request_id: randomUUID(), p_source_turn_id: turnId, p_consent_quote: "Confirm synthetic boundary",
    });
    assert.equal(confirmed.error, null, JSON.stringify(confirmed.error));
    assert.equal((confirmed.data as Record<string, unknown>).saved_date, "2000-06-14");
    fixture.psql(`delete from public.agentic_rectification_candidate_decisions where case_id='${caseId}';
      update public.agentic_rectification_results set selected_candidate_id=null where case_id='${caseId}';
      delete from public.agentic_rectification_candidates where case_id='${caseId}';
      delete from public.agentic_rectification_cases where id='${caseId}'`);
    assert.equal(fixture.psql(`select active_birth_date || ':' || (active_birth_provenance->>'candidate_id') from public.profiles where id='${userId}'`), `2000-06-14:${candidateId}`);
    for (const mutation of ["active_birth_time='23:56'", "birth_time_status='reported'", "timezone_offset=-5", "birth_date='2000-06-16'"]) {
      fixture.psql(`update public.profiles set birth_time_status='accepted',active_birth_time='23:55' where id='${userId}';
        update public.profiles set active_birth_date='2000-06-14',active_birth_timezone_offset=-4,active_birth_provenance='{"contract":"dated-v1"}' where id='${userId}';
        update public.profiles set ${mutation} where id='${userId}'`);
      assert.equal(fixture.psql(`select (active_birth_date is null and active_birth_timezone_offset is null and active_birth_provenance is null)::text from public.profiles where id='${userId}'`), "true", mutation);
    }
    fixture.psql(`update public.profiles set birth_date='2000-06-16' where id='${userId}'`);
    assert.equal(fixture.psql(`select (active_birth_date is null and active_birth_timezone_offset is null and active_birth_provenance is null)::text from public.profiles where id='${userId}'`), "true");
  } finally {
    await closeLocalPostgresDataPool(url);
    fixture.stop();
  }
});

}