PyCForge 1.3.61 and separate PyCForge SDK 0.1.0
Framework and headless authoring qualification — 2026-10-28
Unpublished handoff. CC alone decides and performs publication.

DELIVERED SCOPE

PyCForge adds the public ScalarAuthoring service: prepare an immutable data
declaration, inspect it, convert a candidate source, and serialize a package.
It delegates to the existing scalar descriptors and Runtime converter. Every
existing converter implementation file is byte-identical to 1.3.60. The math
package is unchanged. No new math or NumPy coverage is claimed.

The selected engine exports authoring.json inside its hashed SDK catalogue.
It explains six authoring entries with task grouping, public import paths,
parameters/defaults, returns, effects, errors, examples and limits. It supplies
an inert starter template and the native fixture profile. The wider advanced
method inventory remains separately accessible. Existing XML/discovery/schema
0.1 and old method signatures remain compatible; new guidance has an independent
authoring-reference schema. Some legacy advanced entries still have brief help.

The separate SDK is an installable, stdlib-only package with a public SDK Python
API and pycforge-sdk console entry point. Both clients share one backend. There
is no PySide6 GUI and no PyCForge or Qt runtime dependency in the SDK. It selects
an engine interpreter explicitly and invokes supported public engine services
through an isolated child process. The SDK contains no second converter.

Commands: connect, methods, describe, new, inspect, convert, verify, build,
register. JSON results have independent schemas and explicit success/rejection/
incomplete/canceled/internal-failure states. Method data can feed a future tree
and explanation pane. Examples are never executed by catalogue browsing.

Verification explicitly converts, compiles and executes the project's fixtures.
The build gate requires complete passing evidence bound to current project/test
bytes, engine catalogue, SDK version, compiler identity, host and build profile.
Failed, canceled or incomplete new verification retires prior approval. Rejected
builds preserve existing output. Registration is a separate explicit operation.
PyCForge admits packages and reads verification metadata; it does not run the
SDK verification suite. Reports are finite fixture evidence, not signed proofs.

FRAMEWORK DIRECTIVES

Both source projects include the shared framework directive, original API
requirements and SDK roadmap. Engine AGENTS.md preserves CC's existing README
and publication rules and adds the instruction to consult the SDK framework
before changing the boundary. The SDK has its own project directives.

A later PySide6 client must use the same backend. The engine owns conversion
meaning and publishes its reference. Compatibility, independent-author usability,
array/view contracts and native-resource ownership are explicit development
gates. The SDK is deliberately developed alongside the engine before a general
API freeze. Math and later NumPy remain the two intended bundled defaults.

COMPLETED CHECKS

Engine source coverage: 3,300 tests in four disjoint file groups, followed by
two additional distribution-regression cases, and 4,882 passing subtests. Final
collection exactly matches the reconciled outcomes: 3,230 passed, 72 existing
conditional skips, no unresolved failures. The skipped
node IDs exactly match the 1.3.60 baseline. The first four-group invocation found
two stale assertions expecting active version 1.3.60. They were updated to
1.3.61; all 11 tests in that release-contract file passed on the correction run.
The summary explicitly combines these results; it does not claim the initial
four-group invocation had zero failures. No product code changed for this fix.

Installed PyCForge wheel: 89 selected engine/authoring/math/registration tests
passed. All 143 imported pycforge modules came from the installed wheel. An
earlier harness omitted the installed path for child processes; that harness
was corrected and all 89 checks completed successfully. Earlier logs remain
labeled preliminary and do not establish the final result.

Installed SDK with a separately installed engine: 34 tests passed, no skips.
The checks cover Python/console parity, headless imports, complete native
authoring/package/registration, deterministic package bytes, source/metadata/
expectation/engine/compiler/report staleness, canceled and failed verification,
missing tools, malformed reports, explicit rejection fixtures, offline cache,
legacy engine browsing, path/symlink/JSON/size limits and process supervision.

A real synthetic engine-only upgrade adds a public method, its detailed guidance
and a second scalar template. The SDK code hashes remain unchanged. The same
SDK discovers the additions, authors the new extension, verifies, builds and
registers it. A fresh engine process with no SDK installed consumes that package
and its compiled program produces the expected output. The synthetic 1.3.62
identity exists only inside the test fixture; it is not a release artifact.

The editable cube-root example is included without machine-bound approval state.
A separate installed-client example run also completed verification and build.
Consumers should verify the example in their own selected environment.

PACKAGE CUSTODY

The cross-archive byte check caught a staging rule that omitted the real
pycforge/build package from an intermediate source archive. Staging now excludes
only root build-output folders. The distribution verifier was strengthened to
require every wheel runtime payload in the source inventory and to require both
project instruction files. It rejects the actual incomplete archive. Eleven
distribution tests (including two new omission cases) and six existing subtests
pass. The intermediate source archive is superseded and was not handed off.

The engine wheel contains 931 package files matching maintained source and
installed bytes. The SDK wheel contains 11 Python package files matching its
source and installed bytes. Neither installed environment contains the other
product: the SDK environment has neither pycforge nor PySide6; the engine
environment has no pycforge_sdk. Source archives include the tests, directives
and qualification evidence. Final archive hashes are appended externally after
creation, avoiding self-reference. Nothing was uploaded to PyPI.

ENVIRONMENT AND REMAINING LIMITS

Qualified on Python 3.12, Linux x86_64 with GCC and offscreen Qt for existing
PyCForge UI regression checks. Native SDK verification is limited to the
engine's GNU-style C11 Linux profile. Actual Windows/macOS execution and Python
3.11/3.13 execution were not performed. No GUI usability trial is claimed.

All 0.1 APIs are provisional. The supported extension profile remains direct
scalar Runtime calls using binary64 math.h/libm. Arrays/views, resource-owning
operations, arbitrary native dependencies, Python-entrypoint plugins, complete
conformance tooling and NumPy remain open. A simple declarative native binding
does not supply a new algorithm. Fixture expectations are author-provided and
can be insufficient; passing them does not prove all inputs or platforms.

Timeouts and cancellation supervise explicit tool work; they are not a security
sandbox. POSIX process groups are terminated on timeout/cancellation. Windows
direct-process termination is not claimed to supervise arbitrary descendant
process trees. Sessions and project mutations assume one writer. Compiler
identity covers the selected driver/version, not every external toolchain or
shared-library dependency. Hashes ensure consistency, not publisher authenticity.

REPRODUCTION

Engine source: QT_QPA_PLATFORM=offscreen python -m pytest -q
Engine resources: python -m tools.export_sdk_landscape --check
Engine README: python -m tools.verify_pypi_readme
Engine pair: python -m tools.verify_public_distribution /path/to/engine-pair

SDK checks: set PYCFORGE_TEST_ENGINE to the 1.3.61 engine interpreter and
PYCFORGE_TEST_OLD_ENGINE to an installed 1.3.60 interpreter, then run
python -m pytest -q with the SDK installed or its src on PYTHONPATH.
The compatibility test creates a temporary isolated engine fixture. GCC is
required. Source tests intentionally fail rather than silently skip when
required integration interpreters are absent.

For installed SDK use, run pycforge-sdk --engine-python ENGINE_PYTHON connect,
then methods or describe ScalarAuthoring.convert. See SDK README.md for the
complete create/inspect/verify/build/register workflow and direct Python use.
