66f087b588
Review-only snapshot for BUG-1115 through BUG-1117; not merge-ready. New opening and append-turn PostgreSQL permission failures remain blocked. Persisted joint replay has zero completed questions; segment ordering remains off by default. The existing offline replay JSON is retained stale and unchanged after a denied overwrite, including its CRLF line endings. Browser/provider validation and final serial gates remain pending. No deployment, role permission changes, or staging/main push. Co-Authored-By: Claude Code <noreply@anthropic.com>
204 lines
14 KiB
TypeScript
204 lines
14 KiB
TypeScript
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 { buildInferenceState } from "../src/lib/rectification-agentic/core/build-state.ts";
|
|
import { parseSegmentMinutes } from "../src/lib/rectification-agentic/v9/segment-contract.ts";
|
|
import { loadV9CaseDossier } from "../src/lib/rectification-agentic/v9/tool-service.ts";
|
|
import { ACCOUNT_BIRTH_SELECT, globalBirthProfileFromAccountRow } from "../src/lib/server-owned-birth-profile.ts";
|
|
import { buildLongformBirthPayload } from "../src/lib/personal-report-longform-birth.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));
|
|
|
|
/** Real native computations on fictional birth data; no invented engine response or model interpretation. */
|
|
function nativeCalculation(input: Record<string, unknown>): Record<string, unknown> {
|
|
const script = [
|
|
"import json, sys, tempfile",
|
|
"from pathlib import Path",
|
|
"sys.path.insert(0, str(Path.cwd() / 'scripts'))",
|
|
"from scripts.domain_calculation_service import compute_chart",
|
|
"from scripts.rectification_varga_segments_api import scan_varga_segments",
|
|
"from scripts import varga",
|
|
"body = json.load(sys.stdin)",
|
|
"if 'start_at' in body:",
|
|
" with tempfile.TemporaryDirectory() as tmp:",
|
|
" result = scan_varga_segments(body, cache_dir=Path(tmp))",
|
|
"else:",
|
|
" chart = compute_chart(body)",
|
|
" asc = chart['ascendant']['lon']",
|
|
" planets = {key: value['lon'] for key, value in chart['planets'].items()}",
|
|
" signs = {'D1': int(asc // 30) % 12}",
|
|
" for row in varga.calc_all_vargas(planets, asc, divisions=[9, 10]).values():",
|
|
" signs['D' + str(row['_meta']['div'])] = int(row['Ascendant']['sign_idx'])",
|
|
" effective = chart['calculation_contract']['effective']",
|
|
" result = {'signs': signs, 'ayanamsa': effective['ayanamsa'], 'node_mode': effective['node_mode']}",
|
|
"sys.stdout.write(json.dumps(result))",
|
|
].join("\n");
|
|
const result = spawnSync(process.env.PYTHON ?? (process.platform === "win32" ? "python" : "python3"), ["-c", script], {
|
|
cwd: fileURLToPath(new URL("../../", import.meta.url)), encoding: "utf8", input: JSON.stringify(input),
|
|
maxBuffer: 16 * 1024 * 1024, env: { ...process.env, PYTHONIOENCODING: "utf-8", PYTHONDONTWRITEBYTECODE: "1" },
|
|
});
|
|
assert.equal(result.status, 0, `${result.error ?? ""}\n${result.stderr}`);
|
|
return JSON.parse(result.stdout);
|
|
}
|
|
|
|
function nativeInference(scan: Record<string, unknown>) {
|
|
const minutes = parseSegmentMinutes(scan.minutes);
|
|
assert.ok(minutes);
|
|
// Synthetic weights/gates isolate the saved-tuple contract, not calibration or real engine eligibility.
|
|
// The scan and post-save chart are both genuine native outputs, not hand-authored signs.
|
|
const candidates = [0, 16].map((offset, index) => {
|
|
const minute = minutes[offset]!;
|
|
const start = index ? 12 : 0, end = index ? 19 : 0;
|
|
const first = minutes[start]!, last = minutes[end]!;
|
|
return { id: minute.time, time: minute.time, candidate_date: minute.date, window_index: offset,
|
|
window_offset_minutes: offset, segment_index: 0, rank: index ? 1 : 2, relative_support: index ? 90 : 10,
|
|
raw_score: index ? 10 : 1, tied_minute_count: end - start + 1,
|
|
cluster_times: minutes.slice(start, end + 1).map(member => member.time),
|
|
cluster_intervals: [{ segment_index: 0, start_index: start, end_index: end,
|
|
start_offset_minutes: start, end_offset_minutes: end, start_at: `${first.date}T${first.time}`, end_at: `${last.date}T${last.time}` }] };
|
|
});
|
|
const inference = buildInferenceState({ range_start: "23:55", range_end: "00:25",
|
|
candidates, events: [], probes: [], segment_minutes: minutes, segment_targets: ["D1", "D9", "D10"], segment_scan_complete: true });
|
|
return { minutes, candidates, inference };
|
|
}
|
|
|
|
test("fictional cross-midnight native scan and direct chart share the effective Raman/mean contract", () => {
|
|
const scan = nativeCalculation({ start_at: "2000-06-14T23:55", end_at: "2000-06-15T00:25",
|
|
latitude: 40, longitude: -74, timezone_offset: -4, target_charts: ["D1", "D9", "D10"] });
|
|
const minutes = parseSegmentMinutes(scan.minutes);
|
|
assert.ok(minutes);
|
|
assert.equal(minutes.length, 31);
|
|
const selected = minutes[14]!;
|
|
const actual = nativeCalculation({ year: 2000, month: 6, day: 15, hour: 0, minute: 9,
|
|
lat: 40, lon: -74, tz: -4, ayanamsa: "raman" });
|
|
assert.equal(selected.time, "00:09");
|
|
assert.deepEqual(actual.signs, selected.signs);
|
|
assert.equal(actual.ayanamsa, scan.ayanamsa);
|
|
assert.equal(actual.node_mode, scan.node_mode);
|
|
const { inference, candidates } = nativeInference(scan);
|
|
const adoption = inference.segment_summary?.adoption_minute;
|
|
assert.ok(adoption);
|
|
assert.equal(adoption.offset, 14);
|
|
assert.equal(adoption.date, "2000-06-15");
|
|
assert.equal(adoption.time, "00:09");
|
|
assert.equal(candidates.some(candidate => candidate.time === adoption.time), false);
|
|
assert.deepEqual(actual.signs, adoption.signs);
|
|
for (const chart of inference.segment_summary!.charts) assert.equal((actual.signs as Record<string, number>)[chart.chart], chart.sign);
|
|
// This checks native plumbing only; the separate PostgreSQL tests own the saved-profile chain.
|
|
});
|
|
|
|
for (const timezoneId of ["America/New_York", null]) {
|
|
test(`saved segment civil tuple flows through the production longform payload to actual native signs${timezoneId === null ? " (offset-only)" : ""}`, { 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: "2000-06-14", reported_birth_time: "23:59", 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: timezoneId, 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 scan = nativeCalculation({ start_at: intervals[0].start_at, end_at: intervals[0].end_at,
|
|
latitude: snapshot.latitude, longitude: snapshot.longitude, timezone_offset: snapshot.timezone_offset,
|
|
target_charts: ["D1", "D9", "D10"] });
|
|
const { candidates, inference } = nativeInference(scan);
|
|
assert.equal(scan.ayanamsa, "raman");
|
|
assert.equal(scan.node_mode, "mean");
|
|
const adoption = inference.segment_summary?.adoption_minute;
|
|
assert.ok(adoption);
|
|
assert.equal(adoption.date, "2000-06-15");
|
|
assert.equal(candidates.some(candidate => candidate.time === adoption.time), false, "saved minute is not a representative candidate");
|
|
fixture.psqlAs("identity_runtime", "identity-runtime-test-password", `insert into identity.users(id,name,email,email_verified)
|
|
values('${userId}','Fictional Saved Native Fixture','${userId}@example.invalid',true)`);
|
|
fixture.psql(`update public.profiles set birth_date='2000-06-14',reported_birth_time='23:59',birth_time_source='family_exact',birth_time_status='reported',
|
|
uncertainty_before_minutes=15,uncertainty_after_minutes=15,latitude=40,longitude=-74,timezone_id=${timezoneId ? `'${timezoneId}'` : "null"},timezone_offset=-4 where id='${userId}';
|
|
insert into public.chat_sessions(id,user_id,title,theme,session_type,messages)
|
|
values('${sessionId}','${userId}','Fictional saved native','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: "fictional-saved-native-policy",
|
|
p_evidence_ledger_fingerprint: "b".repeat(64), p_candidate_range_fingerprint: "c".repeat(64),
|
|
p_skill_version: "9.0.0", p_algorithm_version: "fictional-policy-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: false,
|
|
representative_time: "00:11", overall_confidence: "low", margin_percent: 1,
|
|
candidate_window_contract: "dated-v1", candidate_intervals: intervals, candidate_timezone_offset: -4,
|
|
candidate_timezone_id: timezoneId, inference_state: inference },
|
|
p_execution_ledger: [{ phase: "candidate.score", status: "completed", engine: "fictional-policy-native-scan" }],
|
|
});
|
|
assert.equal(persisted.error, null, JSON.stringify(persisted.error));
|
|
const result = persisted.data as { result_id: string; candidates: { time: string; candidate_id: string }[] };
|
|
const anchor = result.candidates.find(candidate => candidate.time === inference.representative_time);
|
|
assert.ok(anchor);
|
|
const accepted = await service.rpc("accept_agentic_rectification_segment_for_case_v1", {
|
|
p_user_id: userId, p_case_id: caseId, p_result_id: result.result_id, p_candidate_id: anchor.candidate_id, p_request_id: randomUUID(),
|
|
});
|
|
assert.equal(accepted.error, null, JSON.stringify(accepted.error));
|
|
const saved = accepted.data as Record<string, unknown>;
|
|
assert.equal(saved.saved_date, adoption.date);
|
|
assert.equal(saved.saved_time, adoption.time);
|
|
const loaded = await service.from("profiles").select(ACCOUNT_BIRTH_SELECT).eq("id", userId).single();
|
|
assert.equal(loaded.error, null, JSON.stringify(loaded.error));
|
|
assert.ok(loaded.data);
|
|
const stored = loaded.data as Record<string, unknown>;
|
|
const provenance = stored.active_birth_provenance as Record<string, unknown>;
|
|
assert.equal(stored.birth_date, snapshot.birth_date, "declared date is preserved");
|
|
assert.equal(stored.timezone_id, timezoneId);
|
|
assert.equal(Number(stored.active_birth_timezone_offset), -4);
|
|
assert.equal(provenance.contract, "segment-v1");
|
|
assert.equal(provenance.candidate_date, adoption.date);
|
|
assert.equal(provenance.candidate_time, adoption.time);
|
|
assert.equal(Number(provenance.timezone_offset), -4);
|
|
assert.equal(provenance.timezone_id, timezoneId);
|
|
for (const sql of [
|
|
`select to_char(selected_time,'HH24:MI') from public.agentic_rectification_results where id='${result.result_id}'`,
|
|
`select to_char(accepted_time,'HH24:MI') from public.agentic_rectification_cases where id='${caseId}'`,
|
|
`select response->>'saved_time' from public.agentic_rectification_candidate_decisions where result_id='${result.result_id}'`,
|
|
]) assert.equal(fixture.psql(sql), adoption.time);
|
|
assert.equal(fixture.psql(`select adopted_credible_range->>'representative_date' from public.agentic_rectification_cases where id='${caseId}'`), adoption.date);
|
|
assert.equal(fixture.psql(`select response->>'saved_date' from public.agentic_rectification_candidate_decisions where result_id='${result.result_id}'`), adoption.date);
|
|
const selected = await service.rpc("get_agentic_rectification_segment_selection_v1", {
|
|
p_user_id: userId, p_case_id: caseId, p_result_id: result.result_id,
|
|
});
|
|
assert.equal(selected.error, null);
|
|
assert.deepEqual(selected.data, { result_id: result.result_id, candidate_id: anchor.candidate_id,
|
|
date: adoption.date, time: adoption.time, contract: "segment-v1" });
|
|
assert.equal(stored.active_birth_date, adoption.date);
|
|
assert.equal(String(stored.active_birth_time).slice(0, 5), adoption.time);
|
|
const profile = globalBirthProfileFromAccountRow(loaded.data);
|
|
assert.equal(profile.date, saved.saved_date);
|
|
assert.equal(profile.time, saved.saved_time);
|
|
assert.equal(profile.birthTimeStatus, "accepted");
|
|
const payload = buildLongformBirthPayload(loaded.data, { today: "2026-09-30", targetYear: 2026,
|
|
candidateRange: range, birthTimeAccuracy: "provisional" });
|
|
assert.ok(payload);
|
|
assert.deepEqual([payload.year, payload.month, payload.day, payload.hour, payload.minute, payload.tz],
|
|
[2000, 6, 15, Number(adoption.time.slice(0, 2)), Number(adoption.time.slice(3)), -4]);
|
|
assert.equal(payload.birth_time_accuracy, "provisional");
|
|
const recalculated = nativeCalculation(payload);
|
|
assert.equal(recalculated.ayanamsa, "raman");
|
|
assert.equal(recalculated.node_mode, "mean");
|
|
assert.deepEqual(recalculated.signs, adoption.signs);
|
|
for (const chart of inference.segment_summary!.charts) assert.equal((recalculated.signs as Record<string, number>)[chart.chart], chart.sign);
|
|
const dossier = await loadV9CaseDossier(service, userId, caseId);
|
|
assert.equal(dossier.latestResult?.segmentSelection?.date, saved.saved_date);
|
|
assert.equal(dossier.latestResult?.segmentSelection?.time, saved.saved_time);
|
|
assert.notEqual(dossier.latestResult?.representativeTime, saved.saved_time, "representative signature remains diagnostic, not the report input");
|
|
} finally {
|
|
await closeLocalPostgresDataPool(url);
|
|
fixture.stop();
|
|
}
|
|
});
|
|
}
|