asketeddy/gooo-canonical-decision-tiny-v1

Gooo Canonical Decision Tiny v1

Small, independently trained decision models for Gooo program construction. They read a source-declared choice, example outputs and intermediate Boolean requirements, then suggest which finite code path to check first. Gooo assembles and executes the candidates, records unmet requirements, and can continue through the remaining choices without another prediction.

Think of a small function with a few marked switches: the model suggests how to set the switches; the supplied examples tell the compiler which settings work. The original study has two switches per function: comparison operand order and branch layout. Each function therefore has four possible bodies.

Published 2026-10-11. Research weights; the default model is unchanged. The model architecture, training and local inference are implemented in Go. The original mean/extreme pair was fitted from fresh seeded weights on authored synthetic Gooo examples. Each has 19,034 FP32 parameters / 76,136 weight-array bytes. The artifacts below preserve the original fits byte for byte.

Compiler and language direction — 2026-10-17

The accepted compiler main source pins SDK0.2.51. Its adapter has separate ordinary V3, V3 prose-neutral and V4 routes. The latest published compiler binary is still 0.6.34-dev / SDK0.2.44; the artifact table below distinguishes these two distribution states.

Gooo's semantic IR, construction candidates, observations, origin relationships and saved replay are program structures. The trained decision models rank choices allowed by Gooo source. Source declarations retain the permitted program space; recorded choices and actual execution observations retain their own origins. The deterministic ordering remains available when a model is omitted.

The next research direction is to expose type, activity-input/output and origin relationships in compact fixed arrays. Stable IDs identify those relationships; evaluation should distinguish learning the relationships from memorizing ID text. Small rule and linear rankers provide useful baselines before adding graph-model complexity. Program families and Korean/English expression pairs need separate reporting, alongside candidate checks, tensor bytes, whole-process memory and ranking time. These are proposed studies; this documentation update runs zero new fits, predictions or programs. The existing V3/V4 regression results below remain the observations for those frozen studies.

Gooo의 의미 구조와 학습된 판단 모델을 구분해 개발합니다. 작은 모델이 선언된 후보의 순서를 제안하고, 언어는 선택과 실행의 출처를 보존합니다. 다음 연구에서는 타입·활동·기원 사이의 관계를 작은 입력으로 읽는 방법을 살펴볼 계획입니다. 이번 갱신은 컴파일러 지원 범위와 연구 방향을 정리한 문서 변경입니다.

Match the artifact to the compiler

Artifact	Compatible route
result/model-mean.json or result/model-extreme.json	Public compiler 0.6.32; earlier 0.6.28/0.6.29/0.6.30/0.6.31 adapters are retained; canonical adapter introduced in SDK 0.2.40
research/source-relative-learning-20261011/result/model-relative.json	SDK 0.2.41; public compiler 0.6.32, model route and commands
research/return-layout-learning-20261012/result/model.json	V2 decoder introduced in SDK0.2.42; public compiler0.6.33/0.6.34, V2 guide
research/output-relations-v3-learning-20261012/result/v2/model.json	Public compiler0.6.33/0.6.34, explicit V2 route
research/output-relations-v3-learning-20261012/result/v3/model.json	Public compiler0.6.34 with SDK0.2.44, V3 guide
profiles/source-relative-v3-prose-neutral-20261012/model.json	Explicit neutral decoder introduced in SDK0.2.45; accepted compiler source uses SDK0.2.51 with a separate neutral route
research/branch-owned-learning-20261012/result/v4-branch-owned/model.json	V4 decoder introduced in SDK0.2.46; accepted compiler source uses SDK0.2.51 with an explicit V4 route; the fresh study retained its first-choice regression

The later role-learning files are retained research variants. The sections below keep their separate protocols, measurements and artifact schemas. The compiler's default ordering remains deterministic; supplying a compatible model enables ranking.

Fresh V4 study: branch ownership alone did not improve the decision

SDK0.2.46 adds a separate V4 artifact and branch-owned input channel. A new preregistered study compares fresh V3 prose-neutral and V4 models using identical seeds, fit settings and768 training documents. Evaluation holds out four operator-pair families: 384 sibling rows from24 goal contracts, including positive, negative and above2^53 literal regimes. Each candidate must meet8 output and3 Boolean requirements.

Held evaluation	V3 neutral	V4 branch-owned
First complete candidate	112/384 (29.17%)	60/384 (15.63%)
Candidate checks to completion	960	1016
Checked finite completion	384/384	384/384
Every sibling complete on first choice	1/24 contracts	0/24 contracts

The fixed-first mask0 baseline completes96/384. V4 alone completes40 paired rows, neutral alone92; both complete20 and neither232. Both models have low training first-completion. The result motivates examining how source and requirement information reaches the decision head; it does not isolate one cause. Exact raw inputs have no incompatible accepted-mask groups or cross-split identical groups. These descriptive sibling counts are not independent task-population estimates.

Both original models and all outcomes are public. Each model fitted once; collection retained6144 candidate histories, and evaluation made3072 predictions without rerunning those bodies. Separate checked probes match1536/1536 observations but repeat96 unique contract/input pairs. A saved-data audit makes zero new model, fit, candidate or native calls. No timing, CPU/RSS, GPU or quantization result was collected. Earlier fitted studies remain unchanged and neither profile becomes the default model.

