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>
163 lines
13 KiB
TypeScript
163 lines
13 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 { buildSegmentSummary, type SegmentMinute, type TargetChart } from "../src/lib/rectification-agentic/core/segment-summary.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));
|
|
const origin = "2000-06-14T23:55";
|
|
const at = (offset: number) => new Date(Date.parse(`${origin}:00Z`) + offset * 60000).toISOString().slice(0, 16);
|
|
|
|
// Fictional SQL algorithm/policy boundary inputs, not calibrated/native chart fixtures.
|
|
function boundaryInput(kind: "empty-d1" | "empty-d9" | "clamp" | "gap-tie") {
|
|
const targets: TargetChart[] = kind === "empty-d9" ? ["D10", "D9"] : ["D10", "D9", "D1"];
|
|
const minutes: SegmentMinute[] = Array.from({ length: 21 }, (_, offset) => ({
|
|
offset, time: at(offset).slice(11), date: at(offset).slice(0, 10),
|
|
signs: kind.startsWith("empty") ? {
|
|
D1: offset <= 4 ? 1 : offset % 2 ? 2 : 3,
|
|
D9: offset >= 5 && offset <= 13 ? 4 : offset % 2 ? 5 : 6,
|
|
D10: offset >= 14 ? 7 : offset % 2 ? 8 : 9,
|
|
} : { D1: 1, D9: 2, D10: 3 },
|
|
}));
|
|
const spans = kind.startsWith("empty") ? [[0, 2], [8, 10], [16, 18]] : kind === "clamp" ? [[0, 4]] : [[0, 4], [16, 20]];
|
|
const candidates = spans.map(([start, end], index) => {
|
|
const offset = Math.floor((start! + end!) / 2), stamp = at(offset);
|
|
return { id: stamp.slice(11), time: stamp.slice(11), candidate_date: stamp.slice(0, 10),
|
|
window_index: offset, window_offset_minutes: offset, segment_index: 0,
|
|
rank: index + 1, relative_support: kind.startsWith("empty") ? 50 - index : 50,
|
|
raw_score: kind.startsWith("empty") ? 12 - index : 10, tied_minute_count: end! - start! + 1,
|
|
cluster_times: minutes.slice(start, end! + 1).map(minute => minute.time),
|
|
cluster_intervals: [{ segment_index: 0, start_index: start!, end_index: end!,
|
|
start_offset_minutes: start!, end_offset_minutes: end!, start_at: at(start!), end_at: at(end!) }] };
|
|
});
|
|
const inference = buildInferenceState({ range_start: "23:55", range_end: "00:15", candidates, events: [], probes: [],
|
|
segment_minutes: minutes, segment_targets: targets, segment_scan_complete: true });
|
|
return { targets, minutes, candidates, inference };
|
|
}
|
|
|
|
test("fictional D7 controls cover empty head intersections and nearest earlier gap points without changing chart priority", () => {
|
|
for (const kind of ["empty-d1", "empty-d9", "clamp"] as const) {
|
|
const { inference } = boundaryInput(kind);
|
|
const summary = inference.segment_summary!;
|
|
const heads = summary.charts.map(chart => chart.segments[chart.top_segment!]!);
|
|
if (kind.startsWith("empty")) assert.ok(Math.max(...heads.map(head => head.start)) > Math.min(...heads.map(head => head.end)));
|
|
assert.equal(summary.adoption_minute?.offset, kind === "empty-d1" ? 2 : kind === "empty-d9" ? 9 : 4);
|
|
}
|
|
const { targets, minutes, candidates } = boundaryInput("gap-tie");
|
|
const summary = buildSegmentSummary({ targets, minutes, windowMinutes: 21, scanComplete: true,
|
|
deliveredOffsets: [[0, 4], [16, 20]], candidates: candidates.map(candidate => ({ ...candidate, score: candidate.raw_score })) });
|
|
assert.equal(summary.adoption_minute?.offset, 4, "equal distances to midpoint 10 choose earlier delivered point 4, never the gap");
|
|
});
|
|
|
|
test("D7 PostgreSQL recomputes priority, clamp and gap tie and rolls back stale or malformed segment adoption", { skip: !docker && "docker unavailable" }, async () => {
|
|
const fixture = startPostgresFixture();
|
|
const url = fixture.connectionUrl("service_runtime", "service-runtime-test-password");
|
|
try {
|
|
const migrated = spawnSync(process.execPath, [runner], { encoding: "utf8", env: {
|
|
...process.env, SCHEMA_DATABASE_URL: fixture.connectionUrl("schema_owner", "schema-owner-test-password"),
|
|
} });
|
|
assert.equal(migrated.status, 0, migrated.stderr);
|
|
const service = createLocalPostgresDataClient(url, null, "service_role");
|
|
const seed = async (kind: Parameters<typeof boundaryInput>[0]) => {
|
|
const userId = randomUUID(), sessionId = randomUUID(), caseId = randomUUID();
|
|
const { candidates, inference, minutes, targets } = boundaryInput(kind);
|
|
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: null, timezone_offset: -4 };
|
|
const intervals = [{ start_at: origin, end_at: at(20) }];
|
|
const range = { start_time: "23:55", end_time: "00:15", candidate_intervals: intervals };
|
|
fixture.psqlAs("identity_runtime", "identity-runtime-test-password", `insert into identity.users(id,name,email,email_verified)
|
|
values('${userId}','Fictional D7 Boundary','${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=null,timezone_offset=-4 where id='${userId}';
|
|
insert into public.chat_sessions(id,user_id,title,theme,session_type,messages)
|
|
values('${sessionId}','${userId}','Fictional D7 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 persisted = await service.rpc("persist_agentic_rectification_candidate_v2", {
|
|
p_user_id: userId, p_case_id: caseId, p_engine_result_id: "fictional-d7-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-d7-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: inference.representative_time, overall_confidence: "low", margin_percent: 1,
|
|
candidate_window_contract: "dated-v1", candidate_intervals: intervals, candidate_timezone_offset: -4,
|
|
candidate_timezone_id: null, inference_state: inference },
|
|
p_execution_ledger: [{ phase: "candidate.score", status: "completed", engine: "fictional-d7-policy" }],
|
|
});
|
|
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)!;
|
|
const accept = (owner = userId) => service.rpc("accept_agentic_rectification_segment_for_case_v1", {
|
|
p_user_id: owner, p_case_id: caseId, p_result_id: result.result_id, p_candidate_id: anchor.candidate_id, p_request_id: randomUUID(),
|
|
});
|
|
const stateSnapshot = () => fixture.psql(`select jsonb_build_object(
|
|
'profile',(select to_jsonb(p) from public.profiles p where id='${userId}'),
|
|
'case',(select to_jsonb(c) from public.agentic_rectification_cases c where id='${caseId}'),
|
|
'result',(select to_jsonb(r) from public.agentic_rectification_results r where id='${result.result_id}'),
|
|
'decisions',(select jsonb_agg(to_jsonb(d) order by created_at,id) from public.agentic_rectification_candidate_decisions d where case_id='${caseId}'))`);
|
|
return { userId, caseId, result, accept, stateSnapshot, inference, minutes, targets, candidates };
|
|
};
|
|
for (const kind of ["empty-d1", "empty-d9", "clamp"] as const) {
|
|
const row = await seed(kind);
|
|
const saved = await row.accept();
|
|
assert.equal(saved.error, null, JSON.stringify(saved.error));
|
|
assert.equal((saved.data as Record<string, unknown>).saved_time, row.inference.segment_summary!.adoption_minute!.time);
|
|
assert.equal((saved.data as Record<string, unknown>).saved_date, row.inference.segment_summary!.adoption_minute!.date);
|
|
}
|
|
// Internal algorithm-only SQL control: a gap is not a lawful dated-v1 adoption
|
|
// envelope. The public RPC below must still reject the fictional disjoint ledger.
|
|
const gap = await seed("gap-tie");
|
|
const gapState = { ...structuredClone(gap.inference),
|
|
credible_intervals: gap.candidates.flatMap(candidate => candidate.cluster_intervals), credible_range: null,
|
|
segment_summary: buildSegmentSummary({ targets: gap.targets, minutes: gap.minutes, windowMinutes: 21,
|
|
scanComplete: true, deliveredOffsets: [[0, 4], [16, 20]],
|
|
candidates: gap.candidates.map(candidate => ({ ...candidate, score: candidate.raw_score })) }),
|
|
};
|
|
const computed = JSON.parse(fixture.psql(`select public.rectification_segment_adoption_minute(c,r,'${JSON.stringify(gapState)}'::jsonb)
|
|
from public.agentic_rectification_cases c join public.agentic_rectification_results r on r.case_id=c.id where r.id='${gap.result.result_id}'`));
|
|
assert.equal(computed.offset, 4);
|
|
fixture.psql(`update public.agentic_rectification_results set decision_receipt=jsonb_set(decision_receipt,'{inference_state}','${JSON.stringify(gapState)}') where id='${gap.result.result_id}'`);
|
|
const gapBefore = gap.stateSnapshot();
|
|
assert.equal((await gap.accept()).error?.message, "agentic_rectification_candidate_state_inconsistent");
|
|
assert.equal(gap.stateSnapshot(), gapBefore, "dated gate is not bypassed to claim a legal gap adoption");
|
|
for (const mutation of ["owner", "malformed", "expired", "newer", "manual", "timezone", "confirmed"] as const) {
|
|
const row = await seed("clamp");
|
|
if (mutation === "manual" || mutation === "timezone" || mutation === "confirmed") {
|
|
assert.equal((await row.accept()).error, null, "fresh accepted identity precedes retry mutation");
|
|
}
|
|
if (mutation === "malformed") {
|
|
const broken = structuredClone(row.inference);
|
|
(broken.segment_minutes![5] as { date: string }).date = "2000-06-14";
|
|
fixture.psql(`update public.agentic_rectification_results set decision_receipt=jsonb_set(decision_receipt,'{inference_state}','${JSON.stringify(broken)}') where id='${row.result.result_id}'`);
|
|
} else if (mutation === "expired") fixture.psql(`update public.agentic_rectification_results set expires_at=now()-interval '1 second' where id='${row.result.result_id}'`);
|
|
else if (mutation === "newer") fixture.psql(`insert into public.agentic_rectification_results(
|
|
user_id,session_id,case_id,engine_result_id,canonical_input_hash,skill_version,algorithm_version,
|
|
evidence_ledger_fingerprint,candidate_range_fingerprint,candidate_range,candidates,overall_confidence,
|
|
baseline_birth_date,baseline_latitude,baseline_longitude,baseline_timezone_offset,created_at)
|
|
select user_id,session_id,case_id,'fictional-newer',canonical_input_hash,skill_version,algorithm_version,
|
|
evidence_ledger_fingerprint,candidate_range_fingerprint,candidate_range,candidates,overall_confidence,
|
|
baseline_birth_date,baseline_latitude,baseline_longitude,baseline_timezone_offset,now()+interval '1 second'
|
|
from public.agentic_rectification_results where id='${row.result.result_id}'`);
|
|
else if (mutation === "manual") fixture.psql(`update public.profiles set active_birth_time='00:12' where id='${row.userId}'`);
|
|
else if (mutation === "timezone") fixture.psql(`update public.profiles set timezone_offset=-5 where id='${row.userId}'`);
|
|
else if (mutation === "confirmed") {
|
|
// State-boundary corruption control, not a substitute for the old lawful confirmation positive.
|
|
fixture.psql(`update public.profiles set birth_time_status='confirmed' where id='${row.userId}';
|
|
update public.agentic_rectification_cases set status='confirmed',completed_at=now() where id='${row.caseId}'`);
|
|
}
|
|
const before = row.stateSnapshot();
|
|
assert.ok((await row.accept(mutation === "owner" ? randomUUID() : row.userId)).error, mutation);
|
|
assert.equal(row.stateSnapshot(), before, `${mutation} rejection leaves all four tables unchanged`);
|
|
}
|
|
} finally {
|
|
await closeLocalPostgresDataPool(url);
|
|
fixture.stop();
|
|
}
|
|
});
|