feat: release Tiny Codemode CNN with evaluation and inference package

.python-version

@@ -0,0 +1 @@
+3.12

EVALUATION.md

@@ -0,0 +1,29 @@
+# Checkpoint-matched evaluation
+
+CNN checkpoint SHA-256: `a6b944d56580b64dfb526da5b3888a137b6783ea29d8a719a0fea3f4e3f7ee76`.
+
+These are curated historical results, not a new evaluation or a claim about a later attention model. Exact counts were recovered from the checkpoint-bound historical record. Full numeric values, source-record hashes and dataset-file hashes are in [evaluation.json](evaluation.json). Original records and full banks are not included in this inference release.
+
+| Bank | Exact supported plans | Supported rejected | Negative false accepts | Correct full decisions |
+| --- | ---: | ---: | ---: | ---: |
+| Fresh, same training grammar | 622/625 | 3/625 | 5/575 | 1192/1200 |
+| Schema + reserved phrasing transfer | 497/612 | 115/612 | 8/588 | 1077/1200 |
+| AI-authored transformed bank | 40/50 | 10/50 | 13/70 | 97/120 |
+
+## Definitions
+
+- **Exact supported plans:** predicted plan equals the annotated plan; denominator is supported requests, including rejected ones.
+- **Supported rejected:** genuinely supported requests producing diagnostics.
+- **Negative false accepts:** unsupported/invalid requests producing plans; denominator is all annotated negatives.
+- **Correct full decisions:** exact supported plans plus correctly rejected negatives, divided by all requests. This is not acceptance rate.
+- Supported fake-tool execution counts equal exact-plan counts on these three banks. Fake execution is not real-workflow reliability or isolation.
+
+## Interpretation and comparison
+
+The authored bank has 24 bases with five variants each, including 10 supported bases. The 40/50 exact supported cases correspond to 8/10 supported bases; two core phrasings failed in every variant. The 13/70 negative false accepts include mixed ordering, unfamiliar prohibition, unknown fields and loop/sorting contexts. Correlated variants are not independent samples.
+
+The historical phrase-rule comparator scored 503/612 supported transfer plans and 41/50 authored supported plans, slightly above this CNN's 497/612 and 40/50. There is no demonstrated general neural advantage over strong rules or a main-model baseline.
+
+Training, validation and evaluation inputs were synthetic/AI-authored, not human task traffic. Exact normalized-input deduplication does not establish semantic independence or representative English coverage. Synthetic labels are not independently established human intent. The banks are now exposed; do not tune on them and call them new held-out tests.
+
+No production-safety, broad-English, demographic-fairness or worst-case latency claim is made. Publication preparation checks packaging/API compatibility, not new model capability.

LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2026 Tiny Codemode contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -0,0 +1,154 @@
+---
+license: mit
+language:
+  - en
+library_name: numpy
+tags:
+  - semantic-parsing
+  - tool-calling
+  - numpy
+  - cpu
+  - synthetic-data
+  - research
+---
+
+# Tiny Codemode CNN
+
+**A 67,485-parameter research model for bounded English tool requests.** It maps
+an instruction and an explicit tool catalog to a typed plan, then deterministically
+compiles the plan into JavaScript. It does **not** execute tools and is not an
+agent, general language model or reliable authorization system.
+
+This release is the original CNN checkpoint, **not** a later attention candidate.
+Unsupported instructions can be incorrectly accepted. Read the limitations before
+using any generated plan.
+
+## Quickstart
+
+Download this model repository, preserving its directory structure. With Python
+3.10+ and [uv](https://docs.astral.sh/uv/getting-started/installation/) 0.9+ installed,
+run from the downloaded directory:
+
+```sh
+uv sync --locked --no-dev
+uv run --locked --no-dev tiny-codemode --help
+uv run --locked --no-dev tiny-codemode --js < examples/request.jsonl
+```
+
+These commands install NumPy-only inference, not Torch. `--js` returns generated
+JavaScript as text; it does not execute it. Input is JSONL: one complete JSON
+object per line. Output is a plan (and optional JavaScript), or a `diagnostic`.
+`python -m pip install .` is also supported but is not a locked installation.
+
+Python API, after installation:
+
+```python
+from core import Diagnostic, compile_js
+from model import Model
+
+request = {
+    "instruction": 'Call list_users with team="blue"; return the last result.',
+    "tools": [
+        {
+            "name": "list_users",
+            "arguments": {"team": "string"},
+            "required": ["team"],
+            "returns": {"kind": "array", "properties": ["id", "name"]},
+        }
+    ],
+}
+
+try:
+    plan = Model().predict(request)
+    print(plan)
+    print(compile_js(plan, request["tools"]))
+except Diagnostic as error:
+    print({"diagnostic": str(error)})
+```
+
+The expected plan for this example is:
+
+```json
+{
+  "mode": "single",
+  "calls": [{ "tool": "list_users", "args": { "team": "blue" } }],
+  "output": { "kind": "last" }
+}
+```
+
+This is custom NumPy inference, not a Transformers/`AutoModel` checkpoint. No
+`trust_remote_code` flag, hosted inference widget or generic text-generation API
+is required or promised. The bundled Python code runs locally; review it before
+use. The NPZ contains numeric arrays and is loaded without pickle.
+
+## Scope and model details
+
+The [contract](SPEC.md) allows 1–8 catalog tools, 1–3 calls, up to four primitive
+arguments per tool and 128 input tokens. It supports single, sequential or
+parallel schedules and all/last outputs. Single-array projection and prefix limits
+are bounded. Dependencies, mixed schedule groups, loops, branching, nested
+arguments and arbitrary JavaScript requests are outside the contract.
+
+Architecture: 1,024 fixed hash buckets, a learned 32-channel embedding, 12
+mechanical schema/primitive features, three width-5 48-channel ReLU convolutions,
+and learned token-role, schedule, output and rejection heads. Catalog/literal
+identities are normalized for the model; exact names and values are retained by
+the deterministic frontend/compiler. No pretrained model was used.
+
+- Parameters: **67,485**, float32 (269,940 raw parameter bytes).
+- Weight file: `tiny_codemode_weights/model.npz` (253,781 bytes compressed).
+- SHA-256: `a6b944d56580b64dfb526da5b3888a137b6783ea29d8a719a0fea3f4e3f7ee76`.
+- Inference: Python + NumPy; CPU only is sufficient.
+- License: [MIT](LICENSE), supplied with the code and checkpoint.
+
+`SHA256SUMS` covers every exported file except itself. `release.json` identifies
+the checkpoint and scope. The manifest checks integrity, not publisher authenticity.
+
+## Training and data
+
+The selected CNN was randomly initialized and CPU-trained on **26,000 synthetic
+requests**, with **1,600 validation requests**. Plans and token-role spans were
+AI-authored/generated before rendering instructions; no real-user traffic is
+represented. Synthetic schemas and phrasing are not a representative sample of
+English tool use. There is no external pretrained base model or Hub dataset ID.
+The full training corpus and experiment infrastructure are not part of this
+inference-only upload; it is not a standalone training-reproduction package.
+
+Seed 715, Adam learning rate 0.002, batch size 96, four CPU threads, 55 epochs.
+The earliest best validation full-decision checkpoint was selected at epoch 12
+(99.0625% validation full-decision accuracy). Training used 25% neutral-wrapper
+hash-bucket perturbation; no runtime wrapper stripping is performed. Historical
+training took 137.60 seconds for the selected run on its recorded CPU environment;
+this is not a hardware-independent speed guarantee.
+
+## Evaluation
+
+See [EVALUATION.md](EVALUATION.md) for counts, denominators, definitions and
+limitations, and [evaluation.json](evaluation.json) for the curated numeric summary.
+These are **historical results bound to the exact shipped checkpoint**, not new
+benchmarks performed while packaging. They include false accepts and rejected
+supported requests, not only successful examples.
+
+The authored bank scored 40/50 supported plans, with **13/70 negative requests
+falsely accepted**. Its 120 requests are transformations of only 24 AI-authored
+semantic bases—not 120 independent users. All reported banks are now exposed;
+they must not be relabeled as future held-out evaluation.
+
+## Intended use, risks and limitations
+
+Use for research, education and constrained offline demonstrations. Do not use as
+an autonomous tool executor, policy gate, authorization mechanism or production
+natural-language parser. Structural validity does not establish that a plan
+matches the user's intent or permission.
+
+Known failures include unfamiliar prohibitions, mixed ordering, unknown projected
+fields, loop/sorting contexts and valid unseen phrasings. The model can reject
+valid requests or silently drop unsupported intent. Neither a successful plan nor
+a diagnostic should be treated as a security guarantee. Independent authorization,
+semantic review and appropriate execution isolation are required before real
+side effects. Mock execution tests are not a security sandbox.
+
+No broad-English, multilingual, human-population, demographic fairness, worst-case
+latency or production-safety evaluation has been established. Dataset diversity
+and labels are synthetic and limited. Later experimental architectures were not
+promoted into this release, and their scores must not be attributed to this CNN.

SHA256SUMS

@@ -0,0 +1,17 @@
+7b55f8e67b5623c4bef3fa691288da9437d79d3aba156de48d481db32ac7d16d  .python-version
+a5e56a98b004c5d564e1d18b46d0ca91977386a7bffbdd808688edfc7d25202d  EVALUATION.md
+0846a890128821c8835d76e2c90fb5fc90891e2b5b6a3067e1674d0059ab1efb  LICENSE
+d6a1e7d27ac4a02960c1716e87059a6090b7d992bc8a518c42b835438ee400a5  README.md
+e18e57a959500a63f4dbdce67a2b006881b6f54d0842ff37e175e7b305ecb4a4  SPEC.md
+9a79e7dc4dc2dc38bb94a99b957ea86bbfb66ee97bf559c4ecbce93409fd0daa  core.py
+3757beb678dc7b13427720b0f5c1ec29119dbb354e954680e3fae4132606be5c  evaluation.json
+f99ff96f8a14e926a3d6a042177b4d62f9a1d0e5dd3299ecc56a605c07ea93f7  examples/request.json
+2559df6c3300eeba1a6c3fbef97cb8dafd661bb279f6055d73d0bc357e56c454  examples/request.jsonl
+6e1a4b175a56db39edb27d9f76691f7ed719ebaef91ce4a14f2d297b373cd626  infer.py
+f6d628f718b21a4f94f714a50344cfb2480f693bb7b83954f2b80d94e3d7cc63  model.py
+e48d12a082c70b95db3bc57f8a1ef631fe6b40ab7c1a379df87bbec2e84ff117  pyproject.toml
+5d8a3d32d303e76c785d42839a510c65a42d56cb7900be37d1868da9ba872a9b  release.json
+25bb4454836c602444ee25ed47feb16003eecc4778cbf1ca6417a4a6694151fe  requirements.txt
+7f1037bf26b31d7c50d20a263090d3664ca386d47c5a293f5841c1f886205710  tiny_codemode_weights/__init__.py
+a6b944d56580b64dfb526da5b3888a137b6783ea29d8a719a0fea3f4e3f7ee76  tiny_codemode_weights/model.npz
+5a960459d51087de9f31430c73136fbdd53b687e9b0f4132aca23c68c0adedb0  uv.lock

SPEC.md

@@ -0,0 +1,76 @@
+# Inference contract
+
+This describes supported structures, not a guarantee that English intent will be
+recognized correctly. Inputs outside these structures may be falsely accepted.
+
+## Input
+
+Each JSONL record is an object with:
+
+- `instruction`: an English string explicitly naming catalog tools and arguments.
+- `tools`: 1–8 catalog entries, each containing exactly `name`, `arguments`,
+  `required`, and `returns`.
+
+A catalog entry looks like:
+
+```json
+{
+  "name": "list_users",
+  "arguments": { "team": "string" },
+  "required": ["team"],
+  "returns": { "kind": "array", "properties": ["id", "name"] }
+}
+```
+
+Tool names must be JavaScript identifiers. Argument schemas contain at most four
+properties of type `string`, `number` or `boolean`; nested objects, arrays and
+null arguments are unsupported. Required argument names must exist in the schema.
+Return kinds are `text`, `object` or `array`, with declared property names where
+projection is needed. Quoted values use JSON string syntax and remain opaque.
+Numbers must be finite and compatible with exact JavaScript numeric handling.
+
+The frontend diagnoses inputs over 128 tokens rather than truncating them.
+The model does not discover tools or interpret free-form tool descriptions.
+
+## Plan
+
+A successful response contains a `plan`, for example:
+
+```json
+{
+  "mode": "single",
+  "calls": [{ "tool": "list_users", "args": { "team": "blue" } }],
+  "output": { "kind": "last" }
+}
+```
+
+Supported schedules are one call, or 2–3 independent calls sequentially or in
+parallel. Repeated tools are allowed. Sequential calls do not pass earlier
+results into later arguments. Dependencies, mixed serial/parallel groups,
+conditions, retries, loops and arbitrary code generation are unsupported.
+
+`output.kind` is `all` or `last`. For one array-returning call only, optional
+`fields` projects 1–3 declared properties and optional `limit` takes the first
+0–100 rows. Projection precedes the limit. Filtering, sorting and aggregation
+are unsupported.
+
+Rejected requests return a `diagnostic` string instead of a plan. Diagnostics are
+not evidence of reliable semantic rejection. Valid plans can be semantically
+wrong even when schema checks pass.
+
+## Compilation, not execution
+
+The CLI's `--js` option also returns a `js` string: an async-function body intended
+for a host exposing `tools[name](args)`, top-level `await` and `return`. Nothing in
+the CLI invokes these tools.
+
+Generated code awaits every started call. Parallel mode uses `Promise.allSettled`;
+serial mode catches each call's failure and continues in mention order. Results
+are `{ok: true, value: ...}` or `{ok: false, error: ...}` records. `all` returns
+records in call order; `last` returns the final call's record, not the last call to
+finish. Single-array shaping reports invalid result shapes explicitly.
+
+The compiler escapes names and values mechanically and validates structural
+constraints. These properties do not grant permission, establish intended
+semantics, or provide execution isolation. Real tool use needs independently
+implemented authorization, intent review and a suitable execution environment.

core.py

@@ -0,0 +1,349 @@
+import hashlib
+import json
+import os
+import re
+
+for _key in ("OMP_NUM_THREADS", "MKL_NUM_THREADS", "OPENBLAS_NUM_THREADS"):
+    try:
+        _threads = int(os.environ.get(_key, "4"))
+    except ValueError:
+        _threads = 4
+    os.environ[_key] = str(max(1, min(4, _threads)))
+import numpy as np  # noqa: E402 -- thread limits must precede NumPy initialization
+
+ROLES = ["none", "tool", "arg", "value", "field", "limit"]
+MODES = ["single", "sequential", "parallel"]
+OUTPUTS = ["all", "last"]
+
+
+class Diagnostic(ValueError):
+    pass
+
+
+NUMBER = re.compile(r"-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?\Z")
+TOKEN = re.compile(r'"(?:\\.|[^"\\])*"|[A-Za-z_$][\w$]*|[+-]?\d[\w.+-]*|[^\s]')
+
+
+def number_ok(v):
+    import math
+
+    if type(v) is int:
+        try:
+            fv = float(v)
+        except OverflowError as error:
+            raise Diagnostic("number: JS overflow") from error
+        if not math.isfinite(fv) or int(fv) != v:
+            raise Diagnostic("number: integer not exactly JS-representable")
+    elif type(v) is float:
+        if not math.isfinite(v):
+            raise Diagnostic("number: nonfinite")
+    else:
+        raise Diagnostic("number: primitive required")
+
+
+def catalog_check(tools):
+    if not isinstance(tools, list) or not 1 <= len(tools) <= 8:
+        raise Diagnostic("catalog: expected 1-8 tools")
+    names = set()
+    for t in tools:
+        if not isinstance(t, dict) or set(t) != {
+            "name",
+            "arguments",
+            "required",
+            "returns",
+        }:
+            raise Diagnostic("catalog: tool shape")
+        name = t["name"]
+        a = t["arguments"]
+        req = t["required"]
+        ret = t["returns"]
+        if (
+            not isinstance(name, str)
+            or not re.fullmatch(r"[A-Za-z_$][A-Za-z0-9_$]*", name)
+            or name in names
+        ):
+            raise Diagnostic("catalog: unsafe/duplicate tool")
+        names.add(name)
+        if (
+            not isinstance(a, dict)
+            or len(a) > 4
+            or any(
+                not isinstance(k, str)
+                or not k
+                or v not in ("string", "number", "boolean")
+                for k, v in a.items()
+            )
+        ):
+            raise Diagnostic("catalog: primitive argument schema")
+        if (
+            not isinstance(req, list)
+            or any(not isinstance(k, str) for k in req)
+            or len(set(req)) != len(req)
+            or set(req) - set(a)
+        ):
+            raise Diagnostic("catalog: required keys")
+        if (
+            not isinstance(ret, dict)
+            or set(ret) - {"kind", "properties"}
+            or ret.get("kind") not in ("text", "object", "array")
+        ):
+            raise Diagnostic("catalog: return schema")
+        props = ret.get("properties", [])
+        if (
+            not isinstance(props, list)
+            or any(not isinstance(k, str) or not k for k in props)
+            or len(set(props)) != len(props)
+        ):
+            raise Diagnostic("catalog: properties")
+    return tools
+
+
+def frontend(item):
+    if not isinstance(item, dict) or not isinstance(item.get("instruction"), str):
+        raise Diagnostic("input: instruction string required")
+    tools = catalog_check(item.get("tools"))
+    s = item["instruction"]
+    toks = TOKEN.findall(s)
+    if not toks:
+        raise Diagnostic("input: empty instruction")
+    if len(toks) > 128:
+        raise Diagnostic("token bound")
+    names = {t["name"] for t in tools}
+    args = {a for t in tools for a in t["arguments"]}
+    fields = {a for t in tools for a in t["returns"].get("properties", [])}
+    ids = []
+    features = []
+    values = []
+    for x in toks:
+        literal = False
+        v = x
+        if x.startswith('"'):
+            try:
+                v = json.loads(x)
+                literal = True
+            except Exception as error:
+                raise Diagnostic("malformed literal") from error
+        elif x in ("true", "false"):
+            v = x == "true"
+            literal = True
+        elif x[0].isdigit() or (x[0] in "+-" and len(x) > 1 and x[1].isdigit()):
+            if not NUMBER.fullmatch(x):
+                raise Diagnostic("number: malformed JSON syntax")
+            try:
+                v = json.loads(x)
+                number_ok(v)
+            except (ValueError, OverflowError) as e:
+                raise Diagnostic(str(e)) from e
+            from decimal import Decimal
+
+            decimal = Decimal(x)
+            if v == 0 and decimal != 0:
+                raise Diagnostic("number: JS underflow")
+            if decimal == decimal.to_integral_value() and int(v) != int(decimal):
+                raise Diagnostic("number: integer not exactly JS-representable")
+            if (
+                type(v) is float
+                and v.is_integer()
+                and decimal != decimal.to_integral_value()
+            ):
+                raise Diagnostic("number: fractional part lost in JS")
+            literal = True
+        f = [
+            float(x in names and not literal),
+            float(x in args and not literal),
+            float(x in fields and not literal),
+            float(literal and isinstance(v, str)),
+            float(literal and type(v) in (int, float)),
+            float(literal and type(v) is bool),
+        ]
+        f += [
+            float(not literal and any(t["arguments"].get(x) == typ for t in tools))
+            for typ in ("string", "number", "boolean")
+        ]
+        f += [
+            float(
+                not literal
+                and any(t["name"] == x and t["returns"]["kind"] == kind for t in tools)
+            )
+            for kind in ("text", "object", "array")
+        ]
+        norm = "<schema>" if any(f[:3]) else "<literal>" if literal else x.lower()
+        ids.append(
+            int.from_bytes(hashlib.sha256(norm.encode()).digest()[:4], "little") % 1024
+        )
+        features.append(f)
+        values.append(v)
+    for i, x in enumerate(toks):
+        if x == "=" and (i + 1 >= len(toks) or not any(features[i + 1][3:6])):
+            raise Diagnostic("literal: assignment requires JSON string/number/boolean")
+    return (
+        toks,
+        np.array(ids, dtype=np.int64),
+        np.array(features, dtype=np.float32),
+        values,
+    )
+
+
+def validate(plan, tools):
+    catalog_check(tools)
+    if not isinstance(plan, dict) or set(plan) != {"mode", "calls", "output"}:
+        raise Diagnostic("plan: shape")
+    catalog = {t["name"]: t for t in tools}
+    calls = plan["calls"]
+    out = plan["output"]
+    if not isinstance(calls, list) or not 1 <= len(calls) <= 3:
+        raise Diagnostic("call bound")
+    if (
+        not isinstance(plan["mode"], str)
+        or plan["mode"] not in MODES
+        or (len(calls) == 1) != (plan["mode"] == "single")
+    ):
+        raise Diagnostic("mode mismatch")
+    if (
+        not isinstance(out, dict)
+        or set(out) - {"kind", "fields", "limit"}
+        or out.get("kind") not in OUTPUTS
+    ):
+        raise Diagnostic("output kind/shape")
+    for c in calls:
+        if (
+            not isinstance(c, dict)
+            or set(c) != {"tool", "args"}
+            or not isinstance(c["tool"], str)
+            or c["tool"] not in catalog
+        ):
+            raise Diagnostic("call: unknown tool/shape")
+        t = catalog[c["tool"]]
+        a = c["args"]
+        if (
+            not isinstance(a, dict)
+            or len(a) > 4
+            or any(not isinstance(k, str) for k in a)
+            or set(a) - set(t["arguments"])
+            or set(t["required"]) - set(a)
+        ):
+            raise Diagnostic("unknown/missing arguments")
+        for k, v in a.items():
+            typ = (
+                "boolean"
+                if type(v) is bool
+                else "number"
+                if type(v) in (int, float)
+                else "string"
+                if type(v) is str
+                else "invalid"
+            )
+            if typ != t["arguments"][k]:
+                raise Diagnostic("argument type")
+            if typ == "number":
+                number_ok(v)
+    if "fields" in out or "limit" in out:
+        t = catalog[calls[0]["tool"]]
+        if len(calls) != 1 or t["returns"]["kind"] != "array":
+            raise Diagnostic("shaping scope")
+        if "fields" in out:
+            fs = out["fields"]
+            if (
+                not isinstance(fs, list)
+                or not 1 <= len(fs) <= 3
+                or any(not isinstance(k, str) for k in fs)
+                or len(set(fs)) != len(fs)
+                or set(fs) - set(t["returns"].get("properties", []))
+            ):
+                raise Diagnostic("projection fields")
+        if "limit" in out and (
+            type(out["limit"]) is not int or not 0 <= out["limit"] <= 100
+        ):
+            raise Diagnostic("limit range")
+    return plan
+
+
+def assemble(item, roles, mode, output):
+    toks, _, _, vals = frontend(item)
+    if (
+        not hasattr(roles, "__len__")
+        or len(roles) != len(toks)
+        or any(
+            not isinstance(r, (int, np.integer))
+            or isinstance(r, (bool, np.bool_))
+            or r not in range(6)
+            for r in roles
+        )
+    ):
+        raise Diagnostic("roles: length/value mismatch")
+    if (
+        not isinstance(mode, (int, np.integer))
+        or not isinstance(output, (int, np.integer))
+        or isinstance(mode, (bool, np.bool_))
+        or isinstance(output, (bool, np.bool_))
+        or mode not in range(3)
+        or output not in range(2)
+    ):
+        raise Diagnostic("heads: invalid class")
+    calls = []
+    pending = None
+    fields = []
+    limit = None
+    for x, v, r in zip(toks, vals, roles, strict=False):
+        if r == 1:
+            if pending is not None:
+                raise Diagnostic("unbound argument")
+            calls.append({"tool": x, "args": {}})
+        elif r == 2:
+            if not calls or pending is not None:
+                raise Diagnostic("argument structure")
+            pending = x
+        elif r == 3:
+            if pending is None or pending in calls[-1]["args"]:
+                raise Diagnostic("value structure/duplicate")
+            calls[-1]["args"][pending] = v
+            pending = None
+        elif r == 4:
+            fields.append(x)
+        elif r == 5:
+            if limit is not None:
+                raise Diagnostic("multiple limits")
+            limit = v
+    if pending is not None:
+        raise Diagnostic("missing value")
+    out = {"kind": OUTPUTS[output]}
+    if fields:
+        out["fields"] = fields
+    if limit is not None:
+        out["limit"] = limit
+    return validate({"mode": MODES[mode], "calls": calls, "output": out}, item["tools"])
+
+
+def compile_js(plan, tools):
+    validate(plan, tools)
+
+    def j(x):
+        return json.dumps(x, ensure_ascii=True, separators=(",", ":"))
+
+    inv = [
+        f"tools[{j(c['tool'])}](JSON.parse({j(j(c['args']))}))" for c in plan["calls"]
+    ]
+    pre = "const err=e=>String(e && e.message || e); const invoke=async f=>{try{return {ok:true,value:await f()}}catch(e){return {ok:false,error:err(e)}}};\n"
+    if plan["mode"] == "parallel":
+        pre += (
+            "const settled=await Promise.allSettled(["
+            + ",".join("invoke(()=>" + x + ")" for x in inv)
+            + ']); const r=settled.map(s=>s.status==="fulfilled"?s.value:{ok:false,error:err(s.reason)});\n'
+        )
+    else:
+        pre += "const r=[];\n" + "".join(
+            "r.push(await invoke(()=>" + x + "));\n" for x in inv
+        )
+    out = plan["output"]
+    if "fields" in out or "limit" in out:
+        pre += 'if(r[0].ok){try{let v=r[0].value; if(!Array.isArray(v))throw Error("result-schema: expected array");'
+        if "fields" in out:
+            pre += (
+                "const fields="
+                + j(out["fields"])
+                + '; v=v.map(row=>{if(row===null||typeof row!=="object"||Array.isArray(row)||fields.some(k=>!Object.hasOwn(row,k)))throw Error("result-schema: missing field"); return Object.fromEntries(fields.map(k=>[k,row[k]]));});'
+            )
+        if "limit" in out:
+            pre += f"v=v.slice(0,{out['limit']});"
+        pre += "r[0]={ok:true,value:v};}catch(e){r[0]={ok:false,error:err(e)}}}\n"
+    return pre + ("return r;" if out["kind"] == "all" else "return r[r.length-1];")

evaluation.json

@@ -0,0 +1,65 @@
+{
+  "authored_semantic_bases": 24,
+  "authored_supported_bases": 10,
+  "authored_supported_bases_correct": 8,
+  "authored_variants_per_base": 5,
+  "banks": {
+    "final_challenge": {
+      "bank_file_sha256": "edf44de829ea42599e70c0cd8a0a8f925c741d7106cf42539175f11c59e86883",
+      "full_decisions_correct": 97,
+      "negative": 70,
+      "negative_false_accepts": 13,
+      "rule_supported_exact": 41,
+      "supported": 50,
+      "supported_exact": 40,
+      "supported_execution_correct": 40,
+      "supported_rejected": 10,
+      "total": 120
+    },
+    "fresh": {
+      "bank_file_sha256": "3da8357ffc18e3dd836665758d747db61708314eccc63f735423bc5d7f6b8670",
+      "full_decisions_correct": 1192,
+      "negative": 575,
+      "negative_false_accepts": 5,
+      "rule_supported_exact": 555,
+      "supported": 625,
+      "supported_exact": 622,
+      "supported_execution_correct": 622,
+      "supported_rejected": 3,
+      "total": 1200
+    },
+    "transfer": {
+      "bank_file_sha256": "20b9c3c7e2f851f69de85f163e57ac2c6a564b3dfd2d8304ff3f68261cff80aa",
+      "full_decisions_correct": 1077,
+      "negative": 588,
+      "negative_false_accepts": 8,
+      "rule_supported_exact": 503,
+      "supported": 612,
+      "supported_exact": 497,
+      "supported_execution_correct": 497,
+      "supported_rejected": 115,
+      "total": 1200
+    }
+  },
+  "checkpoint_sha256": "a6b944d56580b64dfb526da5b3888a137b6783ea29d8a719a0fea3f4e3f7ee76",
+  "historical_evaluation_record_sha256": "c6644ab82f5d7411b92b0bcb5c387412357a0caf829c76b15fb26b90bfd57c38",
+  "historical_training_record_sha256": "871670888d326374c211c511cfb6816779ae899774f729cf6bc60935a6516a0a",
+  "limitations": [
+    "Synthetic/AI-authored data, not real-user or population evidence.",
+    "Authored variants are correlated; 120 requests are not 120 independent users.",
+    "All banks are exposed now; not future held-out evidence.",
+    "Dataset hashes identify source bytes, not proof of label correctness.",
+    "Compiler execution used fake tools, not a security boundary.",
+    "No attention-candidate results are included."
+  ],
+  "parameters": 67485,
+  "status": "historical_exposed_synthetic_evaluation_not_new_measurement",
+  "training": {
+    "epochs_completed": 55,
+    "initialization": "random",
+    "seed": 715,
+    "selected_epoch": 12,
+    "selected_validation_exact": 0.990625,
+    "training_sha256": "ed2ff9f0275c86958c475a89ec8e90664b954e0408eaefc356aa5ffb81c3b33a"
+  }
+}

examples/request.json

@@ -0,0 +1,17 @@
+{
+  "instruction": "Run list_users with team=\"blue\" and list_issues with state=\"open\" concurrently; return both results.",
+  "tools": [
+    {
+      "name": "list_users",
+      "arguments": { "team": "string" },
+      "required": ["team"],
+      "returns": { "kind": "array", "properties": ["id", "name"] }
+    },
+    {
+      "name": "list_issues",
+      "arguments": { "state": "string" },
+      "required": ["state"],
+      "returns": { "kind": "array", "properties": ["id", "title"] }
+    }
+  ]
+}

examples/request.jsonl

@@ -0,0 +1 @@
+{"instruction":"Run list_users with team=\"blue\" and list_issues with state=\"open\" concurrently; return both results.","tools":[{"name":"list_users","arguments":{"team":"string"},"required":["team"],"returns":{"kind":"array","properties":["id","name"]}},{"name":"list_issues","arguments":{"state":"string"},"required":["state"],"returns":{"kind":"array","properties":["id","title"]}}]}

infer.py

@@ -0,0 +1,35 @@
+"""JSONL inference CLI; compiles but never executes tools."""
+
+import argparse
+import json
+import sys
+
+from core import compile_js
+from model import Model
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument(
+        "--checkpoint", default=None, help="NPZ weights (default: packaged CNN)"
+    )
+    ap.add_argument("--js", action="store_true")
+    args = ap.parse_args()
+    model = Model(args.checkpoint)
+    for line in sys.stdin:
+        try:
+            item = json.loads(line)
+            plan = model.predict(item)
+            print(
+                json.dumps(
+                    {"plan": plan, "js": compile_js(plan, item["tools"])}
+                    if args.js
+                    else {"plan": plan}
+                )
+            )
+        except (ValueError, KeyError, IndexError) as e:
+            print(json.dumps({"diagnostic": str(e)}))
+
+
+if __name__ == "__main__":
+    main()

model.py

@@ -0,0 +1,64 @@
+"""Numpy-only neural inference; no semantic phrase rules. Fixed feature hashing."""
+
+from importlib.resources import files
+
+from core import Diagnostic, assemble, compile_js, frontend
+
+# isort: split
+# core must set CPU thread limits before NumPy initializes.
+import numpy as np
+
+
+def default_checkpoint():
+    return files("tiny_codemode_weights").joinpath("model.npz")
+
+
+class Model:
+    def __init__(self, path=None):
+        with np.load(path if path is not None else default_checkpoint()) as z:
+            self.w = {k: z[k] for k in z.files}
+
+    def logits(self, item):
+        _, ids, f, _ = frontend(item)
+        return self.forward(ids, f)
+
+    def forward(self, ids, f):
+        w = self.w
+        dims = w["convs.0.weight"].shape[1] - w["embed.weight"].shape[1]
+        h = np.concatenate(
+            [w["embed.weight"][ids % len(w["embed.weight"])], f[:, :dims]], axis=1
+        )
+        for i in range(3):
+            weight = w[f"convs.{i}.weight"]
+            bias = w[f"convs.{i}.bias"]
+            pad = weight.shape[2] // 2
+            p = np.pad(h, ((pad, pad), (0, 0)))
+            h = np.maximum(
+                sum(
+                    p[k : k + len(h)] @ weight[:, :, k].T
+                    for k in range(weight.shape[2])
+                )
+                + bias,
+                0,
+            )
+        pooled = np.concatenate([h.mean(0), h.max(0)])
+        heads = (
+            h @ w["roles.weight"].T + w["roles.bias"],
+            pooled @ w["mode.weight"].T + w["mode.bias"],
+            pooled @ w["output.weight"].T + w["output.bias"],
+        )
+        return (
+            heads + (pooled @ w["reject.weight"].T + w["reject.bias"],)
+            if "reject.weight" in w
+            else heads
+        )
+
+    def predict(self, item):
+        heads = self.logits(item)
+        if len(heads) == 4 and int(heads[3].argmax()) == 1:
+            raise Diagnostic("learned rejection: unsupported/invalid request")
+        r, m, o = heads[:3]
+        return assemble(item, r.argmax(1), int(m.argmax()), int(o.argmax()))
+
+    def program(self, item):
+        return compile_js(self.predict(item), item["tools"])

pyproject.toml

@@ -0,0 +1,54 @@
+[build-system]
+requires = ["setuptools>=77.0.3", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "tiny-codemode"
+version = "0.1.0"
+description = "Bounded research semantic parser and deterministic JavaScript compiler"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+dependencies = ["numpy>=1.24"]
+
+[project.optional-dependencies]
+training = ["torch>=2.0"]
+
+[dependency-groups]
+dev = ["ruff==0.16.10", "ty==0.0.10", "build>=1.2"]
+
+[tool.uv]
+required-version = ">=0.9.0"
+
+[tool.uv.sources]
+torch = [{ index = "pytorch-cpu", marker = "sys_platform == 'linux' or sys_platform == 'win32'" }]
+
+[[tool.uv.index]]
+name = "pytorch-cpu"
+url = "https://download.pytorch.org/whl/cpu"
+explicit = true
+
+[project.scripts]
+tiny-codemode = "infer:main"
+
+[tool.setuptools]
+py-modules = ["core", "model", "infer"]
+packages = ["tiny_codemode_weights"]
+
+[tool.setuptools.package-data]
+tiny_codemode_weights = ["model.npz"]
+
+[tool.ruff]
+target-version = "py310"
+extend-exclude = ["archive", "artifacts", "history", "build", "dist"]
+force-exclude = true
+
+[tool.ruff.lint]
+select = ["E4", "E7", "E9", "F", "I", "UP", "B"]
+
+[tool.ty.src]
+include = ["*.py", "tests", "tools", "tiny_codemode_weights"]
+exclude = ["archive", "artifacts", "history", "build", "dist"]
+
+[tool.ty.environment]
+python-version = "3.10"

release.json

@@ -0,0 +1,11 @@
+{
+  "checkpoint": "tiny_codemode_weights/model.npz",
+  "checkpoint_sha256": "a6b944d56580b64dfb526da5b3888a137b6783ea29d8a719a0fea3f4e3f7ee76",
+  "evaluation": "evaluation.json",
+  "format_version": 1,
+  "integrity_manifest": "SHA256SUMS",
+  "license": "MIT",
+  "model": "Tiny Codemode CNN",
+  "parameters": 67485,
+  "scope": "inference_only_custom_numpy_not_transformers"
+}

requirements.txt

@@ -0,0 +1,2 @@
+# Legacy pip entry point. Reproducible inference: uv sync --locked --no-dev
+.

tiny_codemode_weights/__init__.py

@@ -0,0 +1 @@
+"""The frozen default CNN checkpoint packaged for offline inference."""

tiny_codemode_weights/model.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a6b944d56580b64dfb526da5b3888a137b6783ea29d8a719a0fea3f4e3f7ee76
+size 253781