V4 keeps528 source values and19,034 FP32 parameters/76,136 tensor bytes. The model sees the literals owned by each branch separately; intent cells remain zero. The runtime predicts once before finite checks. SDK0.2.46 loads both new artifacts; the accepted compiler adapter contains the explicit V4 route with SDK0.2.51. Public compiler0.6.34 continues its existing SDK0.2.44 routes.

분기별 부품을 따로 보여주는 입력을 실제로 학습해 봤습니다. 이번 과제에서는 V4의 첫 선택 완전성이 낮아졌고 확인해야 할 후보도 늘었습니다. 실패 결과와 두 모델을 함께 공개했습니다. 후보 확인을 마친 뒤에는 두 모델 모두 선언된 조건을 충족했고, 그 과정과 첫 판단의 성과를 따로 기록합니다.

Fresh V2/V3 comparison and SDK0.2.44

A new frozen study uses256 Gooo documents in16 return-operator families and32 parameterized contracts. The paired models each trained once on128 new documents with identical settings. Evaluation uses64 documents in four return-operator-pair families absent from training.

Evaluation observation	Fresh V2	Fresh V3
First candidate meets6 outputs +3 Boolean requirements	21/64	18/64
Korean/English first-mask agreement	11/32 pairs	5/32 pairs
Retained candidate checks to completion	140/64	152/64
Checked finite completion	64/64	64/64

V3's added source/output relationships did not improve the first decision in this cohort. Both models and their first failures are preserved in the original results. All ranking evaluation reads once-collected interpreter histories; native execution, general prose, CPU/RSS and latency remain separate or unmeasured. The512 checked probe observations repeat64 unique contract/input pairs in the evaluation split.

SDK0.2.44 provides the explicit V3 artifact, zero-call inspection and one-call finite search. It keeps528 source cells and19,034 FP32 parameters/76,136 tensor bytes. The new V2 file uses the public compiler0.6.33 V2 route. V3 compiler integration was merged in PR1485 as f72e5b6c40aef15932ddf62e990be9dc00ff3974. Its original source CI, numerical compatibility checks and native readiness passed. PR1488 was accepted as b266c0e2cf6878385b59788945861a03e33f766b and published as0.6.34 with a separate zero-weight V3 release regression. The public0.6.34 binary consumesSDK0.2.44. The default model is unchanged.

New factorized decision cohort

A fresh preregistered cohort separates parameter settings, opposing goals, Korean/English, wording, original layout and direct-return/assignment forms. It contains2048documents from64goal contracts. Each of three new models fitted once on1024rows with identical settings; the512held evaluation rows repeat16goal contracts in four operator-pair families.

Held-family observation	V2 full prose	V3 full prose	V3 prose-neutral
First body meets6outputs+3conditions	254/512	220/512	264/512
Korean/English first-mask agreement	162/256	122/256	256/256
Layout-adjusted first-mask agreement	146/384	102/384	136/384
Opposing goals: both first bodies correct	54/256	40/256	64/256
Retained candidate checks to completion	822/512	928/512	776/512
Checked finite completion	512/512	512/512	512/512

Prose-neutral clears only source cells[64:192]. Equivalent language/wording rows then have identical inputs, so their complete agreement follows from representation and deterministic inference. It does not demonstrate bilingual comprehension. Although Boolean checks match1536/1536,248/512 of its first bodies fail some declared output. Return-branch choice and source-layout stability remain gaps.

A read-only follow-up checks exact input identity and groups these same saved outcomes. In the neutral profile, first completion is 0/128 when raw mask 1 is required and 128/128 when mask 3 is required. None of the 16 held contracts completes every sibling variant on the first choice. Exact inputs contain no conflicting accepted-mask groups; hidden representation loss remains unmeasured. The reader makes zero new fits, predictions or candidate executions and is also available in the Go SDK.

같은 계산도 소스에서 가지를 놓는 순서에 따라 첫 선택이 흔들립니다. 저장된 결과를 나눠 보니 특정 스위치 조합은 128개 모두 실패했습니다. 다음 개선은 반환 계산과 조건의 연결을 모델이 더 잘 구분하도록 표현하는 데 집중합니다. 학습량을 늘렸을 때의 효과는 아직 측정하지 않았습니다.

The complete original results retain all three models, losses,6144decision observations, paired IDs and8192 once-collected candidate histories. A stdlib-only reader checks retained outcomes with zero new fits, predictions, candidate or native executions. Each model still uses19,034FP32 parameters/76,136tensor bytes. No latency, CPU/RSS or GPU trial was added. The4096evaluation probe observations repeat128unique goal-contract/input pairs; first completion and checked completion have separate meanings.

The new full-prose weight files use existing V2/V3 routes. Prose-neutral requires the published Go preprocessing and explicit profile.json; its weight file alone does not reproduce this study through the ordinary compiler loader. The separate explicit profile below supplies a supported loader contract for unchanged tensors. These are compiler-library/interpreter observations, with native integration separate. The public default remains unchanged. These2048rows are synthetic factor variants, not2048independent algorithms or100experimental methods.

Explicit neutral SDK profile and one direct Gooo task

SDK0.2.45 publishes a distinct artifact, zero-call inspection and one-call finite search for V3 with intent cells64..191 cleared. All other400 source values and every output/ Boolean row remain. The new file binds this policy to the original tensors and has its own fingerprint. Original ordinary-V3 weights retain their interpretation. The loader-ready model and exact runtime binding were packaged with zero prediction, candidate or training calls. This adds no quality measurement to the frozen2048-document study.

