ci: prepare approved public Unicode C and Rust pilot

Add the reviewed public-source workflow and pinned helpers for the original four-case C Unicode suite against C and Rust normalizers at 62a3294. Keep the request unarmed; a separate manifest-only activation is required.

Use sequential standard Ubuntu public runners, contents:read permissions and text logs only, with a maximum 260 runner-minute setup/activation budget. No paid runners, artifact/cache uploads, secrets or kernel test/timeout changes. A passing logs-only pair remains provisional without retained raw ELF artifacts.

Author: a-coding-mage

.github/pilots/unicode-request.json

@@ -0,0 +1,8 @@
+{
+  "schema": 1,
+  "request_id": "unicode-public-62a3294-v1",
+  "source_sha": "62a3294181556f17db863c9016524fa3068a374b",
+  "profile": "unicode-norm-original-c-x86_64-v1",
+  "evidence": "logs-only",
+  "armed": false
+}

.github/pilots/unicode-v1/CompareEvidence.pm

@@ -0,0 +1,64 @@
+package Elf64;
+# SPDX-License-Identifier: GPL-2.0-only
+# Newly authored minimal reader of the public ELF64 little-endian format.
+# Supports this x86_64 non-LTO pilot only. Unsupported inputs fail closed.
+use strict; use warnings;
+sub new {
+    my ($class, $path) = @_;
+    open my $fh, '<:raw', $path or die "$path: $!"; local $/; my $data = <$fh>;
+    die "not ELF64 LE x86_64: $path\n" unless substr($data,0,6) eq "\x7fELF\x02\x01" && unpack('v',substr($data,18,2)) == 62;
+    my ($base,$size,$count,$names) = (unpack('Q<',substr($data,40,8)),unpack('v',substr($data,58,2)),unpack('v',substr($data,60,2)),unpack('v',substr($data,62,2)));
+    die "unsupported section numbering\n" unless $size == 64 && $count && $names < $count;
+    my $self = bless {data=>$data,sections=>[],symbols=>[],rels=>[]}, $class;
+    for my $i (0..$count-1) {
+        my @v = unpack('V V Q< Q< Q< Q< V V Q< Q<',substr($data,$base+$i*64,64));
+        push @{$self->{sections}}, {index=>$i,nameoff=>$v[0],type=>$v[1],flags=>$v[2],addr=>$v[3],offset=>$v[4],size=>$v[5],link=>$v[6],info=>$v[7],entry=>$v[9]};
+    }
+    my $strings=$self->section_bytes($names);
+    for (@{$self->{sections}}) { $_->{name}=cstr($strings,$_->{nameoff}); }
+    for my $sec (@{$self->{sections}}) {
+        next unless $sec->{type} == 2;
+        die "unsupported multiple symbol tables\n" if @{$self->{symbols}};
+        die "bad symbol size\n" unless $sec->{entry} == 24;
+        my $names=$self->section_bytes($sec->{link}); my $raw=$self->section_bytes($sec->{index});
+        for (my $i=0;$i<length($raw);$i+=24) {
+            my ($n,$info,$other,$section,$value,$len)=unpack('V C C v Q< Q<',substr($raw,$i,24));
+            push @{$self->{symbols}}, {name=>cstr($names,$n),type=>$info & 15,bind=>$info>>4,section=>$section,value=>$value,size=>$len};
+        }
+        $self->{symtab}=$sec->{index};
+    }
+    die "missing full symbols\n" unless @{$self->{symbols}};
+    for my $sec (@{$self->{sections}}) {
+        next unless $sec->{type} == 4;
+        die "unsupported relocation table\n" unless $sec->{entry} == 24 && $sec->{link} == $self->{symtab};
+        my $raw=$self->section_bytes($sec->{index});
+        for (my $i=0;$i<length($raw);$i+=24) {
+            my ($offset,$info,$addend)=unpack('Q< Q< q<',substr($raw,$i,24));
+            push @{$self->{rels}}, {section=>$sec->{info},offset=>$offset,type=>$info & 0xffffffff,symbol=>$self->{symbols}[$info>>32],addend=>$addend};
+        }
+    }
+    return $self;
+}
+sub cstr { my ($data,$at)=@_; die "string out of range\n" if $at>=length($data); my $end=index($data,"\0",$at); die "unterminated string\n" if $end<0; return substr($data,$at,$end-$at); }
+sub section_bytes { my ($s,$i)=@_; my $sec=$s->{sections}[$i] // die "section out of range\n"; die "NOBITS not supported\n" if $sec->{type}==8; return substr($s->{data},$sec->{offset},$sec->{size}); }
+sub symbols { @{$_[0]->{symbols}} }
+sub one {
+    my ($s,$name)=@_; my @m=grep { $_->{name} eq $name && $_->{section}>0 && $_->{section}<0xff00 } $s->symbols;
+    die "expected one definition of $name, got ".scalar(@m)."\n" unless @m==1; return $m[0];
+}
+sub symbol_bytes { my ($s,$sym)=@_; my $sec=$s->{sections}[$sym->{section}]; return substr($s->section_bytes($sym->{section}),$sym->{value}-$sec->{addr},$sym->{size}); }
+sub at {
+    my ($s,$addr,$len)=@_;
+    for my $sec (@{$s->{sections}}) {
+        next unless $sec->{type} != 8 && $sec->{flags}&2 && $addr >= $sec->{addr} && $addr+$len <= $sec->{addr}+$sec->{size};
+        return substr($s->{data},$sec->{offset}+$addr-$sec->{addr},$len);
+    }
+    die "address not in file-backed allocated section\n";
+}
+sub string_at {
+    my ($s,$addr)=@_; my $result='';
+    for (0..4095) { my $b=$s->at($addr+$_,1); return $result if $b eq "\0"; $result.=$b; }
+    die "final string too long\n";
+}
+sub rels_in { my ($s,$sym)=@_; return grep { $_->{section}==$sym->{section} && $_->{offset}>=$sym->{value} && $_->{offset}<$sym->{value}+$sym->{size} } @{$s->{rels}}; }
+1;

.github/pilots/unicode-v1/Elf64.pm

@@ -0,0 +1,41 @@
+package Evidence;
+# SPDX-License-Identifier: GPL-2.0-only
+use strict; use warnings; use JSON::PP; use Digest::SHA qw(sha256_hex); use Encode qw(encode decode FB_CROAK);
+our $JSON=JSON::PP->new->canonical->ascii;
+our @STAGES=qw(install configure build noop ownership guest parse);
+our @CASES=qw(check_supported_versions check_utf8_comparisons check_utf8_nfdicf check_utf8_nfdi);
+our @APIS=qw(utf8version_is_supported utf8nlen utf8ncursor utf8byte);
+our $SOURCE='62a3294181556f17db863c9016524fa3068a374b';
+sub roles {
+  my @r;
+  for my $s (qw(pull container)) {for my $kind (qw(command log status resources.tsv)) {push @r,["host.$s.$kind","host/$s.$kind"]}}
+  push @r,map { ["host.$_","host/$_"] } qw(preflight.txt terminal.txt image.txt container.cid cleanup.inspect cleanup.stderr cleanup.status result.status);
+  push @r,map { ["runtime.$_","runtime/$_"] } qw(context.json source.lock source.before.txt source.after.txt apt-suites.tsv base-packages.tsv downloaded-packages.tsv installed-packages.tsv tool-versions.txt tool-binaries.sha256 config.full config-check.txt);
+  for my $s (@STAGES) {for my $kind (qw(command log status resources.tsv)) {push @r,["runtime.$s.$kind","runtime/$s.$kind"]}}
+  push @r,map { ["runtime.$_","runtime/$_"] } qw(O-before-noop.sha256 O-after-noop.sha256 O-before-guest.sha256 O-after-guest.sha256 O-links-before-noop.tsv O-links-after-noop.tsv O-links-before-guest.tsv O-links-after-guest.tsv image-identities.sha256 object-identities.sha256 test.cmd core.cmd data.cmd crc.cmd norm.cmd guest-admission.json strict-observer.txt strict-observer.stderr upstream-result.json upstream-parser.txt observer-parser.status member.status);
+  return @r;
+}
+sub may_be_empty { return $_[0] =~ /\A(?:host\.cleanup\.(?:inspect|stderr)|runtime\.strict-observer\.stderr)\z/; }
+sub slurp {my($p)=@_;open my $f,'<:raw',$p or die "$p: $!";local $/;return <$f>}
+sub exact_keys {my($h,@keys)=@_;die "not an object\n" unless ref($h) eq 'HASH';die "unexpected object fields\n" unless join(',',sort keys %$h) eq join(',',sort @keys)}
+sub config {
+ my($s)=@_;my %c;
+ for(split /\n/,$s){my($k,$v);if(/^(CONFIG_\w+)=(.*)$/){($k,$v)=($1,$2)}elsif(/^# (CONFIG_\w+) is not set$/){($k,$v)=($1,'n')}else{next}die "duplicate config $k\n" if exists$c{$k};$c{$k}=$v}
+ die "empty config\n" unless keys%c;return \%c;
+}
+sub hashes {
+ my($s)=@_;my %h;
+ for(split /\n/,$s){die "invalid hash entry\n" unless /^([0-9a-f]{64})  ([^\r\n]+)$/;my($v,$p)=($1,$2);die "duplicate hash path\n" if exists$h{$p};$h{$p}=$v}
+ die "empty hash list\n" unless keys%h;return \%h;
+}
+sub resources {
+ my($text)=@_;my @rows=split /\n/,$text;
+ die "resource header\n" unless shift(@rows) eq "phase\tutc\tfree_bytes\tavailable_memory\tfree_inodes\tO_allocated_bytes\tevidence_allocated_bytes";
+ die "resource endpoints\n" unless @rows>=2 && $rows[0]=~/^admission\t/ && $rows[-1]=~/^terminal\t/;
+ for my $i(0..$#rows){my @v=split /\t/,$rows[$i];die "resource row\n" unless @v==7 && $v[0] eq ($i==0?'admission':$i==$#rows?'terminal':'live') && $v[1]=~/^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\dZ$/;
+ for(@v[2..6]){die "resource number\n" unless /^\d+$/}
+ die "resource cap/floor failure\n" unless $v[2]>=1073741824 && $v[3]>=536870912 && $v[4]>=10000 && $v[5]<=1342177280 && $v[6]<=134209536;
+ die "resource admission failure\n" if $i==0 && ($v[2]<4294967296 || $v[3]<6442450944);
+ }
+}
+1;

.github/pilots/unicode-v1/Evidence.pm

@@ -0,0 +1,136 @@
+# Unarmed public Unicode pilot: revision v4 of the unreleased evidence protocol
+
+This is a review candidate. No publication or run is authorized by these files.
+The source remains `62a3294181556f17db863c9016524fa3068a374b`; original C tests,
+config values, provider selectors, flags and guest settings retain their reviewed
+profile. The setup-base gate is deliberately stale and must be refreshed to the
+then-verified feature-branch tip after review. Do not change the experiment pin.
+
+Both matrix jobs reject `github.run_attempt != 1` before checkout, and reject
+reruns again in the host, container, installer and stage shell boundaries. A
+rerun requires a new separately reviewed request. The initial launch record is
+still unapproved and the request manifest is still unarmed.
+
+The installer uses strict `apt-get --error-on=any update` and requires exactly
+one matching InRelease for each of the three reviewed suites. All three exact
+hashes are checked after apt's signature and default validity/time checks. No
+insecure/trusted/freshness/TLS bypass is added. The earliest expiry is updates
+metadata on 2026-10-09 at 14:11:18 UTC. Expiry must fail and return for review.
+
+Docker CID bytes are preserved as Docker writes them: exactly 64 lowercase hex
+characters with no newline. The incorrect older newline fixture is retained as
+a negative control. No whitespace normalization changes the recorded file.
+
+Image pull and the full container lifetime are supervised. Installation,
+configuration, build, no-op, ownership audit, guest and parser have individual
+admission/live/terminal samples and explicit native/supervisor/cleanup/interruption
+statuses. Cleanup targets the owned process group even when its leader exits
+first. Docker cleanup is bounded, records errors and fails on uncertainty. The
+host separately checks complete output/evidence caps at termination. The output
+cap stays 1.25 GiB, evidence cap 128 MiB, minimum free disk 1 GiB and minimum
+available memory 512 MiB. Admission retains 4 GiB disk and 6 GiB available memory;
+the initial host admission requires 10 GiB disk. A small evidence reserve covers
+final status writes. Cap measurements use allocated filesystem bytes. Every
+measurement, parse, clock read and record write checks its own return status;
+partial numeric output from a failed command is rejected even when Bash errexit
+is disabled. No evidence is truncated to produce a pass.
+
+## Proposed run and time commitment
+
+The setup commit adds both this workflow and the unarmed manifest. It can trigger
+one request-only run, which is expected to reject the setup push and start no
+member. After that expected outcome is verified, a separate manifest-only
+activation commit can trigger one request job and the sequential C/R pair.
+There is no skip directive or hidden trigger bypass. Approval must cover both
+commits, both possible workflow runs and the specified public logs.
+
+The request job has a 10-minute ceiling in each run. Each member has a proposed
+120-minute GitHub job ceiling. Thus the complete planned setup-plus-activation
+maximum is 260 standard-runner minutes: 10 + 10 + 120 + 120. It is not a measured
+duration. The verified prospective base had no pre-existing workflow files; the
+head and workflow inventory must be rechecked before publication.
+
+The internal soft job deadline is 115 minutes from the first workflow step,
+leaving a five-minute tail relative to that step's 120-minute window. Platform
+setup or cancellation is outside this internal timer; a hard runner cancellation
+remains a failed attempt. Pull is allowed at most 10 minutes. The container
+aggregate is at most 100 minutes and must end at least three minutes before the
+soft job deadline. Native stage allowances are installation 20, configuration 10,
+build 30, no-op 10, ownership 5, guest supervision 17 and parser 5 minutes.
+
+The build allowance is over four times the recorded 6m54s native Rust build,
+while package/network/CI performance remains unmeasured. Stage ceilings share
+the aggregate budget; they are not promises that every stage can consume its
+maximum. A stage overrun fails the pilot instead of changing its work.
+
+The original KUnit timeout remains 300 seconds. The original QEMU outer timeout
+remains exactly 900 seconds with a 10-second kill grace. Its separate supervisor
+allowance is 1,020 seconds, so a 900-second stage wrapper cannot preempt the grace
+or postchecks. Before starting the guest, a recorded admission requires at least
+1,560 seconds remaining in both the container and soft job budgets: 1,020 guest
+supervision + 300 parser + 60 cleanup + 180 evidence seconds. Insufficient budget
+stops before guest launch. No guest clock, workload or original timeout is tuned.
+
+The unchanged original Python KUnit parser and the new strict observer both run.
+Their outputs are written directly, with both statuses and nonempty required
+results checked. There is no tee pipeline whose failure can be lost.
+
+## Complete text evidence
+
+`Evidence.pm` is the exact ordered role catalog. `emit-evidence.pl` emits only
+those text files using `UEV3` framing. It records file identity, UTF-8 byte count,
+SHA256, ordered text chunks and an ordered manifest digest. No binary image,
+object, archive or encoded binary payload is emitted.
+
+The envelope includes full raw stage logs, exact command arrays, resource samples,
+status/cleanup records, source/config/tool/apt evidence, complete before/after
+output-tree hash and symlink inventories, original C command files and object
+identities, the complete selected normalizer command sidecar, final ELF-owner
+observations, raw serial, strict observer output and
+unchanged upstream parser JSON. The selected normalizer command's source/required
+flags are checked and its exact bytes are bound to the output-tree hash inventory;
+C and Rust normalizer command files are not required to be identical.
+Empty diagnostic files are allowed only for
+explicitly designated stderr/cleanup roles. Any missing file, cap overrun or
+encoding/emission failure prevents success. Failures remain visible in the logs.
+
+## Read-only download and comparison
+
+After an authorized run, first verify its repository, event, feature branch,
+approved activation commit, attempt 1, workflow identity and the two unique jobs
+`unicode-c` and `unicode-rust` through authenticated read-only GitHub metadata.
+Both jobs must be terminal successes. Preserve the fetched job text exactly as
+UTF-8 and hash those saved files before comparison. Populate the example receipt
+from that verified metadata and those local file hashes; never populate it from
+success text in the logs themselves.
+
+When a connector returns decoded text, the preserved bytes are the UTF-8 encoding
+of that decoded text. They are not claimed to be original HTTP response bytes.
+If the connector omits or truncates text, obtain a complete supported read or
+stop; do not reconstruct or assume missing evidence. Retain the download receipt
+and original saved text with the existing approved backup process.
+
+Run:
+
+    perl compare-logs.pl trusted-download-receipt.json C-job.log Rust-job.log
+
+The comparator checks the download hashes before recognizing optional GitHub
+timestamp prefixes. It then requires one uniquely ordered complete envelope and
+one successful terminal record, verifies every payload/manifest digest and exact
+named role, and checks the substantive stage, config, source, tool, command,
+ownership, original-case and upstream-JSON evidence. C/R original C objects,
+complete commands, package/tool closures and config values must match, except
+the one normalizer selector. Full output and symlink inventories must remain
+identical through each member's no-op, audit and guest.
+
+This validates the evidence contract for logs obtained from the verified run.
+An offline parser cannot authenticate an invented download receipt or distinguish
+a fully fabricated, internally consistent report from its purported origin.
+The GitHub metadata/download verification is therefore a required trust boundary.
+The positive synthetic fixtures intentionally exercise the protocol; they are
+never evidence of a kernel build or runtime pass.
+
+Even a complete passing envelope retains observations and hashes, not final ELF
+bytes. It remains a provisional logs-only C/R result. Independent later binary
+reinspection requires separately approved bounded artifacts; no artifact upload
+or binary-through-logs substitute is included here.

.github/pilots/unicode-v1/README.md

@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+# SPDX-License-Identifier: GPL-2.0-only
+set -euo pipefail
+[[ ${PILOT_RUN_ATTEMPT:-} == 1 ]]
+for key in PILOT_JOB_STARTED_EPOCH PILOT_JOB_DEADLINE_EPOCH PILOT_CONTAINER_STARTED_EPOCH PILOT_CONTAINER_DEADLINE_EPOCH; do
+ [[ ${!key:-} =~ ^[1-9][0-9]{9,11}$ ]] || exit 78
+done
+now=$(date -u +%s) || exit 79
+[[ $now =~ ^[1-9][0-9]{9,11}$ ]] || exit 79
+job_remaining=$((PILOT_JOB_DEADLINE_EPOCH-now))
+container_remaining=$((PILOT_CONTAINER_DEADLINE_EPOCH-now))
+# 17-minute stage covers unchanged QEMU900s+kill10s and110s postcheck margin.
+# Parser300s, cleanup60s and evidence180s are reserved in addition to the stage.
+required=1560
+(( PILOT_JOB_DEADLINE_EPOCH == PILOT_JOB_STARTED_EPOCH+6900 && PILOT_CONTAINER_STARTED_EPOCH >= PILOT_JOB_STARTED_EPOCH && PILOT_CONTAINER_DEADLINE_EPOCH <= PILOT_CONTAINER_STARTED_EPOCH+6000 && PILOT_CONTAINER_DEADLINE_EPOCH <= PILOT_JOB_DEADLINE_EPOCH-180 && now >= PILOT_CONTAINER_STARTED_EPOCH && container_remaining >= required && job_remaining >= required )) || exit 78
+printf '{"now":%s,"job_remaining":%s,"container_remaining":%s,"required_seconds":1560,"guest_timeout":900,"guest_kill_grace":10,"guest_stage_allowance":1020,"parser_seconds":300,"cleanup_seconds":60,"evidence_seconds":180}\n' "$now" "$job_remaining" "$container_remaining" || exit 79

.github/pilots/unicode-v1/admit-guest.sh

@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+# SPDX-License-Identifier: GPL-2.0-only
+set -euo pipefail
+here=$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)
+cat "$here/launch.json"
+# These values may be changed only in the exact owner-reviewed setup revision.
+# This is a recorded approval gate, not a way for software to grant permission.
+if ! jq -e '.schema==1 and .status=="reviewed-pilot" and .public_source_review=="approved" and .owner_pilot_approval=="one-logs-only-execution-approved" and .evidence_mode=="logs-only"' "$here/launch.json" >/dev/null; then
+  printf '%s\n' 'LAUNCH_BLOCKED: exact public draft and one logs-only execution lack owner approval.' >&2
+  exit 78
+fi