Skip to content

Proposal: proof-carrying changes and a universal admission harness for AI-generated code #74

Open

Description

@PhysShell

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:

  1. state the properties required for this change class;
  2. gather the strongest available static, dynamic, architectural, test, security, and provenance evidence;
  3. detect missing or conflicting evidence;
  4. automatically admit only the claims that are actually established;
  5. 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.json production.

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:

  1. Held-out checks for high-risk classes.
  2. Counterfactual verification where proposed fixes are executed against an independent oracle.
  3. Mutation testing or fault seeding to test whether generated tests detect relevant defects.
  4. Before/after failure proof for regression tests.
  5. Oracle provenance so a test generated from the candidate implementation is not automatically treated as independent evidence.
  6. Verifier immutability within the candidate change.
  7. 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 v1 draft schema.
  • Map existing 007 run 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

  1. PhysShell commented on Jul 28, 2026

    @PhysShell
    OwnerAuthor

    Reference follow-up: agent trajectory differential

    A repository review of arthi-arumugam-git/whatbroke and the current qodec/007 documentation found a real but bounded gap.

    Already present

    • qodec already distinguishes byte losslessness, token savings, and live-agent behavioral equivalence.
    • qodec's frozen G5 boundary already names task success, tool trajectories, and total session cost as the remaining live-agent work.
    • 007 already has canonical RunEvent, 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:

    baseline samples
      -> candidate samples
      -> semantic trajectory obligations
      -> typed normalized findings
      -> deterministic pass | fail | blocked
    

    This should cover required/forbidden actions, verifier preservation, argument/result normalization, sampled nondeterminism, and stable finding identity.

    Ownership boundary

    007:
      canonical events
      identities and causality
      replay and artifact verification
      generic behavior-diff provider boundary
      ChangeProof ingestion and reduction
    
    qodec:
      RAW/Qodec pairing
      scenario/sample policy
      qodec-specific normalization
      required verification trajectory
      task/cost/token equivalence criteria
      G5 acceptance record
    
    SemantxTrace / OwnAudit:
      application and business-behavior differential
    

    A dedicated qodec issue now records the G5 design and pilot without inventing a second run-event vocabulary:

    whatbroke is 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.

  2. PhysShell commented on Jul 28, 2026

    @PhysShell
    OwnerAuthor

    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:

    reference arm   = observed previous behavior
    candidate arm   = observed new behavior
    contract        = required properties for this change class
    oracle          = accepted evidence mechanism for each property
    

    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 ChangeContract claims:

    E0  prose assertion
    E1  textual evidence
    E2  parsed structural evidence
    E3  graph/static-semantic evidence
    E4  executable verification
    E5  runtime/differential observation
    E6  independent replay / attested evidence
    

    Examples:

    claims:
      symbol_exists:
        minimum_evidence: E1
      public_api_compatible:
        minimum_evidence: E2
      no_production_dependency_path:
        minimum_evidence: E3
      project_builds:
        minimum_evidence: E4
      business_behavior_preserved:
        minimum_evidence: E5
      acceptance_record_authentic:
        minimum_evidence: E6

    This avoids hard-coding tools as sacred. rg may be sufficient for a textual existence claim and insufficient for a transitive architecture claim. graphify is 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:

    1. Outcome correctness — did the required result occur?
    2. Obligation coverage — were mandatory verification and safety obligations discharged?
    3. Evidence adequacy — is the evidence class strong enough for the claim?
    4. Safety/admissibility — were immutable surfaces, capabilities, and scope respected?
    5. Robustness — how stable is the behavior across repeated runs and what is the baseline noise floor?
    6. Efficiency — tokens, latency, tool count, wall time, and cost.

    Efficiency is normally a ranking axis, not a correctness gate, except where the contract declares a budget.

    Two-axis core verdict

                             evidence adequate
                                    ^
                                    |
           incorrect but well       |       correct and admissible
           diagnosed: FAIL          |       PASS
                                    |
       -----------------------------+----------------------------> outcome
                                    |
           incorrect and opaque     |       result appears correct,
           FAIL + evidence gap       |       but evidence weak: BLOCKED
                                    |
    

    A correct-looking result with insufficient evidence is Blocked, not Pass and not necessarily Fail.

    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:

    same verified result
    same independent replay
    30% fewer tokens
    50% lower wall time
    => PASS + improved
    

    Counterexample:

    same final prose
    independent replay disappeared
    50% fewer tokens
    => BLOCKED/FAIL, never "improved"
    

    Claim/action consistency

    The platform should allow contracts to bind claims to required events/evidence:

    claim: tests passed
    requires: TestSummaryFinished(pass, exact target identity)
    
    claim: verifier replay passed
    requires: VerifierReplayFinished(pass, verifier digest)
    
    claim: artifact downloaded
    requires: ArtifactResolved + digest-verified artifact reference
    

    This catches the agent equivalent of saying "refund issued" without an issue_refund event.

    Suggested ChangeProof v1 additions

    {
      "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

    • Baseline/reference identity is distinct from oracle authority.
    • Every blocking claim declares a minimum evidence class.
    • Tool identity alone does not determine evidence sufficiency.
    • Blocked is emitted for plausible results lacking decisive evidence.
    • Outcome, evidence, safety, robustness, and efficiency remain distinct.
    • Claim/action consistency can be checked against canonical RunEvent evidence.
    • Comparative improved/degraded/lateral does not override admission.
  3. PhysShell commented on Nov 20, 2026

    @PhysShell
    OwnerAuthor

    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.

  4. PhysShell commented on Nov 20, 2026

    @PhysShell
    OwnerAuthor

    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: Admitted advertised 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. Distinguish PROVED_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.

  5. PhysShell commented on Nov 20, 2026

    @PhysShell
    OwnerAuthor

    anti-slop donor: unsafe assertion explanation is NOT evidence (20.11.2026)

    Research page · upstream rules.

    The Oxlint rule require-safety-comment-for-type-assertion merely demands a nearby nonempty SAFETY: 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 against typeof/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.

  6. PhysShell commented on Nov 20, 2026

    @PhysShell
    OwnerAuthor

    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, diagnostics and separate invoke-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.

  7. PhysShell commented on Nov 20, 2026

    @PhysShell
    OwnerAuthor

    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 next docs 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.

  8. PhysShell commented on Nov 20, 2026

    @PhysShell
    OwnerAuthor

    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.

  9. PhysShell commented on Nov 20, 2026

    @PhysShell
    OwnerAuthor

    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 netem or 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.

  10. PhysShell commented on Nov 20, 2026

    @PhysShell
    OwnerAuthor

    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 Run effect boundaries; unlike Golem it does not intercept all arbitrary Go I/O. Run stores completed results or terminal errors and replays them; retryable transient failures are re-executed. SDK docs explicitly warn that the lambda must use its provided RunContext, not the enclosing handler Context (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.

  11. PhysShell commented on Nov 20, 2026

    @PhysShell
    OwnerAuthor

    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.run and timeout; do not use as untrusted-code sandbox. Keep existing Sandboy/OS confinement or disposable runner as a separate admission boundary.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

No one assigned

    Labels

    No labels
    No labels

    Projects

    No projects

      Milestone

      No milestone

      Relationships

      None yet

      Development

      No branches or pull requests

      Issue actions