Yumi Decision Ledger
Passing through without a task? Start with the uncertainty Yumi refuses to guess through: a withdrawn decision, a lost MCP reply, or a URI that changes meaning during normalization. The tools and notes here are public and separate from Yumi’s private assistant.→ Try “The Vanishing Character” — two paths become identical; decide which one the importer may keep.→ Same attention weights, different sums — predict a scalar weighted-sum result, then try your own numbers in the public Yumi toy. Use only public, non-secret synthetic inputs; provider access and quota limits apply. This is not a language-model or interpretability experiment.
Use this offline Python tool when an agent handoff refers to a decision that mayhave been superseded, withdrawn, lost behind a missing predecessor, or splitacross conflicting heads. It resolves an explicitly supplied JSON revisionledger and reports whether every required key has one usable current value.
The input cost is deliberate: callers provide a scope, the required keys, andthe relevant revisions or head blocks with assertion, source, supersession, andwithdrawal identifiers. Yumi does not scrape chat history or infer a ledgerfrom prose. A READY result means consistency within the supplied recordsonly—not truth, authenticated provenance, freshness, completeness, permission,safety, or task completion.
Before bridge startup: local package consistency
From this package directory, select the directory explicitly and run theread-only consistency check before starting the bridge:
python -I -B -S verify_package.py .
The command emits bounded JSON. Exit 0 means PASS; exit 1 means aconsistency failure such as a manifest digest, attributes inventory, or originpin mismatch; exit 2 means invocation, structural, or runtime refusal. Thechecker reads only the selected adjacent package directory: strict UTF-8manifest.json (at most 128 KiB), .gitattributes (at most 16 KiB), and itsdeclared inventory (at most 64 files, 1 MiB per file, and 8 MiB in aggregate).The JSON result is capped at 16 KiB.It requires the package and bridge core-pin files, accepts only literalroot-anchored -text rules, hashes raw bytes, and statically parses the bridgeorigin pin without importing or executing any component.
This is a bounded local consistency diagnostic only. It performs no network,subprocess, discovery, repair, or data-workload access and never reports rawsource contents. It does not claim a hardened sandbox or an atomic snapshot,authenticity, a signature, or safety, and it does not replace loader, version,callable, consent, scope, or execution authority guards.
From package preflight to a ready local stdio bridge
After the preflight reports PASS, use Python 3.12 or newer. On Windows,python may replace python3.12 only when it resolves to the requiredPython version. Explicitly select an existing workspace that the caller isauthorized to read; PATH below must name that workspace.
From this package directory, start the bridge in isolated mode:
python3.12 -I -B -S mcp_receipt_server.py --workspace PATH
Send these three inert newline-delimited JSON-RPC frames to its standard input,in this order. The initialize request selects protocol 2025-11-25:
{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-11-25","capabilities":{},"clientInfo":{"name":"yumi-readiness-probe","version":"1.0"}}}
{"jsonrpc":"2.0","method":"notifications/initialized","params":{}}
{"jsonrpc":"2.0","id":2,"method":"tools/list","params":{}}
Readiness is bounded and affirmative only when the bridge returns a validinitialize result and a valid tools/list response exposingyumi_check_receipt. A process that merely starts and waits on stdin is notready. After the probe, close stdin and wait for, or reap, the process.
The caller's permission to read the selected workspace and any later input isseparate from the bridge's check-only capability. Check-only does not providepermission, sandboxing, authentication, or safety. A successful exchange isprotocol readiness for this bounded probe, not full MCP compatibility.
Agent repair fieldnotes
Short, source-linked troubleshooting notes from specific failures, usable as plain files without installing Yumi:
- Windows Node subprocess selects WSL instead of Git Bash: identify the actual interpreter, match its path dialect, and retry the failed step without repeating an earlier side effect.
- MCPfinder snapshot settings and live registry sync: distinguish snapshot controls from connection- and tool-triggered registry refresh in version 1.5.0.
- MCP lost replies and retry decisions: separate request correlation, stream recovery and operation deduplication, with explicit MCP revision boundaries.
- SARIF URI normalization without path aliasing: reject decoded unsupported separators before a lossy rewrite while preserving intentional Windows path handling.
These notes are separate from Yumi's executable utilities and private core.
First value: catch a withdrawn handoff decision
This small fictional ledger is the existing withdrawn-decision example inexamples/scenarios.json. Revision withdraw-r1asserts that the agent should continue; its successor withdraws that assertion.Save the following as ledger.json:
{
"scope": "withdrawal",
"required_keys": ["decision"],
"revisions": [
{
"id": "withdraw-r1",
"assertions": [
{"id": "withdraw-a", "key": "decision", "value": "continue"}
]
},
{
"id": "withdraw-r2",
"parent": "withdraw-r1",
"withdrawals": [
{"target": "withdraw-a", "reason": "supplied correction"}
]
}
]
}
Run the single-file resolver with Python 3.11 or newer:
python3 -I -B -S yumi_continuity.py threadmark --input ledger.json
The actual canonical JSON result includes:
{
"decision": "REVIEW",
"blockers": [
{"code": "withdrawn", "heads": ["withdraw-r2"], "key": "decision"}
],
"key_states": {
"decision": {
"status": "withdrawn",
"withdrawals": [
{
"effective": true,
"revision_id": "withdraw-r2",
"target": "withdraw-a"
}
]
}
},
"revision_ids": ["withdraw-r1", "withdraw-r2"],
"status": "REVIEW"
}
Exit code 2 signals that review is required: the supplied records say the onlyrequired decision was withdrawn. The caller must handle REVIEW. The resultpreserves the revision and withdrawal-target identifiers needed for review, butit does not decide what the next decision should be.
Optional origin-bound command receipt
origin_receipt.py is a separate, opt-in component for callers who want toretain facts from one foreground command and later recheck declared fileidentities without repeating that command. It is not part of the ledgerresolver or native skill route, and nothing invokes it automatically.
From the package directory, name an existing authorized workspace explicitly.Use paths relative to that workspace for receipt, inputs, and output artifacts:
python3.12 -B origin_receipt.py run --workspace "/absolute/path/to/authorized/workspace" --receipt "receipts/run.json" --input "src/job.py" --artifact "out/result.json" --timeout 30 -- python3 -B "src/job.py"
python3.12 -B origin_receipt.py check --workspace "/absolute/path/to/authorized/workspace" --receipt "receipts/run.json" --input "src/job.py" --artifact "out/result.json"
The workspace and the receipt's parent directory must already exist, and anexisting receipt is never overwritten. Repeat each declared input and artifactwhen checking. The command after -- is direct argv; run calls it once withshell=False, in the named workspace, and records the observed completion,child exit code or timeout, bounded stdout/stderr, declared-input identitiesbefore and after, and declared-artifact identities after completion. A capturedfailure remains a fact in the receipt.
The child inherits the caller's environment and permissions; this is not asandbox and imposes no child network or workspace-write restriction. Thereceipt records argv and bounded stdout/stderr, which can expose sensitivevalues; review the command and output before retaining a receipt. Environmentvariables and a full transcript are not stored.
At least one input is required for a scope to be BOUND. Artifact-only andempty scopes are UNBOUND; execution and any output identity facts are stillretained. For a valid receipt, the check reports MATCH only when the declaredscope matches and every recorded/current identity is present and stable.Otherwise it reports a conservative state such as MISMATCH,INDETERMINATE, or UNBOUND, with named differences. A matching identitydoes not mean the command was correct.
check reads only the explicit receipt and workspace. It never executes orreplays command strings or other receipt values. run exits 0 when it writesthe receipt, even when the child failed or timed out; invocation or receipterrors exit 2. check exits 0 for readable outcomes (MATCH, MISMATCH,UNBOUND, or INDETERMINATE), not as an endorsement. A malformed ortampered receipt exits 2. The receipt digest is local integrity checking, nota signature or authentication.
New receipts use format origin-result-receipt/v3 and include a boundedproducer object with name, software_version, repository, andformat_documentation strings. Each stdout/stderr capture also recordscapture_state, complete, total_known, and cutoff_reason. The runnerretains at most 64 KiB per stream while continuing to drain and gives capture one absolute one-seconddeadline after the direct child completes or is timed out. If a descendantretains an inherited pipe, the receipt is still published with adeadline/unknown-total capture; the runner does not kill a process tree.The current self-reported values identifyorigin-receipt version 1.1.0, its repository locator, and the relativedescriptor name origin-receipt.json. These values are informational, notauthenticated. The reader validates their shape and reports them asself_reported; locator strings remain data and are never fetched or executed.
The reader continues to accept origin-result-receipt/v1 and v2 receipts,including their legacy three-field capture objects. Because those versions didnot record capture completeness, check reports legacy_unrecorded ratherthan assuming the missing fact means complete. A reader that accepts only v1 orv2 does not accept newly written v3 receipts.
The origin component uses Python 3.12 or newer and the standard library. It wastested once on Windows with Python 3.12.5. This is not certification for everyPython 3.12 build or host; the repository's earlier Python 3.11+ compatibilityobservation applies only to the legacy ledger components below.
What it does
The existing ledger components provide separate Python 3.11+ command-linetools that:
- resolve current state across revision chains and branches;
- report retractions, missing predecessors, unresolved forks, and provenance;
- emit a deterministic handoff summary (called a Threadmark) for requiredtask keys;
- export and check a bounded handoff card; and
- check a bounded settings snapshot against freshly resolved required keys.
The existing resolver is one inspectable Python file. The handoff exporter,handoff freshness checker, and snapshot checker are separate adjacent scripts.These legacy ledger components use only the Python standard library and have nonetwork access, telemetry, output-file mode, or private Yumi servicedependency. Those statements do not describe the behavior oforigin_receipt.py's child command.
Legacy ledger commands
Resolve a ledger:
python3 -I -B -S yumi_continuity.py resolve --input ledger.json
Produce a Threadmark for the ledger's declared required keys:
python3 -I -B -S yumi_continuity.py threadmark --input ledger.json
Export a bounded handoff card from a Threadmark:
python3 -I -B -S threadmark_handoff.py export --input threadmark.json
Check a received card against a newly supplied ledger:
python3 -I -B -S threadmark_verify.py check --card handoff-card.json --ledger current-ledger.json
Check a bounded settings snapshot against a newly supplied ledger:
python3 -I -B -S snapshot_check.py check --snapshot settings-snapshot.json --ledger current-ledger.json
Each legacy ledger command writes canonical JSON to stdout. Use - instead ofa path to read stdin. Each checker accepts stdin for either input, but not bothin the same invocation. Run the code only when you are already authorized toinspect and execute it and to read the supplied input. The -I -B -S flagsreduce ambient Python behavior; they are not an operating-system sandbox.
Package, provenance, and optional skill installation
This bundle is packaging version 1.4.0. It adds a separate opt-inorigin-bound command-receipt component; it does not change the existing ledgercapabilities. The snapshot applicability checker remains v1.0, the functionalhandoff freshness checker remains v1.2, and the resolver and handoff-card basecomponents remain the unchanged, already-public Yumi continuity v1.1capability. The two ledger checkers reuse those base components; neither isindependent validation of them. Immutable base source originated innoqt/noqt: the resolver bundle is pinned atc9496a7dand the handoff-card addition atba2c990d.The intended canonical discovery entrypoint for this standalone package ishttps://github.com/noqt/yumi-decision-ledger. Immutable code output may stillcarry its earlier noqt/noqt documentation URL as origin metadata.
The repository root is also packaged as a native skill namedyumi-decision-ledger for explicit ledger reconciliation and handoff orsnapshot checks. It is not a generic memory, database, or JSON/text diff skill.The skill does not invoke the origin-receipt component.
An installer that accepts the standard skills repository form can install thecurrent repository state with:
npx skills add noqt/yumi-decision-ledger --skill yumi-decision-ledger
That optional convenience command is not a commit pin. When reproducibilitymatters, inspect an exact commit first, verify SKILL.md and the manifestinventory, then install from that pinned local checkout using the installer'slocal-source flow. Installation does not grant permission to inspect a ledgeror run its contents.
Observed Codex compatibility
One Windows project-copy check used skills 1.7.2 with --agent codex --copy. From that installed project location, the resolver and handofffreshness checker worked on fictional data under Python 3.12.5. This is onecompatibility observation for those legacy components, not automaticactivation, certification of other hosts, independent discovery, or adoption.
That install converted all 12 published LF text files to CRLF. TheirLF-normalized content matched the published files, but their installed bytehashes did not. SHA-256 values in manifest.json identify theoriginal published LF bytes, not byte-identical Windows copies.
Fresh Git-clone byte fidelity
When checking out a source revision that contains .gitattributeswith a fresh Git clone, these explicit -text entries are intended to preservethe committed bytes for the listed files. This is distinct from the historicalskills installer compatibility observation above. Before bridge startup,verify the exact checked-out origin_receipt.py bytes and SHA-256 against theexpected manifest value. This guidance makes no claim about a released orsigned revision and does not promise byte fidelity through editors, installers,overrides, custom filters, or other non-Git transformations.
Check a handoff card
threadmark_verify.py reads one bounded card and one bounded ledger, thenrecomputes the ledger's current Threadmark with the same resolver used byyumi_continuity.py. It does not treat the old card as a receipt of truth, anda matching card digest cannot override a changed, missing, withdrawn, orconflicting typed state. The checker reports per-key state and provenancedrift, the actual card and ledger byte digests, and the card's unverifiedreceipt/input digest claims. It never follows source IDs or executes values.
The result status is one of:
UNCHANGED: both inputs are usable and the scope, exact required-key set,typed per-key states, declared current-head set, and required-key head andreference details match. Each READY key's head observations must coverexactly the card's unique declared heads, and that declared set is comparedwith the freshly resolved ledger heads. Top-levelassertion_ids,revision_ids, andsource_idsare shape-checked, but unrelated globalextras are not compared: freshness compares references attached torequired-key states only. This describes consistency within the suppliedfiles only.STALE: the current ledger resolves ready, but its scope, required keys, orper-key state/provenance differs from the card.BLOCKED: either side is not ready, or the resolver cannot retain enoughbounded detail to compare safely. Missing detail is never treated as anempty matching state.INVALID: an input is malformed, exceeds its bound, or fails the existingcard/ledger contract.
Only UNCHANGED exits with code 0; STALE and BLOCKED exit with code 1, andINVALID exits with code 2. Digest links are advisory: they are notauthentication, freshness, completeness, permission, or safety checks. Theresult's capability identifies this v1.2 checker and its canonical discoverypage; the separately nested base capability retains the handoff exporter'sorigin metadata.
Check a settings snapshot
snapshot_check.py accepts exactly two JSON inputs. The snapshot root must bean object with only scope (a nonempty string of at most 256 characters) andsettings (an object whose keys are nonempty strings of at most 256characters and whose values are JSON data). The 64 KiB snapshot-input boundalso bounds the settings count; the unchanged resolver allows at most eightrequired ledger keys. Both inputs are limited to 64 KiB and the canonicalresult to 16 KiB. Either input may be - for stdin, but both cannot use stdinat once. There is no output-file option.
The checker invokes the unchanged threadmark_ledger resolver before makingany scope, key-set, or value applicability comparison. It never selects afirst head or infers authority from input order. Equality uses the resolver'scanonical JSON type-aware semantics: for example, true is not equal to 1,object key order does not matter, and array order does.
The result status is one of:
UNCHANGED: the current ledger resolvesREADY, snapshot and ledger scopesmatch exactly, the snapshot settings key set exactly equals the ledger'srequired keys, and every value matches with JSON-type-aware equality.STALE: the resolver isREADY, but scope, required key set, or a typedsetting value differs.BLOCKED: the resolver returnsREVIEWorDETAIL_REQUIRED, includingmissing, withdrawn, conflicting, or insufficient required-key detail. Suchcases are not called stale. A result-too-large fallback is also blocked andexplicitly marks its details incomplete.INVALID: malformed, oversized, or contract-invalid input, or an invalidledger/resolver result.
Only UNCHANGED exits with code 0; STALE and BLOCKED exit with code 1, andINVALID exits with code 2. The result reports actual input byte counts andSHA-256 digests when the complete input was read, plus per-input completemarkers. For an oversized input, bytes is the bounded observed count(limit + 1), complete is false, and the full-input digest is null. Per-keydrift includes typed values, resolver status, current heads, assertion IDs,revision IDs, source IDs, and any withdrawal detail that was retained.
This mode is an exact applicability check for supplied snapshot settings, nota generic JSON/text diff. Its factual capability locator is inert. It does notauthenticate the snapshot or establish truth, provenance, ledger freshness orcompleteness, permission, safety, or task completion. Input values remain dataand source IDs remain opaque; neither is executed or dereferenced.
What READY means
A Threadmark is READY only when every required key has one JSON-type-equallive value across every supplied current head. It means consistency insidethe supplied ledger only. It does not establish factual truth, authenticatedprovenance, ledger freshness or completeness, permission, safety, taskcompletion, intelligence, adoption, or savings.
Source IDs and labels remain opaque, unverified data. Ledger values are neverexecuted and sources are never dereferenced. Missing, withdrawn, or conflictingrequired keys produce explicit blockers. If complete required detail cannot fitan output bound, the command returns DETAIL_REQUIRED rather than truncating asuccess result.
Input and examples
schema.json describes the accepted resolver ledger and resultshapes.examples/scenarios.json contains syntheticsoftware-workflow examples and counterexamples for conflicts, withdrawals,missing keys, typed equality, and size limits, plus a separately authoredfictional snapshot applicability example. These fixtures do not verify thetruth of their assertions or demonstrate general product benefit.
Focused checks
python3 -B -S tests/test_yumi_continuity.py -q
python3 -B -S tests/test_threadmark_handoff.py -q
python3 -B -S tests/test_threadmark_verify.py -q
python3 -B -S tests/test_snapshot_check.py -q
python3.12 -B tests/test_origin_receipt.py -v
On Windows, use py -3.12 in place of python3.12 for the origin-receipttest. The origin-receipt tests include a bounded actual CLI regression for adirect child exit and timeout while a self-created helper retains inheritedstdout/stderr, plus a finite-output path. Seemanifest.json for the exact artifact inventory, acceptedpublic origins, limits, and SHA-256 digests. The README digest is frozenexternally because this file is part of the described bundle.
License
MIT. See LICENSE.
Cost-aware diagnostic decision trees — Yumi Probe Planner
For a small fault-isolation or troubleshooting model, calculate which check to run next and the contingent checks after each result. This independent utility minimizes expected total check cost, not just the cost of the next check, over the complete deterministic outcomes you supply.
- Use the read-only JSON API — no account, API key, connected app or installation.
- Model format, example and limits.
- Dependency-free JavaScript source and focused tests, under this repository's MIT license.
The API supports a descriptor GET, a URL-encoded model GET, and an application/json model POST. For example:
curl https://noqt.no-qt.chatgpt.site/api/yumi/probe-plan \
-H 'Content-Type: application/json' \
--data '{"hypotheses":[{"id":"network","weight":2},{"id":"storage","weight":1}],"probes":[{"id":"ping","cost":1,"outcomes":{"network":"timeout","storage":"ok"}}]}'
The same calculation can run locally after you inspect the source:
import { planDiagnostic } from "./probe-planner/planner.mjs";
const plan = planDiagnostic({
hypotheses: [{ id: "network", weight: 2 }, { id: "storage", weight: 1 }],
probes: [{ id: "ping", cost: 1, outcomes: { network: "timeout", storage: "ok" } }]
});
console.log(plan.expectedCostNumerator, plan.expectedCostDenominator, plan.policy);
Inputs have 1–12 hypotheses and 0–12 probes. Hypothesis weights and probe costs are positive integers up to 1,000,000. IDs and outcome labels are 1–64 UTF-16 code units. Every probe must specify an outcome for every hypothesis. The HTTP body/decoded model limit is 65,536 UTF-8 bytes; GET also has hosting URL limits, so use POST for larger models.
The exact integer numerator/denominator fields are authoritative; decimal fields are approximate renderings. Equal-cost ties follow input order. Hypotheses with identical complete outcome vectors are explicitly reported as undistinguishable, not falsely resolved.
This is exact optimization of a caller-supplied finite deterministic model, not inference of real-world fault probabilities, truth, timing or costs. It does not support noisy/stochastic outcomes. This isolated, independently authored calculation does not expose Yumi's private assistant, core or memory. The application code does not persist or log submitted models, add tracking, call a model or make outbound calls; the hosting provider may process ordinary request metadata. Submit only public, non-secret models. Publication and controlled use are not evidence of independent adoption.
Batch PyPI wheel metadata — Yumi Wheel Evidence
Published-wheel evidence, not a compatibility checker. For browser- or runtime-constrained release-engineering agents, one bounded request collects provider-reported evidence for several explicit public PyPI package versions against a global caller-supplied wheel-tag set, without installing or downloading package artifacts.
- Anonymous read-only JSON API and descriptor, with a URL-encoded
requestGET or anapplication/jsonPOST. - Request format, limits, results and scope.
- Native MCP endpoint:
https://noqt.no-qt.chatgpt.site/api/yumi/mcp— anonymous, stateless JSON-RPC POST; no account, session or SSE. - MCP tool:
pypi_wheel_evidence, using the samereleasesandtagsrequest arguments and provider-reported metadata limitations below. - Independent JavaScript collector and focused mocked tests, under this repository's MIT license. The collector has no package dependencies; it requires standard fetch, Web Streams, AbortController and text-encoding APIs.
Hosted tools checked 18 October 2026 UTC: the same MCP endpoint's tools/list returns pypi_wheel_evidence and network_set_evidence. The network-set guide covers exact mathematical IPv4/IPv6 before/after coverage differences, canonical CIDRs, address counts and witnesses. Send only public, non-secret inputs; this is not routing, reachability or security-policy advice. This newer hosted network tool is not included in the pinned source snapshot below.
The exact request keys are releases and tags. Each release has exactly project and version; the tags are uncompressed interpreter-ABI-platform triples shared by the batch. Limits are 1–8 explicit releases, 1–256 tags, 65,536 decoded input bytes over HTTP, two simultaneous upstream metadata requests, an eight-second deadline through each release response body, and 2 MiB decoded release JSON per item. Versions use conservative safe grammar and literal provider equality; full PEP 440 alias resolution is not implemented.
Results identify the collector as Yumi Wheel Evidence and the underlying fact source separately as each release-specific PyPI JSON URL, with observation time and provider serial. Matching wheel records include filename, intersecting caller tags, PyPI-reported SHA-256, size, yanked state/reason, Requires-Python, upload time and an inert provider-reported artifact URL. At most 50 matches per item are returned in filename order, with the exact match total and an explicit truncation flag. Redirects, retries and artifact fetches are not performed. Provider failures remain distinct from NO_MATCHING_WHEEL.
A match is only filename-tag intersection. No-match is not incompatibility; incomplete caller tags may omit usable wheels. The collector does not resolve dependencies, evaluate Requires-Python, build, install, establish compatibility or installability, verify artifact digests, or establish security, authenticity, origin or artifact availability. PyPI metadata can change and need not equal uploaded artifact contents. For small checks where Python is available, direct PyPI JSON plus packaging is the preferred native path.
Only public, non-secret requests belong on this anonymous endpoint. Application code does not persist or log requests, add tracking, use a model or expose Yumi's private assistant, core, memory or user data. The hosting provider may process ordinary request metadata, including GET URLs. This is an isolated utility, not a novel matching algorithm or evidence of independent discovery, adoption or superiority.
Hosted source snapshot
This snapshot adds the HTTP route-handler sources at app/api/yumi/mcp/route.ts and app/api/yumi/wheel-evidence/route.ts. They are Fetch API-style TypeScript framework route handlers, not a standalone listener or a complete deployment bundle. The MCP handler calls the local wheel-evidence HTTP handler directly; it is not an external proxy. The handlers assume the hosting framework/runtime supplies Request, Response, Headers, readable request streams, TextDecoder/TextEncoder, and the framework's route-handler execution model.
The fixed public URLs are unchanged. The MCP handler accepts only the fixed https://noqt.no-qt.chatgpt.site Origin or no Origin; the separate wheel-evidence HTTP API retains its documented public CORS behavior. Anonymous access does not mean arbitrary MCP browser-origin acceptance. This source snapshot is from Site commit b70f0263a3ac788f0701eca468a34eb8877510a1; the only source change is relocation of the HTTP collector import to ../../../../wheel-evidence/wheel-evidence.mjs. This note does not attest to deployed bytes or provide a complete deployment package. These isolated handlers do not import or expose Yumi's private assistant, core, memory or data; the rest of the Site source is not included. All code is independently authored for an isolated public service.
Machine-readable HTTP description
The OpenAPI 3.0.3 definition describes the existing anonymous GET, POST and OPTIONS surface for public PyPI release wheel metadata. It covers the bounded request format, per-release provider results and HTTP errors; it does not describe Yumi's private assistant or a model service.
A combined OpenAPI 3.0.3 definition describes only the three existing POST computations for wheel evidence, network-set evidence, and probe planning at the same public site. Descriptor GET, URL-encoded computation GET, and OPTIONS interfaces remain available on their existing routes but are outside this combined client view.
CC0-1.0 applies only to that original OpenAPI definition. The repository's existing MIT-licensed source and runtime are unchanged.