Repository navigation
Description
Classification
Architecture / product direction / research proposal.
This issue records the intended long-term position of 007: not merely an agent runner or an AI code-review wrapper, but a change-admission system that requires independently reproducible evidence before an AI-generated change is accepted.
Context
AI makes code generation cheap while leaving verification expensive.
The common response is to add another model:
AI writes code
-> AI reviews code
-> human skims the explanation
-> merge
That may improve triage, but it does not establish correctness. A reviewer model can share the builder's assumptions, accept a weak test oracle, approve a modified baseline, or confidently explain a defect.
The underlying problem is not primarily generation quality. It is verification debt:
change volume grows faster than trusted review capacity
There is a related competence problem for junior developers, but it should not be confused with the admission problem. A team may separately require evidence that a contributor understood a change. The core platform must first answer a more objective question:
What independently reproducible evidence permits this exact change to enter the system?
Thesis
007 should become a provider-neutral Change Admission Controller for untrusted or partially trusted code-producing agents.
The core idea is:
human intent
+ explicit change contract
+ constrained execution
+ independent verification
+ replayable evidence
+ fail-closed verdict reduction
The result is a proof-carrying change: a candidate patch accompanied by machine-readable evidence for its claimed properties.
This is not a claim that arbitrary software can be formally proven correct. The practical goal is narrower:
- state the properties required for this change class;
- gather the strongest available static, dynamic, architectural, test, security, and provenance evidence;
- detect missing or conflicting evidence;
- automatically admit only the claims that are actually established;
- present humans with the remaining semantic decisions rather than the entire undifferentiated diff.
Product shape
ChangeContract
|
v
Untrusted Builder
|
v
Candidate Diff
|
+----------------+----------------+
| | |
v v v
Static Verifier Runtime Verifier Policy Verifier
| | |
+----------------+----------------+
|
v
Evidence Correlator
|
v
Deterministic Reducer
|
v
PASS / REJECT / HUMAN_JUDGMENT
Models may assist in planning, implementation, explanation, test generation, and evidence interpretation. They must not be the sole authority for admission.
Universal kernel, domain-specific semantics
The universal part should be deliberately small.
Universal 007 kernel
TaskContract/ChangeContract;- immutable base revision and environment identity;
- worktree, container, or microVM isolation;
- capability and network policy;
- diff scope policy;
- builder/verifier separation;
- verifier identities and versions;
- evidence schema and evidence DAG;
- replayable run records;
- deterministic verdict reduction;
- risk lanes and escalation rules;
- attestations and artifact hashes.
Domain adapters
- .NET / WPF;
- web applications;
- backend APIs;
- database migrations;
- mobile;
- framework or dependency migrations;
- project-specific business journeys.
The kernel should not pretend to understand every framework and business domain. That path ends with a large prompt, a grep wrapper, and a marketing page about autonomous engineering.
Trust boundaries
1. The builder does not own its examination
A builder must not silently modify:
- gate configuration;
- approval baselines;
- verifier binaries;
- held-out tests;
- policy sources;
- evidence history;
- accepted snapshots;
- release provenance rules.
Changes to those surfaces require a separate high-risk contract and independent approval.
2. Builder and verifier are independent roles
The verifier receives:
- immutable task intent;
- immutable baseline identity;
- candidate diff;
- read-only evidence inputs;
- verifier policy.
It must not treat the builder's explanation or chain of reasoning as evidence.
3. Baseline evidence is captured before mutation
Before the builder runs, record relevant state:
- current build and test status;
- warnings and known findings;
- architecture facts;
- dependency graph;
- public API surface;
- runtime traces;
- business-side effects;
- coverage or mutation baseline where applicable.
This prevents the candidate from redefining a new failure as pre-existing history.
4. Unknown evidence fails closed
The reducer must distinguish:
proved true
proved false
not observed
conflicting
verifier unavailable
out of scope
Absence of evidence is not a green checkmark with better typography.
Change Proof Bundle
A stable bundle should become the central interchange format:
change-proof/
intent.json
environment.json
base-identity.json
actor-identities.json
action-plan.json
capability-log.jsonl
diff.patch
scope-verdict.json
build-evidence.json
static-evidence.json
architecture-delta.json
behavioral-delta.json
test-evidence.json
mutation-evidence.json
provenance.json
unresolved-claims.json
verdict.json
attestation.dsse
A verdict should not be a decorative floating-point confidence score.
Example:
{
"verdict": "human_judgment_required",
"passed": [
"build",
"public_api_compatibility",
"dependency_policy",
"ui_journey:customer-search"
],
"blocked": [],
"unresolved": [
{
"claim": "changed rounding behavior is intentional",
"reason": "legacy executions exhibit two conflicting behaviors",
"required_role": "domain_owner"
}
]
}The human reviewer should answer the unresolved domain question, not manually rediscover every mechanical fact already established by tools.
Repository responsibilities
007: execution and admission plane
Owns:
- task/change contracts;
O7ActionPlan;- worktree and runner lifecycle;
- capability enforcement;
- immutable gate definitions;
- builder/verifier separation;
- run records;
- evidence collection protocol;
- final fail-closed reduction.
Own.NET: semantic obligation engine
Owns machine-readable facts and obligations such as:
- lifetime and ownership rules;
- architecture boundaries;
- forbidden dependencies;
- async and UI-thread contracts;
- resource disposal;
- API and compatibility obligations;
- finding identity and lineage;
- architecture delta.
Expected result shape:
{
"obligation": "UI_THREAD_ACCESS",
"subject": "OrderViewModel.Refresh",
"before": "satisfied",
"after": "violated",
"evidence": ["call-path:...", "dispatcher-state:..."],
"severity": "block"
}SemantxTrace: behavioral truth plane
Owns normalized runtime observations:
- business operations;
- UI journeys;
- SQL effects;
- exceptions;
- message ordering;
- async causality;
- framework interactions;
- stable semantic events;
- old/new differential traces.
Raw logs should not be compared byte-for-byte when timestamps, identifiers, or permitted ordering are nondeterministic. The comparison target is normalized semantic behavior.
OwnAudit: evidence and decision plane
Owns:
- static/runtime/build/security/provenance evidence correlation;
- finding lineage;
- evidence DAG construction;
- evidence completeness reporting;
- unresolved-claim classification;
- review packaging;
fix-proof.json/change-proof.jsonproduction.
Sandboy: containment plane
Owns process-level trust boundaries:
- filesystem capabilities;
- network policy;
- environment allowlist;
- process tree control;
- secret isolation;
- resource limits where supported;
- machine-readable enforcement report.
The builder is treated as an untrusted contractor, not as a friendly script with unusually broad shell access.
Preventing verifier gaming
The platform should support:
- Held-out checks for high-risk classes.
- Counterfactual verification where proposed fixes are executed against an independent oracle.
- Mutation testing or fault seeding to test whether generated tests detect relevant defects.
- Before/after failure proof for regression tests.
- Oracle provenance so a test generated from the candidate implementation is not automatically treated as independent evidence.
- Verifier immutability within the candidate change.
- Production reachability and architecture checks, not text-based approximations that can be satisfied by comments or dead code.
Optional novice-learning lane
Training evidence can be layered on top without contaminating the core admission verdict.
Possible observable demonstrations:
- predict which architectural obligation the change affects;
- identify which test should fail after a seeded regression;
- explain a concrete runtime trace;
- localize a fault without regenerating the entire change;
- complete a small follow-up modification under restricted assistance.
The output should be a competence matrix, not an LLM-generated personality score:
WPF dispatcher semantics demonstrated
IDisposable ownership demonstrated
SQL transaction boundaries not demonstrated
DevExpress binding lifecycle assisted only
Commercial wedge
Do not begin with "every PR in every language". Generic AI review is already crowded and easy to imitate.
The strongest initial product is:
Safe incremental modernization of legacy .NET Framework / WPF systems with evidence of behavioral preservation for each migrated business journey.
This area has:
- high defect cost;
- weak or misleading test coverage;
- hidden business rules;
- UI and async behavior;
- SQL side effects;
- binary dependencies;
- architecture drift;
- substantial human review cost;
- poor fit for generic coding agents.
The first sellable unit is one verified journey, not a promise to migrate an entire monolith:
legacy journey capture
-> semantic trace
-> explicit obligations
-> candidate implementation
-> normalized differential
-> static/runtime/provenance evidence
-> admission verdict
Example:
customer search
-> open customer card
-> calculate debt
-> edit fields
-> save
-> verify SQL effects
-> verify audit trail
-> compare UI/runtime semantics
Moat
The durable advantage is not the chosen model or orchestration framework.
It is the accumulated corpus of:
- behavioral specifications;
- accepted equivalences;
- business journey traces;
- architecture facts;
- verifier adapters;
- failure taxonomies;
- exception policies;
- finding lineage;
- reproducible migration evidence.
Every senior review decision should eventually become one of:
one-time exception
new deterministic rule
new characterization scenario
new architecture obligation
new policy
new detector
Review knowledge should compound instead of evaporating into PR comments.
Initial roadmap
R0: one proven WPF journey
- one legacy build identity;
- one candidate implementation;
- stable UI identifiers;
- semantic trace health gate;
- SQL effects;
- deterministic normalization;
- Own.NET obligations;
- OwnAudit evidence bundle;
- 007 fail-closed verdict.
R1: ChangeProof v1
Define:
- evidence types;
- claim identity;
- verifier identity;
- provenance;
- deterministic reducer;
- unresolved claims;
- DSSE / in-toto-compatible attestation mapping.
R2: risk lanes
Example:
L0 documentation
L1 local refactor
L2 behavior-preserving code change
L3 dependency or API migration
L4 data or business-rule change
L5 security, release, or infrastructure
Each lane defines mandatory verifier classes and escalation rules.
R3: reviewer-load benchmark
Compare:
- ordinary PR;
- PR with AI summary;
- PR with Change Proof Bundle.
Measure:
- reviewer time;
- files opened;
- review iterations;
- escaped defects;
- confidence calibration;
- novice retention where applicable.
R4: migration adapter SDK
Provider interfaces for:
- static facts;
- runtime observations;
- business mapping;
- differential comparison;
- policy;
- attestation.
Non-goals
- claiming universal formal correctness;
- replacing all human domain decisions;
- treating an LLM review as independent proof;
- inventing a single scalar quality score;
- building a generic agent marketplace before the admission kernel works;
- allowing candidate changes to rewrite their own acceptance conditions;
- coupling the design to one model vendor.
Research question
Can AI-generated change volume scale faster than human verification cost when every admitted change must carry independently reproducible evidence for its claimed properties?
Supporting questions:
- which claims can be established deterministically;
- which require runtime or statistical evidence;
- how verifier completeness is measured;
- how verifier gaming is detected;
- how escalation is calibrated;
- how human decisions become permanent rules;
- how competence growth is measured without weakening admission criteria;
- how long-term architecture entropy is tracked.
First acceptance criteria for this proposal
- Define a stable
ChangeProof v1draft schema. - Map existing
007run artifacts into the schema. - Define immutable and candidate-modifiable surfaces.
- Define builder/verifier trust boundaries.
- Define verdict states and fail-closed reduction rules.
- Select one WPF business journey as the R0 vertical.
- Map Own.NET, OwnAudit, SemantxTrace, and Sandboy evidence producers into that vertical.
- Produce one replayable end-to-end change proof.
- Measure reviewer work with and without the proof bundle.
Position
007 should not compete on writing more code than other agents.
It should become the infrastructure that decides which generated changes deserve to exist in the production history, and can explain that decision with evidence that survives model changes, reviewer turnover, and time.
Activity
PhysShell commentedon Jul 28, 2026
Reference follow-up: agent trajectory differential
A repository review of
arthi-arumugam-git/whatbrokeand the current qodec/007 documentation found a real but bounded gap.Already present
007already has canonicalRunEvent, digest chaining, a pure reducer, and independent replay in PR 4 — Canonical run events, pure reducer, and independent replay #65.Missing layer
What is not yet present as a normative artifact is an agent trajectory differential over canonical events:
This should cover required/forbidden actions, verifier preservation, argument/result normalization, sampled nondeterminism, and stable finding identity.
Ownership boundary
A dedicated qodec issue now records the G5 design and pilot without inventing a second run-event vocabulary:
G5: agent trajectory differential and behavior contracts for live-agent equivalencewhatbrokeis treated as a compact reference implementation, not as the final normative engine. Its useful ideas are sampled traces, baseline flakiness classification, behavior contracts, and deterministic offline diffing; its name-only LCS alignment, shallow JSON equality, coarse finding identity, and string output comparison are insufficient for the proof-carrying-change path.PhysShell commentedon Jul 28, 2026
Design refinement: claim-to-evidence admission model
A baseline trace must never be treated as an oracle merely because it predates the candidate. The admission model should keep four roles explicit:
The reference arm is useful for noise-floor estimation, regression localization, and discovering previously undocumented behavior. It does not define correctness.
Evidence-strength ladder
A practical provider-neutral ladder for
ChangeContractclaims:Examples:
This avoids hard-coding tools as sacred.
rgmay be sufficient for a textual existence claim and insufficient for a transitive architecture claim.graphifyis not inherently better; it is better only when it produces the evidence class required by the claim.Admission axes
Keep these dimensions separate rather than collapsing them into one score:
Efficiency is normally a ranking axis, not a correctness gate, except where the contract declares a budget.
Two-axis core verdict
A correct-looking result with insufficient evidence is
Blocked, notPassand not necessarilyFail.Comparison annotation
Admission and comparative quality should be separate fields:
{ "admission": "pass | fail | blocked | human_judgment_required", "comparison": "improved | degraded | lateral | unknown" }A candidate is an improvement only when hard obligations, outcome, evidence strength, and safety are not degraded and at least one soft axis improves.
Example:
Counterexample:
Claim/action consistency
The platform should allow contracts to bind claims to required events/evidence:
This catches the agent equivalent of saying "refund issued" without an
issue_refundevent.Suggested
ChangeProof v1additions{ "claims": [ { "claim_id": "...", "claim_kind": "no_production_dependency_path", "required_evidence_level": "E3", "evidence_refs": ["..."], "observed_evidence_level": "E1", "verdict": "insufficient" } ], "axes": { "outcome": "pass", "obligations": "pass", "evidence_adequacy": "blocked", "safety": "pass", "robustness": "unknown", "efficiency": "improved" } }Acceptance additions
Blockedis emitted for plausible results lacking decisive evidence.RunEventevidence.improved/degraded/lateraldoes not override admission.PhysShell commentedon Nov 20, 2026
Research donor: assurance cases, evidence validity and reproducible CLI checks (20.11.2026)
Safety-critical engineering page · resource catalog · LIT/FileCheck article.
This is a methodological addendum, not approval to impose a safety-certification process or build a new assurance engine.
Small negative controls for the existing proof-carrying/admission harness: (a) evidence produced for older SHA, (b) green CLI CHECK assertions but false semantic claim, (c) missing assumption/exclusion and unsupported input incorrectly shown as PASS, (d) tool execution output missing or contradictory. Distinguish claim, argument, run evidence, assumptions, independent validation, and residual unknown. LIT/FileCheck is one possible fixture style for textual CLI assertions only, not a proof oracle.
GO only if explicit evidence fields/gates reveal a real missed invalid admission compared with baseline. Else DEFER. No runtime dependency or CI release-policy change from this research note.
PhysShell commentedon Nov 20, 2026
Axiomander evidence status anti-patterns (20.11.2026)
Research · Axiomander admitted proof false completion repro.
Add bounded admission negative controls to the already-scoped evidence-gate research:
Admittedadvertised as complete, external axiom treated as verified theorem, SMT UNKNOWN projected to PASS, unverified source→IR lowering claiming source-level validity, and stale callee-proof accepted after contract change. DistinguishPROVED_WITH_ASSUMPTIONS,ASSUMED,UNPROVED,STALE,COUNTEREXAMPLE,UNKNOWN; retain full proof/query assets, exact hash and trust-boundary lineage.Require a deliberately bad synthetic artifact to be refused by the gate. A successful Coq compilation or agent success message alone is not a sufficient proof receipt. Compare with present baseline; no universal formal-verification platform, integration, or production gate change authorized.
PhysShell commentedon Nov 20, 2026
anti-slop donor: unsafe assertion explanation is NOT evidence (20.11.2026)
Research page · upstream rules.
The Oxlint rule
require-safety-comment-for-type-assertionmerely demands a nearby nonemptySAFETY:justification for TS casts. It does not verify that justification. This is a useful negative control for proof-carrying/admission workflows: an agent writes a plausible but false safety explanation and the policy lint passes. Distinguish claimed invariant from independently observed validation.Bounded pilot on a small authorized TS fixture (not general cross-language lint): select only
no-widen-then-assert,no-chained-type-assertions,no-known-value-widening,require-safety-comment-for-type-assertion,no-reduce-accumulator-copy; compare plain tsc/ESLint/Oxlint baseline and false positives. If a cast needs a proof, require validator/invariant ID + verified fixture/receipt rather than decorative comment. The anti-slop project is vendoring-first, uses lexical AST/scope instead of full TS checker and contains deliberately opinionated rules againsttypeof/module mocking/names; do not enable the whole ruleset by default.GO only if the pilot catches actionable real issues or materially improves audit cost; else DEFER. No new mandatory lint/CI gate or direct code modification.
PhysShell commentedon Nov 20, 2026
Grain: agent-readable runtime catalog, validate-before-invoke and explicit effects (20.11.2026)
Research page · dev-only code-agent-tools · Event Model.
Useful for the proof-carrying admission discussion as a small donor rather than a new infrastructure platform: agent introspects actual command/query/event schemas and available capabilities from read-only registry, validates proposed payload against independent schema, then requests an explicitly permissioned mutating invocation with receipt/tenant/revision. Grain exposes
catalog,schemas,validate,diagnosticsand separateinvoke-command!; it is dev-only and the latter can append real events. Never equate schema validation to authorization or a development mode marker to a security sandbox.Bounded negative controls: omitted/forged tenant context, unsafe command despite valid schema, stale catalog after deployment, untrusted agent trying write through read-only path, misleading accepted event without intended business result. Compare with existing 007 admission harness and evidence receipts; no nREPL production access, no new runtime plugin, no framework adoption or CI change.
PhysShell commentedon Nov 20, 2026
Golem donor: durable effect receipts, replay boundaries and external idempotency (20.11.2026)
Research page · Golem docs: durable execution · recovery implementation.
GOLEM-01 / CRASH-REPLAY-BOUNDARY / KILL-FIRST, inside existing proof-carrying admission harness investigation. Golem journals host external calls/results, replays guest code using committed results, then resumes live. Exactly-once scope matters: committed internal agent/tool calls are documented as exactly-once; HTTP in-flight at crash may be retried with same idempotency key and remote exactly-once depends on downstream deduplication. A committed oplog entry is not proof that all external effect boundaries were atomically committed. The
nextdocs may precede stable release; do not adopt marketing claim without own test.Isolated synthetic Go agent flow with mock model, external HTTP, effect ledger and approval callback: inject failures (1) before send, (2) remote applied / response lost, (3) response observed before local log commit, (4) after durable log, (5) snapshot/replay-to-live, (6) new binary revision vs old history. Independently count real remote mutations under idempotent vs non-idempotent server; record SHA, trace/order, log index, invocation key, policy decision and ambiguous in-flight state. Compare existing outbox/inbox+idempotency baseline.
GO only if ≥2 independently reproduced gaps or meaningful evidence/recovery benefit not already covered; STOP if existing simple harness suffices. GOLEM-03 replay-upgrade deferred. No Golem runtime migration, new CI gate or customer data. Golem core is BUSL-1.1, not unrestricted OSS.
PhysShell commentedon Nov 20, 2026
Billy B-Assistant: bounded update/recovery evidence donor (20.11.2026)
Research page · upstream update design.
BILLY-02 / LAST-KNOWN-GOOD-UPDATE / KILL-FIRST, if release/admission workflow gaps arise. The project maintains an independent rescue startup path, versioned release environments, digest-checked locks, explicit selected generation and staged health validation/rollback. Transfer the test questions, not the noncommercial Python code. A proof-carrying update receipt should distinguish downloaded/verified/staged/activated/healthy/rolled-back and bind exact release SHA, configuration revision, expected generation, health gate and rollback compatibility.
Synthetic fault injection against existing release/admission baseline: corrupted config, candidate fails start, lost power between staging and selection, stale worker signal after new generation, incompatible durable state. Independently verify selected release and persisted data after restart. If basic backup+atomic switch already covers this, no new architecture. Release provenance/signatures and migration rollback are NOT proved merely by SHA-256 of a lockfile. No production update, new dependency, or platform build; upstream license restricts commercial derivative use.
PhysShell commentedon Nov 20, 2026
Awesome Networking donor: NETWORK-01 / ambiguous HTTP outcomes under injected link faults (20.11.2026)
Research page · nyquist catalog · containerlab · netem-style tool.
NETWORK-01 / FAILURE-MATRIX / KILL-FIRST as bounded addendum to proof-carrying action admission/receipts, not a new network test framework. Separate (a) transient connection failure before send, (b) remote server committed an effect but response was dropped, (c) response observed but local receipt lost, (d) reconnection/retry with same or different idempotency key. For each, hold an independent mock server-side mutation ledger and compare invocation key, attempt IDs, actual side effects, admitted claim, trace SHA and any UNKNOWN outcome. Do not infer from timeout/500 that no effect occurred; exactly-once external mutation requires a cooperating downstream deduplication contract.
Compare inexpensive deterministic HTTP fault proxy plus current mocked failures against Linux namespaces +
tc netemor containerlab; use disposable namespace and a tiny Go client/server. Explicit inject/control of post-commit response drop matters more than stochastic packet loss. GO if ≥1 independently confirmed defect or meaningful coverage missing today; STOP if existing test harness/outbox checks fully cover it. No CI gate, production packet capture, live host network impairment, or platform dependency. NETWORK-03 AI-agent overlay network remains DEFER; default WireGuard/mTLS/HTTPS, not new custom tunnel.PhysShell commentedon Nov 20, 2026
Restate donor: RESTATE-01 / durable step vs PostgreSQL outbox, kill-first (20.11.2026)
Research page · runtime · Go SDK durable Run.
Restate uses an external durable journal/server to recover ordinary Go service handlers with explicit
Runeffect boundaries; unlike Golem it does not intercept all arbitrary Go I/O.Runstores completed results or terminal errors and replays them; retryable transient failures are re-executed. SDK docs explicitly warn that the lambda must use its providedRunContext, not the enclosing handlerContext(undefined/concurrent behavior).RESTATE-01 / DURABLE-STEP-BOUNDARY / KILL-FIRST: in a disposable Go+PG fixture implement the same 4-step workflow in A) current SQL transactions+outbox/inbox+idempotency worker and B) Go SDK+Restate server. Inject crash/transport cut (1) before send, (2) remote effect committed but response lost, (3) received response before durable result, (4) after journal commit, (5) duplicate invocation/idempotency key, (6) restart with same workflow. Count real remote mutations in an independent server-side ledger and preserve attempts/keys, log positions, exact SHA, observed ACK, UNKNOWN outcome, response and state. Restate exactly-once step replay does not mean atomic exactly-once mutation of arbitrary external HTTP/SQL resource. Stable downstream deduplication remains essential.
Compare total runnable code, operational footprint, recovery accuracy, ambiguity, and time-to-debug vs the baseline. GO only on independently proven missing guarantee or clear meaningful reduction in complexity for an actual long-lived workflow; STOP if simple Go/PG outbox covers the case. No production migration, permanent server, extra CI gate or customer data. Runtime BUSL-1.1, sdk-go MIT.
PhysShell commentedon Nov 20, 2026
TESTed donor: TESTED-01 / language-neutral tests with independent typed oracles (20.11.2026)
Source audit + kill-first · dodona-edu/universal-judge · capability model · language adapters.
TESTed (Ghent University) uses one language-neutral YAML suite to generate C#/Python/Java/Kotlin/etc test harnesses, checks required constructs/types against each adapter before execution (
SUPPORTED/REDUCED/UNSUPPORTED), then runs independent value/text/exception/exit/file oracles. It is an educational judge, not proof of code correctness. Go is NOT a supported adapter in the audited repo; a Go-vs-C# pilot would need a new adapter, not a claimed ready-made feature.TESTED-01 / LANGUAGE-NEUTRAL-ORACLE / KILL-FIRST: freeze 20 tiny pure function cases with type width, numeric overflow, float precision, null, collection ordering, exceptions and text encodings. Compare language-neutral typed fixture + wrappers for C# and Python vs small native xUnit/pytest suites (and only add Go if justified). Independent expected values + suite SHA + per-language run evidence, explicit unsupported capability and type fallback (not silent equivalence). Track unique semantic discrepancies, duplication avoided, maintenance LOC and diagnostic fidelity.
GO if shared source catches independently confirmed cross-target drift or removes significant duplicated tests; STOP if native suites reading common JSON are simpler. Treat tests as bounded evidence; no new agent platform or mandatory CI. Security: TESTed launches code with Python
subprocess.runand timeout; do not use as untrusted-code sandbox. Keep existing Sandboy/OS confinement or disposable runner as a separate admission boundary.