A new preregistered usage-band contract uses rate7 below4093 and rate5 at/above4093. The fitted neutral model selected the comparison correctly and the return placement incorrectly. Its first body matched 0/6outputs and3/3Boolean cases. Without a new prediction, the second of four possible bodies matched6/6outputs and3/3conditions. Native caller1/1 and separate evaluation8/8 passed, including exact signed integers beyond2^53.

The complete first failures, generated source and native result come from one command invocation and one model call on clean development source 673789ad59aa09dbe129eea4ceae0114cdae4b3a. No fitting or adjustment followed the decision. The runtime internally performs two process executions per caller/ evaluation; this multiplicity was underestimated in the protocol, and eight evaluation inputs remain the denominator. Three overlap declared boundary cases; the other five are separate. A saved-report read and stdlib audit made zero new model/program calls. Incidental timing/RSS fields are retained without a repeated benchmark or comparative speed claim.

PR1492 was closed without merging. The later accepted compiler source contains the explicit neutral and V4 routes with SDK0.2.51. PR1490 is also closed; the historical source and outcomes remain recorded. This development/native task has its own source identity. The public0.6.34 binary continues to use the ordinary V3 route described below; compiler acceptance and release remain separate from SDK/model publication.

이번 연결에서는 Gooo가 가능한 몸체 네 개를 정해 두고, 작은 모델이 확인할 순서를 고릅니다. 실제 과금 예제에서 첫 후보는 조건식 세 개를 맞혔지만 반환값 여섯 개를 모두 틀렸습니다. 같은 판단을 사용해 두 번째 후보를 검사한 뒤 선언 사례를 충족했고, 별도 실행 입력 여덟 개도 통과했습니다. 반환 계산을 어느 가지에 놓을지가 아직 약한 부분입니다. 전체 결과와 실패한 후보를 함께 공개했으며, SDK와 모델은 공개됐고 컴파일러의 neutral·V4 연결은 SDK0.2.51을 고정한 검증된 main 소스에 포함돼 있습니다. 공개 바이너리 0.6.34의 SDK0.2.44 지원 범위는 아래 릴리스 설명으로 구분합니다.

Current public compiler: 0.6.34

Gooo0.6.34-dev uses source b266c0e2cf6878385b59788945861a03e33f766b, Go1.27.2 and SDK0.2.44. It connects the explicit V3 artifact to source input inspection, body codegen, native construction and saved replay. The V2 route remains available. Omitting a model gives deterministic construction.

The original accepted-source native run checks the committed cutoff67/divide4/add13 fixture on Linux amd64, macOS amd64/arm64 and Windows amd64. Each platform uses a fresh zero-weight V3 artifact: inspection retains528 cells/48 relationship features with zero model calls; construction makes one initial prediction, passes caller1/1 and native8/8, then deletes the copied model file and passes saved8/8 with zero new predictions and identical generated Go. Four-platform repetition keeps eight behavioral inputs as the denominator. These observations establish the release adapter boundary; the fitted model retains the separate64-document study above.

The accepted-source CI and publication run succeeded. Nine public asset identities, eight checksums, seven manifest payloads, the annotated source tag and final PUBLISHED / EXACT receipt were verified. Six needed files, including the actual macOS arm64 archive, were downloaded and their bytes checked; that archive's binary was installed with clean source identity, Go1.27.2 and SDK0.2.44. The other three platform archive identities were checked against their API/checksum records; their bytes were not downloaded in this installation observation. Original fitted studies were not repeated.

The SDK0.2.44 release provides Go source and the V3 inspection/search example. Its installed inspection preserves source/requirement identity and makes zero predictions, candidate executions and training updates. The SDK's authored JSON fixture and the compiler's source-bound native receipt have separate scopes.

공개0.6.34에서 소스의 조건·반환값 관계를 읽는 V3 경로까지 사용할 수 있습니다. 모델은 먼저 확인할 스위치 조합을 제안하고, Gooo는 정해 둔 예시를 검사하며 남은 조합을 이어서 확인합니다. 첫 선택과 검사 후 충족률을 각각 기록합니다. 이번 새 학습에서는 V3의 첫 선택이 더 낮았으므로 선택 기능으로 유지합니다. 모델 없이도 같은 소스의 유한 조립을 결정론적으로 진행할 수 있습니다.

Committed V3 source and usage · SDK V3 guide · Read-only breakdown of the original64 evaluation rows.

Earlier public compiler: 0.6.33

Gooo0.6.33-dev uses source 44118d5fa5130912493862d389c28dec67f8e034, Go1.27.2 and SDK0.2.42. The explicit V2 artifact connects to source input inspection, body codegen and native construction. Source-owned variable assignments, comparison order, return placement, Integer division, output examples and Boolean requirements remain visible. Omitting a model gives deterministic construction.

The original accepted-source platform run checks a fresh zero-weight V2 regression on Linux amd64, macOS amd64/arm64 and Windows amd64: one initial prediction, caller1/1, native8/8, then saved8/8 after deleting the model file with zero new predictions. It also checks exact source, input arrays, candidate histories, generated program and large Integer values. Four-platform repetition leaves the behavioral input denominator unchanged.

