A layered public evidence trail showing how GAL-2 moves from legacy mediated-time
continuity into application-boundary commit protection, local multi-substrate
durability, local Postgres gating, local latency characterization, and controlled
GAL-2 Time authority beyond the signed 32-bit Unix time boundary. The model is not
“GAL-2 patches every legacy machine.” The model is: keep the minimum substrate alive,
move operational time authority to GAL-2, and protect the workflow before broken time
becomes committed state.
Operational continuity model
GAL-2 does not claim to keep a failed 32-bit kernel, firmware, filesystem,
database engine, or host operating system alive by itself.
GAL-2 operates where a protected workflow can still execute, or where a bridge,
wrapper, gateway, daemon, or external integration layer can consume the Time Contract.
Under that model, GAL-2 moves operational time authority away from signed-32 Unix time
and into governed GAL-2 Time.
Minimum substrate stays alive. GAL-2 governs time authority. Protected workflows keep operating.
Layer 1
Legacy boundary
Published
Legacy Binary Continuity
Post-2038 continuity for tested legacy execution paths
Legacy 32-bit execution paths were evaluated beyond the raw Y2038 boundary
using GAL-2 API-seeded temporal continuity.
This package documents mediated-time behavior in legacy post-2038 scenarios
where tested legacy-style execution paths continued operating in cases where
raw execution paths failed.
Interpretation: evidence of legacy survivability and continuity
for tested binary execution paths. Not a universal claim for every legacy binary,
operating system, or execution environment.
Layer 2
SQLite
PASS
Application-Boundary Protected Commit
GAL-2 Y2038 Protected Commit Test v1.1.1
This package extends the prior Y2038 corpus from legacy mediated-time behavior
into application-boundary protected commit behavior.
In the tested single-host SQLite scenario, the raw path committed unsafe
Y2038-style time-derived state. The GAL-2 protected path checked the Time
Contract gate and the declared Y2038 safety policy gate before durable commit,
blocking unsafe inputs before they became durable application state.
Claim boundary: application-boundary protected commit evidence.
Not universal Y2038 remediation, not operating system, kernel, filesystem,
database engine, or distributed-system remediation, not production throughput
or latency evidence, not metrology, and not UTC, GNSS, PTP, NTP, or chrony
replacement.
Layer 3
SQLite + JSONL
PASS
Local Multi-Substrate Protected Commit
GAL-2 Y2038 Multi-Substrate Protected Commit Test v1.2
This package extends protected commit evidence from a single SQLite substrate
to a local multi-substrate scenario using SQLite and an append-only JSONL ledger.
The raw path committed unsafe Y2038-style state into both tested substrates.
The GAL-2 protected path produced zero unsafe commits across SQLite and JSONL.
Cross-substrate consistency means data parity: the same logical safe commits
appear in both tested substrates, and unsafe inputs are absent from both GAL-2
protected substrates. It does not claim transactional atomicity, two-phase commit,
rollback coordination, distributed transactions, or atomic cross-substrate recovery.
Claim boundary: local multi-substrate application-boundary
protected commit evidence using SQLite and append-only JSONL. Not universal
Y2038 remediation, not distributed-system remediation, not production throughput
or latency evidence, not transactional atomicity evidence, not metrology, and not
UTC, GNSS, PTP, NTP, or chrony replacement.
Layer 4
Postgres
PASS
Local Postgres Protected Commit
GAL-2 Y2038 Postgres Protected Commit Test v1.3
This package extends the protected commit evidence into a local Postgres
database substrate. It evaluates whether unsafe Y2038-style time-derived
state can be blocked before becoming durable Postgres application state.
In the tested single-host local Postgres scenario, the raw path committed
unsafe Y2038-style records into Postgres. The GAL-2 protected path blocked
all unsafe inputs and committed all safe inputs.
Claim boundary: local Postgres application-boundary protected
commit evidence. Not universal Y2038 remediation, not operating system, kernel,
filesystem, database engine, or distributed-system remediation, not replication
evidence, not multi-node behavior, not multi-writer behavior, not transactional
atomicity across multiple systems, not production performance evidence, not
metrology, and not UTC, GNSS, PTP, NTP, or chrony replacement.
Layer 5
Latency
PASS
Local Latency Characterization
GAL-2 Protected Commit Latency Characterization v1.4
This package characterizes local raw path latency, GAL-2 protected path
latency, local Time Contract fetch latency, safe commit latency, unsafe block
latency, and p50 / p95 / p99 behavior across SQLite, append-only JSONL, and
local Docker Postgres.
The Contract measurement uses the real local GAL-2 Time Contract surface at
127.0.0.1:9095/contract. It measures local daemon latency, not
a direct public API round-trip to api-v2.gal-2.com.
For Postgres, the meaningful interpretation is protected path versus raw path
under the same local method. Absolute Postgres latency values include
docker exec psql overhead and should not be interpreted as
production libpq, connection-pooled, or networked database latency.
Claim boundary: local latency and throughput characterization
only. Not production throughput evidence, not production latency evidence, not
distributed-system performance evidence, not a capacity benchmark, not metrology,
and not UTC, GNSS, PTP, NTP, or chrony replacement evidence.
Layer 6
Y2038 authority crossing
PASS
Challengeable
RC4 Sandbox Authority Crossing
30-minute controlled post-boundary Time Contract continuity
This package documents a controlled GAL-2 RC4 Time Contract engine
characterization across the signed 32-bit Unix time boundary.
A copied GAL-2 RC4 Time Contract engine was run as a local sandbox with a
controlled Y2038 test clock. The engine produced governed GAL-2 Time Contract
output beyond 2038-01-19T03:14:07Z for a 30-minute
post-boundary characterization window.
The question tested is narrow and challengeable:
can the GAL-2 RC4 Time Contract engine maintain governed Time Contract behavior
beyond the signed 32-bit Unix time boundary under a controlled Y2038 clock?
In this run, the answer was yes under the declared test conditions.
Post-boundary samples
180
Final result:
PASS_Y2038_RC4_SANDBOX_30MIN_POST_BOUNDARY_CONTINUITY.
The run also verified safe_to_consume, contract_hash,
required Time Contract fields, and source lineage declaring
gal2_fractal_time_authority, rc4_contract_engine,
and y2038_controlled_clock.
Together with prior Docker linux/386 raw signed-32 failure evidence and
real-daemon consumer-gate evidence, this layer supports the bounded claim that
GAL-2 provides an operational continuity path for protected legacy workflows by
moving operational time authority away from signed-32 Unix time and into
governed GAL-2 Time.
Claim boundary: controlled application-facing Time Contract
continuity evidence. This package does not claim that GAL-2 patches arbitrary
unmodified legacy binaries from the inside. It does not claim that the production
AWS/API authority crossed 2038. It is not platform-level Y2038 remediation,
production SLA evidence, UTC accuracy certification, or metrology certification.
