Skip to content

Latest commit

 

History

History
360 lines (333 loc) · 24.9 KB

status.md

File metadata and controls

360 lines (333 loc) · 24.9 KB

Status and caveats

Code is atyrode.code, a TypeScript/React policy and presentation plugin within Manifold. The independent atyrode.omp plugin owns its native runtime. #149 records the ratified replacement and #161 its current cross-repository integration. The architecture's section 6 is the sole transition ledger. This page records constraints, not another roadmap.

Native shared-role cutover

#286 owns the native routing refresh. The typed caller package is 0.2.0 and the root action plugin is 0.5.0 because the strict public route result no longer contains agentBacked; the generator is 0.4.0. These are exact authored labels for one clean generation: Code caller 0.2.0, root plugin 0.5.0 and generator 0.4.0 pair with OMP family 0.4.0. They are not manifest minimums: no manifest declares a version range, nothing compares these numbers and a higher label is not admitted for being higher. Admission is separate and exact:

  • The source gate uses Bun 1.4.4 and the exact Manifold revision. Both Code package manifests and their resolved locks pin the same immutable OMP commit; its paired SDK revision and Code's workflow SDK source must match that file. Protocol and hardened-contract admission come from that exact SDK, not an older installed hub. The gate prepares the pinned source rather than installed CLI or branch bytes.
  • At runtime the hub admits Code's required OMP dependencies by plugin ID, the typed caller holds OMP inputs and results to strict schemas, and installation admits bundles only against the hub's actual core protocol, owner RPC and hardened-contract capabilities.
  • A catalog's ompVersion is recorded provenance, never compared or admitted.

This source pins the tagged OMP a538300 (family 0.4.0 on OMP 18.20.1) and Manifold 5693107 (v0.37.0: protocol 60, owner RPC 46, hardened contract 14), which is also OMP's own MANIFOLD_REV. The Code gate is source proof against that locally prepared OMP commit. Separate publisher proof for stable OMP v0.4.0 passed: ordinary unauthenticated HTTPS downloads of all six assets, strict publisher sums and full native verification with a fresh normal owner and no prepared archive map. The release is versioned and SHA-verified, not GitHub-immutable or Sigstore-attested. That upstream release proof does not establish Code's own gate or live activation. The pinned native runtime is OMP 18.20.1 inside that family; a standalone OMP 18.20.2 found on a workstation is ambient, not a substitute for this pin, and nothing here admits, tests or launches it.

Separately pinned callers intentionally remain on their old caller/root pair until their owner upgrades and repacks them; nothing shims the old pair. Before activating the new root, the operator must confirm every installed dependent caller in that deployment is paired. An authorized read-only inventory of the selected development deployment found Babel installed with native execution enabled beside a native-disabled Code bundle, so Babel's owner-upgraded, repacked compatible caller is required there before any later Code activation. Babel's local source pin does not establish the installed bundle's provenance, and this records a pairing prerequisite, not an observed failure. This page does not publish an installed roster or assert cross-version compatibility.

There is no compatibility alias. Code configures only shared native roles and does not replace bundled agents or emit task.agentModelOverrides. The routing contract distinguishes configured role effort from native agent thinking and bounds automatic fallbacks below premium tiers unless explicitly selected. Widget and memory stay on the cheap first rung with their own empty retry chains, including while ordinary fallbacks are off. Shared memory routing does not change its enabled/backend/retention/autolearn preferences.

Disposable browser and synthetic native proof do not establish live activation, native owner binding, credential migration, provider availability or production acceptance. Operational follow-through stays open at the owning issue until the authorized owner supplies and reviews native authority and exercises the deployed surface. No production action is part of this source cutover.

Integrated source and preview acceptance

The integrated source contains four Code bundles: container-CAS catalog/routing/account-choice/suggestion policy and the launcher/accounts/usage React surfaces. It imports the typed OMP caller package and has no machine manifest, broker, gateway, probe workers or runtime artifact pins. The shared headless workflow calls OMP's public owner-scoped actions through ordinary Manifold dispatch, rechecking Code composition, OMP defaults, destinations and native review pins before effects.

The 2026-09-13 source gate pinned Manifold c731aa2364531ec6cf14e6ffb13c3a806dff9f6b and OMP 19223eb4d08ad8aef70b31fb8ff9d716d91e597b. It passed 87 Code tests with 530 assertions, packed and verified all three OMP and four Code bundles, and drove two independent real browser identities. The browser proof covered shared state convergence, draft and navigation retention, first-use recovery, responsive and keyboard interaction, permission refusal and stale or cross-destination review fences.