The accepted-source CI and publication run succeeded. Nine public assets, eight checksum entries, seven manifest payloads, the annotated source tag and final publication receipt were verified. The actual public macOS arm64 archive was checked and installed. These release observations are separate from the original fitted-model study and prototype producer below.

SDK0.2.43 adds the Go example's explicit V2 inspection and search route. Inspection preserves all requirements and unsupported reasons, emits empty lists as arrays and makes zero predictions/candidate executions/training updates. Search predicts once when a compatible model is supplied; later steps continue the finite queue. The installed public example was inspected with three output requirements and one Boolean requirement. Its authored JSON fixture has no compiler-produced source-binding receipt. The original model asset remains in SDK0.2.42.

한국어 설치와 분모 · Compiler source guide · SDK source guide.

A new task through the public 0.6.33 compiler

The budget-route protocol was published before using the fixed V2 weights. Gooo constructs a function with source-owned assignments: divide by five below 41, otherwise add nine. The model chooses comparison order and branch placement; Gooo checks the declared cases.

Route	Model calls	Inner candidate checks	Selected outputs / conditions	Separate native inputs
Fixed V2 model	1	1	6/6 + 3/3	8/8
Deterministic	0	4	6/6 + 3/3	8/8

Both routes produced identical Go. Saved replay passed the same eight inputs after removing the task's model-file copy, with zero new predictions. The one original prediction recorded 0.114 ms; no extra timing or CPU/RSS collection was performed. This is one operational integration task with the public binary, not a measured speed improvement or general accuracy estimate. Training overlap is unmeasured, and the original fitting study remains unchanged. Original records, source identities and denominators.

Earlier public compiler: 0.6.32

Gooo 0.6.32-dev uses source 83928fa4538245abe33b08549da47f8cbdc50ed2, Go 1.27.2 and SDK 0.2.41. The Gooo string package implements substring search, non-overlapping counts and Unicode rune counts. A single-condition package keeps its loop and returns explicit while Gooo fills one allowed predicate.

The accepted-source platform run passed the twenty string queries and ten byte-condition queries with exact saved replay on four platforms, with zero model calls. The ten byte queries reuse six selection and four held-out source inputs. Platform repetition leaves those behavioral denominators unchanged. The publication run published nine assets; source, API/checksum/manifest digests and the final receipt were verified, and the actual public macOS arm64 binary was installed.

An independent new retry-rule observation uses the existing source-relative weights once. The first proposal matched outputs 0/6 and Boolean conditions 3/3; finite checking selected a body matching 6/6 and 3/3. Later native evaluation and saved replay each matched 8/8, including a large Integer. The one prediction took about 0.163 ms, with 76,136 resident tensor bytes; whole-process memory and model-only CPU utilization were unmeasured. It is one local test observation with producer UNBOUND_LOCAL_SOURCE, whose viewing records retain that limitation. Existing weights and original studies remain unchanged.

한국어 설치와 확인 범위 · Source guide.

Earlier compiler 0.6.31 bounded Text operations

Gooo 0.6.31-dev uses source c56007f5881296cb3181ff056c50a4ae917a9850, Go 1.27.2 and SDK 0.2.41. It adds counted loops and byte access for valid UTF-8 Text up to 1,024 bytes. A Gooo search library and importing app find a byte and return its original byte offset. Indentation and line breaks around computes bodies are accepted, while literal string spaces retain their values.

The accepted-source native checks passed the ten committed cases and saved replay on Linux amd64, macOS amd64/arm64 and Windows amd64, with zero model calls. These are ten independent cases repeated across four platforms. The interpreter compares 1,290 authored combinations with Go strings.IndexByte. The public macOS arm64 binary was checksum-checked and installed.

The existing model files, original fits and first-choice observations retain their identities. The SDK remains 0.2.41. This compiler update expands source-authored computation and preserves the preceding model adapters and deterministic ordering.

한국어 설치와 바이트 검색 · Original publication run.

Earlier compiler 0.6.30 construction features

Gooo 0.6.30-dev uses source d75cbb23db560c334301035a7243eaea167aad53, Go 1.27.2 and SDK 0.2.41. It extends body fill to source-declared pure helpers, continues after a failed candidate within the declared budget, and preserves the helper-dependent candidate pool. Preflight and candidate evaluation keep their actual helper arguments, including the prefix reached before a failure.

The model still suggests the order of finite source choices. Gooo checks the supplied cases and saves the chosen program for replay; omitting the model uses the declared deterministic order. Model weights and the original fitting and first-choice measurements below retain their original identities.

Two release profiles each passed 3/3 native output cases and saved replay on Linux amd64, macOS amd64/arm64 and Windows amd64, with zero model calls. The helper-fill profile retains two overlapping inputs and one unknown input; the fixed-pool search profile retains three unknown inputs. Those are finite example and platform checks, separate from the original model studies below. The public macOS arm64 file was checksum-checked and installed.

Installation and construction guide · 한국어 설치와 확인 범위 · Original publication run.

Earlier 0.6.29 installation observation

Compiler 0.6.29-dev ships the source-relative adapter and actual construction-input history. Its accepted source is 90ff2bb5aeffc2ac553496b646d14db1e8d33fdb; the release uses Go 1.27.2 and SDK 0.2.41. The actual macOS ARM64 public executable was downloaded and installed. It loaded the unchanged relation artifact and exported the prepared input arrays with zero predictions or candidate executions. A separate deterministic installation check retained the failed first candidate and its actual helper argument: four evaluation rows were three unique root inputs, one duplicate, two overlapping inputs and one disjoint passing case. Six saved-report reads also matched their prepared baselines. These are installation checks, separate from the original model-quality studies. Release evidence and scope.

Development observation: ranked helper and caller fill

A new synthetic example connects the unchanged source-relative model to Choose, then lets Gooo fill expressions in a caller that uses the assembled helper. One prediction ranked the first body; it matched 0/4 declared output cases. The next candidate matched 4/4. The caller fill used deterministic scoring. Native evaluation and saved replay each passed 3/3 supplied rows, while construction-input separation remained UNKNOWN. The single ranking reported 93,083 ns and 76,136 resident tensor bytes. These are separate from whole-command cost.

This observation uses development producer deb93c0a, ahead of public compiler 0.6.29. It demonstrates the connection and retains the weak initial proposal. The original fits and studies are unchanged; a matched deterministic comparison was not run for this new fixture. The linked folder contains source, cases, the prior protocol and the source-bound observation.

Original canonical artifacts

File	Purpose	Bytes
result/model-mean.json	Mean pooling weights	223,116
result/model-extreme.json	Extreme pooling weights	223,210
result/model-info-*.json	Artifact SHA256, fingerprint, fit cost and loss	Small JSON
protocol.txt, corpus.jsonl.gz	Frozen plan and all 256 authored documents	Compressed corpus
result/sources.jsonl.gz	Sources, model inputs, all candidate bodies and recorded checks	Lossless records
result/searches.jsonl.gz	All 768 construction sessions and attempts	Lossless records
result/training.json.gz, result/history-*.json.gz	Training inputs and every retained epoch loss	Lossless records
result/report.json.gz, result/audit.json	Summaries, improved/regressed IDs and checks	JSON
SHA256SUMS	Checksums of this publication's payload	Text

Model SHA256 values:

• Mean: a3e6c98dc23489f4379d44e7f62ce6bb1ba9758beaad50b88fc8a445b5978f50
• Extreme: c341e61830cda3bd4181bc3ebea15bd829b247cf39aa05908d6c570eab020680

The public study source and original records are the authoritative producer. Its protocol and producer were public at 706c590b before either fit or prediction. The protocol retains that original future-tense wording. Both fits and all sessions have since completed once.

Inputs for the original canonical pair

The artifact schema is gooo/canonical-interaction-requirement-contract/v1. The source feature version is canonical_branch_intent_ordered_expressions_v1. Each choice receives 528 FP32 source features, plus separate streams of 32-value output-case and condition-case rows. Korean/English intent descriptions contribute features alongside the source and cases.

Supported pure expressions are read through the compiler's canonical source adapter. A direct return and its equivalent variable assignment can produce the same model input. Reserved source channels 192:384 must remain zero. Use the adapter and the matching decoder; old source feature arrays have a different ABI.

Mean pooling averages learned case activations. Extreme pooling keeps the largest absolute activation in each channel. The two training runs start with the same seed and update recipe, and their weights diverge. The comparison therefore covers two complete training recipes.

Measured first choices and final completion

These are 256 related synthetic documents from three known arithmetic templates. Training uses 64 bound/distance documents. Related evaluation uses 128 variants with new constants and direct-return/assignment forms. Another 64 use a conditional addition/multiplication family excluded from both fits. Known templates and Korean/English descriptions are reused.

Population	Fixed order	Mean	Extreme
Training: first body meets all checks	16/64	14/64	29/64
Related evaluation: first body meets all checks	32/128 (25%)	32/128 (25%)	36/128 (28.125%)
Excluded family: first body meets all checks	16/64	16/64	16/64
Final body meets all checks, at most four candidates	256/256	256/256	256/256
Total candidate checks across 256 sessions	640	635	607

Each document has eight authored output cases and three intermediate conditions. Sixteen separate output probes and three condition probes were fixed before execution. The threshold condition intentionally overlaps; output-probe inputs are separate from authored output inputs. Authored and probe completeness agree in this corpus. Evaluation and probe outcomes were excluded from fitting.

Extreme improves 14 related-evaluation documents and regresses on 10 against mean. In the excluded family it improves 14 and regresses on 14. All IDs, failed choices and attempts are retained. Canonical inputs, logits and proposals agree across 96 direct-return/assignment pairs for each model.

These percentages describe the rows above. They do not establish correctness for arbitrary programs or a general Korean/English understanding rate. Completing the finite search and choosing a correct first body are separate measurements.

Local compute cost

Both models use seed 37, 2,000 epochs, learning rate 0.3 and L2 0.0001, on CPU.

Original observation	Mean	Extreme
One fit	15.256s	15.045s
First prediction median, 256 observations	95.938 microseconds	95.584 microseconds
First prediction p95, nearest rank	102.166 microseconds	104.125 microseconds
Last retained pre-update loss	1.386181	1.391441

The whole original process took 31.29s wall / 30.98s user+system CPU, with 77.031MiB maximum RSS, on Apple M4 / 10 logical CPUs / 16GiB RAM. CPU divided by wall time is about 99% of one core on average. Instantaneous machine-wide CPU utilization increase was not measured. RSS covers both fits and all records.