The same revisions were then accepted on the preview through native actions. OMP's root, account and gateway deployments reached ready on dev-01 and the separately enrolled Code isolated destination. Both destinations validated a real workspace, produced a readable 11-model inventory from the complete saved account pool and opened account-backed OMP terminal sessions with output. The actual Code panel rendered the permitted online and offline destinations and, because no classifier service is configured, withheld rather than faked its suggestion control.

The shared OMP broker now has one runtime owner. Existing account identities, saved choices and legacy Code/Usage clients continued across the reviewed transfer and restart without reauthentication; a legacy client completed a fresh quota observation afterward. Run-scoped credentials and grants were revoked after each proof. Existing credential backups were retained, and no production deployment, backup disposal or personal-session mutation occurred.

See plugin development for the Bun 1.4.4 and pinned Code/OMP/Manifold gate, and configuration for the exact actions. Source retirement does not authorize moving or deleting existing user files, service state, credentials or backups.

Explicit availability boundaries

  • OMP's managed Bun, SDK and pi-natives pins do not themselves supply an owner's independently reviewed system or development closure. Missing artifacts, bindings, consent, scoped service access or connectivity stay unavailable; host PATH, ambient files and caches are not fallbacks.
  • The accounts owner alone reviews/configures broker runtime and places sign-in. Ordinary authorized users may read permitted account/usage observations without gaining setup authority. There is no owner discovery, failover or private Code credential form.
  • The gateway owner alone reviews/configures the destination service. Code's service actions bind only the optional external suggestion classifier. Neither path grants account authority or supplies credentials.
  • The first workbench derives a frozen local starter from OMP's passive bundled SDK model metadata after a successful absent or initialized-empty configuration read. The generator's rows and routing need no account or runtime setup. The starter is render-only: saving it is the model check the first Launch press runs (OMP inventory through the saved account pool, a charge the operator approves once per person, per-provider benchmarks, then the derived catalog staged, which keeps it as the person's check of that pool and budget, reviewed, promoted and saved with the selection), or the person's kept check of that pool, adopted without spending. Stored active policy wins and unrecorded historical provenance stays unknown. A saved tier that a list read at its models' named tiers would give another model is never given it on its own: reads answer the record as stored, listings name no selected model, and compositions and background adoptions refuse it with nothing written; the raw list, digest, provenance and kept check stay as stored, and the panel's rows let the person choose that profile again, its same word included, and Save it; Code then keeps privately which model that choice resolved to (no public field, input or migration), and no check is run or paid for again. Read-only native panels remain locally explorable, not writable. Disposable presentation/CAS proof is not native consent, configured accounts, provider execution, a release or authenticated preview acceptance.
  • Agent launch through Code reaches Manifold's real doors only up to launchRun. The gate's browser verifier presses the launch as a human sponsor with agents:delegate on its disposable server: Code registers its Agent and creates a Run, the machine (no native job owner) refuses launchRun, Code cancels the Run (listRunsV2 reads it cancelled), the same press goes on to the reviewed session, and from then on that machine's launches are the reviewed session with "no live dials: cannot launch agent runs". Sessions' Runs (activity, the lease to 24 of 24 and detached, the dials' pending, queued, confirmed, clamped, not served, unanswered and forbidden states, locked dials that send nothing, a queued change included, the thinking unknown once a TUI reports, a read served before a model report landing after its answer, a model switched in the TUI and a stale kept answer dropped) are rendered from fixtures shaped on that real Agent and Run. Each Run whose TUI opened carries the provider and id alone that OMP's harness reports once its TUI is up, and a synthetic controlRun reports its model switches to the fixture. No launched Run, renewal, activity or model report or controlRun answer has been exercised through Code or on any preview; those are proven end to end only by OMP's own native harness gate. The launch line after a launch ("Launched on … · dials", or "· no live dials: …" with Enable in Setup) needs an opened terminal, which the disposable server cannot open, so only unit tests cover it. A Run's model is its live Run.model, which follows the model its TUI session serves once the Run's harness confirms it (manifold#1078). The last controlRun answer this browser received is the one word on its thinking and bridges a dial until a read shows its model, so a read served before the session's report does not drop it. A Run this browser has not turned reads its level as ? from its TUI's first report, and a level changed in the TUI alone is not seen. A Run is attributed for at most about 13 leases. After that, or after a missed renewal, its TUI goes on detached and unattributed, with no dials.
  • Manifold validates an Agent's profile in OMP's isolate (registration, update and launchRun) only while that isolate serves nothing else, and refuses rather than waits (exclusive request requires a drained guest). Ordinary reads of OMP from open panels made two preview launches fail that way before Code asked such a door again. Code now retries those two refusals for about two seconds; unit tests prove the retry and its words against a scripted dispatch, and the disposable verifier's registrations pass the real validation, but no busy refusal is provoked there. Waiting instead of refusing would be Manifold's change.
  • The main view's presentation has these bounds. Cost is a relative list-price index, not billing, and the speed meter stays unlit and says "unmeasured" until every lead model has measured throughput. The usage pane reads again every five minutes (Code's own cadence, since the host's feeds read again only on events while their channel is live); it draws reported windows, balances and blocks, not reset credits, which appear in the manage view's readings. The accounts view only switches accounts; the pool, presets, sign-in and credential actions are in Manage accounts, which keeps the Code accounts panel's own controls. Spark is retired: models that draw a quota of their own are left off the ladder, a stored Spark flag reads as off and no control, route or usage bucket exists for it. A machine on which OMP is not installed is never a default destination and is refused in the machine list; where OMP answers is read for every online machine and says nothing about its permissions or accounts.
  • Pure catalog/preferences actions need no machine process or selected account. composeProbe and composeSession consume typed caller-supplied OMP observations but do not attest them; OMP rechecks concrete account slots before execution.
  • OMP workspace, inventory, benchmark and session preparation produce native reviews, jobs or terminal descriptors. Admission and placement are not successful OMP/provider execution; verify output, cancellation and reconnect before claiming them.
  • Code's headless client and web use the same ordinary dispatch workflow. Babel is a potential downstream consumer, not a Code dependency or acceptance shortcut; no old process ABI is retained.
  • Optional skills come only from OMP's authorized immutable catalog and native review. Code's workbench and headless workflow pass an ephemeral launch choice; they do not discover host paths, download third-party skills, grant source-job access or claim invocation. The disposable browser fixture has no sealed skill source jobs: its real catalog is empty. Real-browser scenarios cover clear/disable-all, refresh/navigation retention and destination/review invalidation. Separate synthetic metadata exercises set expansion, deduplication, conflicts and stale catalog revisions; it does not establish governed source admission or selected-skill execution.
  • Restricted automation source consumes OMP's shared schemas and supported tool subset, displays native effective review policy and carries it to preparation and one-shot posting. OMP's SDK registry is the enforcer, not a Code-side filter. Ordinary new sessions remain unchanged. Selected skills are instruction-only; restricted ambient discovery and OMP task/advisor suppression are not OS sandboxing; permitted bash retains subprocess authority.
  • Native fleet source reads bounded title/header metadata separately on each permitted machine, keeping not-requested, pending, failed, unavailable, empty and ready states distinct. Only an exact harness/machine/session correlation exposes a running terminal and its authoritative home. Legacy absence means unknown activity, not a stopped session or an inferred workspace.
  • Preserve-state resume and explicit current-profile model/thinking choices are separate. Both re-observe native metadata and public terminals; a newly observed running match reopens through the public terminal URI instead of creating a replacement. Profile choices describe the next resume, not live effective state.
  • Disposable real-browser scenarios exercise fleet metadata, authoritative reopening, independent machine failure/offline state, stale-response fencing, preserve-versus-explicit inputs and native refusals using synthetic RPC responses. They do not establish provider execution, governed consent or a qualified native dependency pin.
  • Separate packaged native proof covers 20 offline scenarios using the published CLI/SDK programs: fresh selected/disabled skills, authoritative project filters, sealed resource reads, restricted tools, native resume, explicit model/thinking precedence, missing/changed-state refusal and cancellation. Synthetic inference in isolated network namespaces is not paid-provider or live-fleet acceptance.
  • The earlier OMP 0.2.0 qualification used the published 18.8.6 credential graph with its retained patch; its ordinary CLI and independent unpatched SDK host also used 18.8.6. Native lifecycle accounting uses public SDK hooks and passes the retained deadline/quiescence regressions without copying credential algorithms. This does not qualify the separate unpatched credential migration in manifold-omp#72. Code's existing-Run tools and one-shot sessions were qualified against OMP f67e4f1 (manifold-omp#98, merged) and Manifold 0701320. The pinned worker build retains whitespace compaction without syntax or identifier minification. Its native gate passed with complete-family fingerprints matching local builds. This conservative configuration does not identify the original compiler cause; manifold-omp#94 retains that investigation. Matching bytes do not authorize replacing an enabled native declaration; downstream release verification and deployment review remain separate. OMP's one-shot run location uses temporary raw output directories; sealed transcripts remain readable, while workspace/session state and legacy directories are unchanged. Code retains its panel-free baseline web registration for the shared stylesheet and declares the portable Worker entry that the pinned SDK requires for hardened installation. The gate runs real Code-to-native tool and bounded-material proof against Code's current pins. Source and disposable verification do not establish a released Code bundle or deployed production capability, and no transition-ledger row advances. That baseline pinned Manifold 8260541 (manifold#1078), protocol 57, and OMP 0639a16 (manifold-omp#125, OMP 0.2.0), whose own MANIFOLD_REV is the same commit. A protocol 57 hub admits only bundles stamped 57 (manifold#1068), so Code's four bundles and OMP's three are rebuilt on that SDK and no earlier stamp is retained. That SDK stamps them hardened contract 13, which no hub older than 8260541 admits, so they need a hub at that commit or later. The Manifold pin lets a Run's own harness report the model its session serves, which the harness's resolveModel confirms before it replaces Run.model; it also budgets 1024 activity reports per lease and reports the adopted Run's expiry at bind. The OMP pin's TUI harness reports the model at ready and on every switch, and Code shows it as each Run's live model. The OMP pin also scopes accounts by custody of the broker's credential store (manifold-omp#121); the one scope change its adoption causes is described under Accounts and custody. Its gateway names a provider's definite refusal of a model, which a benchmark settles as not_found or client_blocked rather than unresolved (manifold-omp#122). Its native proof refuses unless the family it re-packs inside its unit reproduces the SHA256SUMS of the family under verification (manifold-omp#119); Code's verify:native names the sums of the OMP bundles its gate prepared and installed. That baseline's inventory receipt was its 18.8.6 one, and each row carried the SDK's quotaTier, which the derivation reads directly. Its bundled catalog was stamped with its separately pinned SDK's version, then also 18.8.6. No version string decides whether a verification holds: it records the artifact its inventory ran from and the bundled catalog's revision. An OMP update alone, another artifact or another catalog revision that still publishes every routed model, leaves it current and is noted in Models; it goes stale when a moved catalog no longer publishes a routed model, or the saved choices select another pool, with no Code rebuild. A verification recorded before these identities, without them, reads as unverified, so the next launch checks the models first, and a current one can be renewed on purpose. Unit tests prove the rule against a synthetic destination and catalog, and the disposable browser against the real bundled catalog: it moves a verified list's runtime artifact, then serves a synthetic republish of that catalog without the list's default lead. Applied to the preview workspace's live reads (destination pins, catalog revision and account pool), the rule gives current: only the runtime artifact moved. This source repin is not a release, preview installation, native deployment review or provider observation. The one-shot-only agentTools: { runId } selector carries existing native authority; it does not grant, infer or acknowledge it. Omission stays unbound. Read, follow and cancel preserve the exact retained Run correlation.
  • Portable captures/archive recovery, general live settings-origin inspection, live per-account quota preservation and Code-owned upstream fallback repair are not planned. Bounded Babel acceptance remains separate and unproven.

Domain and safety constraints

Catalogs and estimates

Code owns ladders and routing, not provider entitlement. Metadata, a reachable endpoint or an inventory entry does not prove model quality or callability. Unavailable, incompatible and inconclusive probes are distinct. Automatically assigned tiers require review; a timed request is a sample, not a sustained throughput guarantee. Costs and speeds remain estimates, and nullable facts must not be presented as measured values.

OMP/provider schemas can change. Runtime claims must name pinned versions and exercised behavior. Routing preserves role identity at the OMP overlay boundary; source-level intent alone does not prove all upstream child-session behavior.

Account health

Declared model quota buckets, provider-wide capacity and tier-specific windows are different signals. Missing usage is not health or entitlement; stale, disabled, exhausted and blocked accounts are not interchangeable. Code interprets authorized observations and shared choices without becoming a broker or a second account-health authority. Selected runtime pools must not broaden when a slot disappears or changes identity.

Native lifetime and privacy

Manifold owns grants, consent, resources, storage/migrations, native job/terminal lifetime and traces. OMP owns broker and gateway lifetime, sign-in, credential storage/refresh, permitted observations, workspace/probe/session operations and ordinary agent behavior. Code owns no credential or second account-health authority. Scoped access is not a claim that an authorized process cannot disclose data it can legitimately read; measure containment and refuse unavailable requirements.

Native lifetime must protect live work, uncommitted changes, child processes and retained sessions. A missing workspace is not permission to recreate, prune or erase it. Do not mine OMP transcript bodies or retain Code's former runtime registry. Data adoption, broker custody and backup disposal are separate, explicitly bounded operations.

Promotion remains separate

Code product promotion and native OMP review are separate. Changed Code revision/composition, OMP defaults, destination, installation, binding, service policy or caller authority refuses stale use at its owning boundary. Building, merging or publishing authorizes neither installation, credential movement, broker transfer nor destructive data changes. Tags and release bytes remain immutable. Operational evidence must identify the installed Manifold, OMP and Code revisions, hub/surface, action, observed result and remaining boundary.