Construction totals were 26.149ms fixed / 62.495ms mean / 62.948ms extreme. These intervals include session setup and candidate checks, and exclude source lowering, candidate collection, fitting and separate final probes. Each model was called once before each session's first candidate (256 calls per model); later advances made zero predictions. For these cheap checks, fixed ordering had the lowest total construction cost. Shared-host timings and a fixed execution order support descriptive observations only.

Use canonical artifacts from Go or Gooo

Use the custom Go runtime in gooo-decision-runtime v0.2.40-experimental. The matching loader is:

raw, err := os.ReadFile("result/model-extreme.json")
if err != nil {
    return err
}
model, err := contractdecision.DecodeCanonicalInteractionRequirementConditioned(raw)
if err != nil {
    return err
}
// model.PredictInto / PredictChoicesInto accept canonical source features,
// output cases, condition cases, and caller-owned workspaces.

Import github.com/kimjooyoon/gooo-decision-runtime/contractdecision. The loader checks artifact shape and ABI. Decode alone does not predict or train. Arrays and caller-owned workspaces keep runtime storage explicit.

The public compiler0.6.28 development prerelease includes the canonical-model adapter and SDK0.2.40. Its source is ee24a413. Earlier compiler0.6.27 does not support this artifact schema. Download the weight file and follow the matching compiler guide, substituting result/model-extreme.json for its model filename. Using that release's source examples and installed executable:

gooo body-context \
  --model /path/to/result/model-extreme.json --activity Choose \
  examples/body-codegen/source-interaction-assignment-cases.gooo.fixture

body-context inspects inputs without predicting or executing candidates. The same guide shows body-construct --model, fixed ordering when --model is omitted, and replay from a saved construction. Unsupported source shapes return an explanation and use deterministic search; malformed model artifacts return an error. This publication's observations are the original SDK construction study. A separate native end-to-end observation of these two weight files has not been performed. Earlier native observations used a different canonical weight file. The actual 0.6.28 macOS ARM64 release executable loaded the Hub extreme model in body-context, with zero model predictions and zero candidate executions. That checks input compatibility; the original SDK study supplies the behavioral records. Native construction requires Go1.27.2. Reading a full saved construction with gooo body-construct --report result.json needs neither Go nor model files.

Limits and next question

First-choice selection remains weak, including on training data. Only one seed and one update recipe were observed. Raw scores have no demonstrated calibration. The study covers a small source-declared choice space and synthetic requirements; completion outside those checks remains unknown. These weights use FP32; 1.58-bit quantization quality has not been measured.

The separate role-learning experiment below has now compared comparison-order and branch-layout models on a new frozen corpus. Its related first-choice result did not improve, and it is retained with the extra resource cost. The source-relative follow-up below now measures explicit condition relations at a fixed learning budget. The product question is whether a developer can express a recurring rule, inspect the failed requirements, and reuse its checked construction with less total effort. External adoption, customer savings and payment willingness remain unmeasured.

Read the existing records with the study's Go audit; it performs no new fit, prediction or candidate execution. Preserve the original observation instead of rerunning the producer as a verification step. This Hub publication copies only public synthetic sources, weights, records and documentation. Local host paths, raw environment logs, credentials and caches are excluded.

한국어 요약

Gooo에 적힌 비교식·분기 후보 중 무엇부터 검사할지 고르는 작은 자체 모델입니다. 사용자가 원하는 출력과 중간 조건을 함께 읽고, 실제 후보 조립과 검사는 Gooo가 맡습니다. 평균·극값 모델 모두 가중치는 19,034개이며 Go로 학습·실행합니다. 관련 평가의 첫 선택 성공은 32/128·36/128이었습니다. 고정 순서도 네 후보 안에서 같은 최종 검사를 모두 통과했고, 이 작은 계산에서는 전체 조립 시간이 가장 짧았습니다. 현재 성적과 실패를 그대로 공개했습니다. 후속 역할 분리 실험에서는 관련 평가가 30/128로 같았고 모델 호출과 용량은 두 배가 됐습니다. 원본 결과와 비용을 아래에 남겼습니다. 공개 컴파일러 0.6.28에서 이 모델 형식을 읽을 수 있으며, 모델을 쓰지 않는 결정론적 실행도 계속 제공합니다.

Follow-up: independent comparison and branch models

A separate role-learning experiment was completed once after its protocol and producer were frozen publicly. The complete Go implementation and records are public in SDK PR63; its exact-result CI and merge status are tracked there. The two pooling models above keep their original weights and interpretation.

The follow-up compares a fresh joint mean-pooling model with two independently fitted mean-pooling models, each responsible for one choice. It reuses known synthetic templates with new constants and a separately frozen corpus. The joint policy deploys 19,034 parameters / 76,136 FP32 weight bytes and makes one call per construction. The split policy deploys 38,068 / 152,272 and makes two calls.

Follow-up result	Fixed order	Joint	Split
Related evaluation: first accepted body	32/128	30/128	30/128
Excluded affine family: first accepted body	16/64	16/64	18/64
Final declared checks and separate probes	256/256	256/256	256/256
All candidate checks	640	637	635
All model calls	0	256	512
Total construction search	28.177 ms	64.160 ms	98.401 ms

On 64 related pairs with identical source/output examples and changed intermediate conditions, both policies change their scores but neither changes either initial choice bit. The split policy improves eight related documents and regresses eight. It is not adopted as a default. Final completion comes from inspecting the four permitted bodies against finite requirements; it is not general correctness.

The original process took 50.62 s wall time and 54.05 MiB maximum RSS on Apple M4. Median prediction per component was 105.063 µs (joint), 103.792 µs (comparison) and 102.834 µs (branches). The split policy needs both component calls. Whole-process CPU time was 49.73 s; instantaneous machine utilization increase was not measured. Its explicit four-mask frontier differs from the earlier study's SDK frontier, so timings and candidate counts are not a controlled cross-study comparison.

research/role-learning-20261011/result/ retains all three original weight files, losses, training rows, source/candidate records, 768 constructions, 3,448 ordered events, cost and a read-only audit. These are ordinary component model files, but split-policy.json is research metadata with no public native split-policy loader. The Go auditor in the linked SDK source inspects retained records without new training, predictions or candidate execution. Existing defaults remain unchanged.

Follow-up: source-relative condition inputs

The source-relative study adds an explicit relationship between the source comparison, each input and the requested Boolean result. It holds the model size and fitting budget fixed and compares fresh baseline/relative models with fixed ordering and a small rule. Protocol and producer were public before execution. SDK PR66 carries the original records and the corrected read-only audit.

Observation	Fixed	Relation rule	Baseline model	Relative model
Related first complete body	32/128	64/128	32/128	64/128
Excluded-family first complete body	16/64	32/64	14/64	32/64
All288 authored final completion	272/288	272/288	272/288	272/288
Candidate checks	728	472	726	542
Total construction time	36.214ms	25.589ms	98.630ms	84.688ms

Relative improves46 related documents and regresses14 against baseline. On64 condition-only pairs it changes both choice bits64/64 times, compared with0/64 comparison flips and2/64 branch flips for baseline. The deterministic rule reaches the same first-body count with fewer candidate checks and lower observed total cost. Current defaults remain unchanged.

Sixteen missing-condition documents each allow two authored-complete bodies; separate condition probes expose ambiguity. Sixteen inconsistent documents remain PARTIAL, each satisfying10/11 authored observations. Their separate probe success does not erase that failure. Full denominators, losses and partial bodies are retained in the linked report.

Each model has19,034 FP32 parameters /76,136 raw weight bytes. Prediction medians are106.625µs baseline and107.292µs relative,288 calls each. Both fresh CPU fits, collection and1,152 constructions took32.57s wall with63.594MiB maximum RSS on Apple M4 /10 logical CPUs /16GiB RAM. User+system CPU totals32.27s, about99.08% of one core on average; instantaneous host utilization increase was not sampled. Preparation cost is included in construction totals. The run is descriptive, using one seed and fixed policy order.

The relative artifact has schema gooo/source-relative-condition-research-model/v1. Go SDK0.2.41-experimental provides DecodeSourceRelativeRequirementConditioned and an ordinary finite construction session for these exact weights. Go usage and input inspection. It predicts once before candidate execution and retains partial results. The SDK's lazy frontier differs from the original four-mask study, so the original timings and candidate totals do not measure this new route. Public compiler0.6.29 loads this relative artifact. The older 0.6.28 supports the canonical model connection. Existing pooling/role weights remain byte-for-byte unchanged. The initial audit rejected55 rule scoring intervals rounded to0ns; the audit was corrected to accept the clock's resolution while keeping all1,632 recorded bucket checks. No original fit, prediction or candidate execution was repeated. All original files, the audit correction, resource cost and checksums are included under research/source-relative-learning-20261011/.

조건 관계를 명시한 새 입력에서 관련 사례 첫 선택이32/128에서64/128로 늘었습니다. 간단한 규칙도 같은 수를 맞혔고 비용은 더 적었습니다. 조건이 비어 있거나 서로 맞지 않을 때는 여러 가능한 답과10/11 부분 결과를 그대로 남깁니다. 소형 모델이 어디서 도움이 되는지와 규칙으로 충분한 부분을 함께 확인하는 실험입니다.

Native compiler observation with the relation model

The native observation uses one new batch function with variable assignments, a comparison and two arithmetic branches. Public frozen compiler source24281f37 loads the unchanged relation weights through SDK0.2.41. PR1455 tracks this adapter. At the time of that observation the public compiler was0.6.28; the original records remain bound to24281f37 after the0.6.29 release.

Fixed order and model order both check masks0,1. The first body meets1/4 output requirements and3/3 Boolean requirements; the second meets4/4 and3/3. Both pass the outer1-case check and later native4-case check. Saved replay passes the same four later cases with zero new model calls. These repeated cases are dependent; runtime helper-input separation remains UNKNOWN in the full records.

One model prediction took106.833µs, constructor setup7.822ms and retained tensors 76,136bytes. Whole-command costs were0.81s/82.375MiB fixed and0.64s/81.578MiB model, with normal build caching, fixed order and shared hardware. These observations support no causal speedup claim. The original context arrays, failed first body, Go source, native results, resource data and read-only audit are public in the linked folder. The earlier study, all weights and default policy are unchanged.

Compiler 0.6.29: follow actual construction inputs

The 0.6.29 compiler source now carries the original construction context into native observation. Each new caller-guided candidate records the actual arguments received by constructed helpers. Later evaluation compares its arguments with local output/condition cases, holdouts, recorded probes and every consumed caller attempt, including failed candidates. The model weights and ranking policy stay unchanged.

A caller can receive 3 and -3 while passing 9 to the same helper. That helper input has already been used. Likewise, an input seen only in a failed candidate belongs to construction history. Reports count distinct caller inputs, overlapping constructed inputs, disjoint cases and unknown cases. Duplicate rows share one input count and all their supplied expectations must agree with execution. See the input-history contract and report guide.

This is available in the public 0.6.29 experimental release. Regression tests cover changed caller inputs, failed candidate routes, repeated and nested calls, condition-only inputs, exact int64 values and conflicting duplicate expectations. Saved replay checks the recorded argument history with zero new inference. Observation uses the existing native runs. The original native study above retains its UNKNOWN; its executions and weights have not been repeated. Unrecorded calls made while scoring local candidates remain a measurement limit, and model-training exposure remains unknown. These finite counts describe the recorded construction boundary; first-choice quality and compute-cost results remain the original measurements above.

호출자의 입력이 달라도 내부 함수가 같은 값을 받으면 이미 사용한 입력으로 셉니다. 실패한 코드 후보가 받았던 값도 이력에 포함합니다. 공개0.6.29는 이 연결을 기록하고, 과거 실험에서 관측하지 못한 값은 그대로 미측정으로 남깁니다. 모델 가중치는 같으며, 실제 조립 과정을 더 정확하게 읽기 위한 변경입니다.

New return-layout model study (2026-10-12)

A new Go-only fit and its complete observations use 100 fresh Gooo documents in 25 contract groups. The pre-fit source and protocol were public before training. One fit received 60 training documents; grouped validation20 and heldout20 stayed outside the fit. The held-out first complete body rate was12/20, compared with fixed-order5/20. Declared Boolean conditions matched60/60; return placement remains the main observed weakness. Checked completion over retained candidate observations was20/20, separate from first selection. The held-out set represents five independent contract groups.

The new V2 model has19,034 FP32 parameters (76,136 tensor bytes). The fit took 0.736s, and100 single predictions had median0.094ms. Process CPU/wall during the fit was0.988; whole trainer peak RSS was18.4MB. A new prototype compiler task made one0.149ms model call before candidate execution and passed native8/8 input expectations. Saved construction reused the same program with zero new model calls. Raw split results, failed choices, weights, process observations, source patches and path-redacted native views are in the linked folder.

이번 실험에서는 조건식 방향은 모두 맞혔지만 반환 계산을 어느 가지에 놓을지는 미사용 평가20개 중8개에서 틀렸습니다. 잘못 놓인 가지를 사례 검사로 찾고, 남은 후보를 확인하는 과정까지 함께 기록했습니다. 학습은 Go와 CPU로 수행했으며, 원래 V2 실행 관측은 로컬 시제품에서 수행했습니다. 이후 공개0.6.33에 V2 연결을 배포했으며, 새 릴리스 회귀와 당시 시제품의 생산자 식별값은 각각 보존합니다. GPU와1.58비트 양자화는 별도 실험으로 남아 있습니다.

Public SDK0.2.42 connection (2026-10-12)

SDK0.2.42 now publishes the explicit V2 decoder, source/requirement input encoder and one-prediction finite construction session. Its model-source-relative-v2.json asset has the same8570dd8c… SHA256 as the original result above. The Go guide explains array layout, deterministic use and source identity. Both original PR checks and the accepted-source CI passed, with earlier numerical compatibility preserved and performance collectors disabled.

Compiler PR1479 was accepted as source 2fdc206d3c1b39cbc18fadcb9e8e51f3abf3476f. It connects the published module to body-context, body-codegen and body-construct. New zero-weight regressions check stepwise construction, deterministic order, native expectations and replay after deleting the model file. Public compiler PR1480 was accepted as source 44118d5fa5130912493862d389c28dec67f8e034 and published in compiler0.6.33 with the explicit V2 native profile on all four existing platforms. The original fit, failed first choices, timings and prototype producer identity remain their original observations; SDK publication performs no additional fit.

SDK를 일반 Go 의존성으로 설치해 V2 입력과 모델을 읽을 수 있게 됐습니다. 컴파일러 연결은 PR1479로 병합됐으며 PR1480의 소스를 공개0.6.33으로 배포했습니다. SDK0.2.43은 같은 V2 API에 Go 명령 예제를 연결합니다. 모델이 정한 첫 경로와 Gooo가 사례를 검사한 뒤의 완전성은 따로 보고하며, 원래 실험의 실패와 측정값도 그대로 남깁니다.

Per-choice diagnosis of the original V4 comparison

A retained-data reader now separates the original two choices without fitting or prediction. On the same 384 held-out rows, comparison-order correctness was 216/384 for neutral versus 164/384 for V4; branch-placement correctness was 168/384 versus 192/384. Each bit has balanced expected labels. The saved four-candidate rankings are nearly uniform, with mean largest probabilities of 0.270 and 0.271. These scores describe the candidate pool and are not calibrated program-correctness probabilities.

The report retains the same24 contracts/four held families and original inputs. It suggests testing typed decision heads using Gooo's choice dependencies in a fresh preregistered study; no new trained model or causal finding is claimed.