OneRingAI Version 2 Guide

Published beta — 2026-11-02: oneringai@2.0.0-beta.1 is published under aantich, from source tag v2.0.0-beta.1 at 318c84b. Both latest and next select this first beta. Registry integrity matches the validated artifact; a fresh registry install passes all eleven public entries in ESM/CJS and nine document formats. See the publication evidence. Stable release and pending live/provider/platform gates remain separate.

Website documentation handoff — 2026-11-02: Standalone usage guides and the User Guide installation section now identify the verified published beta rather than their earlier branch-only status. Historical stage records below retain their dates and validation scope; this documentation correction does not rerun live provider gates or announce another package version.

Documentation/release review — 2026-11-02: The README is rewritten for v2, and the complete User Guide is reviewed and reorganized. Use those documents for current integration, the v2 changelog for a consolidated feature/upgrade summary, and Release readiness for validation and the corrected routine prompts, consumer dependency assessment, and final validation. Historical counts and availability statements below retain their delivery dates. Hosea's subsequent revival now passes its full desktop typecheck; the older 24-diagnostic statement below is historical. The subsequent beta publication is recorded above; stable-version selection remains separate.

Repository handoff — 2026-11-02: v2 was committed and merged into main at 9c18dfa, and that revision was pushed to GitHub. main is now the canonical v2 development line; version1 remains the legacy maintenance line. This source promotion does not announce an npm release. Older stage records below retain their original branch names and uncommitted-at-validation statements as history.

Package identity — 2026-11-01: The user explicitly selected the unscoped npm name oneringai for v2 and retained this repository. The branch prepares 2.0.0-beta.1; v1 remains published as @everworker/oneringai. This authorized package-name change requires explicit dependency/import migration; it does not change runtime defaults, public subpaths or saved session formats. See Package migration and Licensing.

AMOS and Hosea source are now MIT licensed under Anton Antic with contact anton.antich@gmail.com. The owner explicitly authorized incorporating the previously separate React UI source into Hosea under MIT. Its external package dependency and commercial-license startup gate are removed. Both applications build. Subsequent Hosea revival work also passes its complete desktop typecheck and provides the local design preview; installer/platform release gates remain separate. The package migration and release-readiness guides record clean-consumer, compatibility, examples and offline test results. This does not establish signed desktop distribution or additional provider live support.

This is the living, user-facing guide to OneRingAI's Version 2 initiative. It explains what each delivered stage enables, how to adopt it, and what must reach the standard documentation before release. Read the architecture roadmap for implementation scope, dependencies, research, and acceptance criteria.

• Status: Core stages, Stage 16A, Stage 14A and consumer slices C1–C9-C and agent-harness H0–H6 are implemented on branch. The user separately authorized bounded Codex/OpenAI validation on 2026-11-01; other new native/provider live gates remain pending. The latest consumer review corrections track the preceding corrective validation; earlier totals and live-pause statements below are historical. Publication remains separate; this bounded run is not standing authorization for additional live suites.
• Stage 03 review: All findings fixed and validated: 7,473 units / 245 Stage 03 cases, 66 live cases / 78 scenarios and 15 offline examples pass. See the third corrective completion.
• Stage 06 review: All findings corrected and validated: 7,228 units and 48 live cases/60 scenarios pass. See the latest completion.
• Created / last updated: 2026-10-07 / 2026-11-02.
• Current selected scope: Agent-harness revision 3 H0–H6 is sequentially authorized; see the delivery ledger. The preceding full consumer-hardening sequence C2–C8 and C9-A/B/C is authorized, in order with review/fixes after each slice. C1 is complete. The delivery ledger records current availability; each slice must pass its own gates. Existing APIs/defaults stay unchanged; no consumer upgrade or release is included.
• Repository package version at creation: 1.2.0.
• Implemented stages: 00 — evaluation and compatibility baselines; 01 — fresh request accounting and safe compaction; 02 — tool outcomes and per-execution cancellation; 03 — durable evidence, scoped retrieval and opt-in projections; 04 — protected host task state, explicit receipts and separate workflow confirmations; 05 — selective data contributions, bounded dispatch refresh and cache-aware layout/diagnostics; 06 — explicit helper roles and process-local model tasks/budgets; 07 — experimental observation masking and source-backed historical summaries, including review corrections; 10 — bounded managed-loop recovery and host-owned completion checks; 12 — opt-in presets, resolved capability inspection and AMOS adoption; 14A — optional managed model routing; 16A — opt-in provider-native compaction composed with context plugins, including all review corrections.
• Version 2 release: 2.0.0-beta.1 published and registry-install verified on 2026-11-02; stable 2.0.0 remains pending.

“Version 2” includes the prepared unscoped package and the recorded development initiative. Implemented capabilities at source revision 318c84b are included in the verified npm beta. Historical stage labels below describe their availability at delivery time; inclusion in a beta does not complete pending live/provider gates. Additional breaking changes and stable publication require separate decisions.

Reading this guide

For an integration today, use the README, User Guide, public API reference, and runnable examples. This guide adds the evolving adoption story; those documents remain the reference for existing APIs.

Each new capability will have one of these availability labels:

Stage completion and package release are separate. Do not turn “available on branch” into “released” until the package version and release have been verified. Existing foundation APIs below are not new Version 2 features.

What Version 2 aims to improve

Long tasks should keep their constraints, retain useful evidence, and finish with results the host can verify. Applications should be able to use an evaluated, inexpensive model for a bounded helper task while retaining their chosen main model. These improvements should be easy to configure and inspect, with clear limits on cost, recovery, persistence, and provider support.

The first delivery path has nine core stages: 00 → 01 → 02 → 06 → 03 → 07 → 04 → 10 → 12. Stage IDs are stable identifiers; they are not a requirement to implement every intervening number. Conditional extensions do not block the core path.

No cost reduction or quality improvement is promised before the relevant workload has been evaluated. Fewer prompt tokens can still lead to more calls, repeated searches, or worse results; comparisons must include the whole task.

The foundation you continue to use

Version 2 builds on the current integration model:

• Create named Connector instances for provider credentials and external accounts. Provider connectors declare an explicit Vendor; model names do not determine authentication or vendor identity.
• Use Agent.create() with run() or stream() for managed context and tools. Use runDirect() or streamDirect() deliberately when a direct call is appropriate.
• Add context capabilities through plugins. The agent and context share one ToolManager: agent.tools === agent.context.tools.
• Use the model registries for capabilities and limits. The host supplies trusted user, tenant, group, connector, and account scope.
• Continue using MemorySystem for long-term entity/fact knowledge and its existing ingestion and permission model. Execution observations do not automatically become permanent facts.
• Save and load managed context when needed, and destroy disposable agents, plugins, and clients during teardown.

Start with the basic agent example. For external accounts and tool sources, use the Connector & Tool Catalog. For long-term knowledge, use the Memory Guide and Memory Permissions. For interchangeable agent harnesses, use the Agent Runtime guide and local runtime example.

Provider-hosted tools and external SDK agent harnesses have their own execution boundaries. A control supported by OneRingAI's local loop must not be presented as available in every runtime driver. Each delivered feature will state which paths and drivers support it.

Evaluate a change against the current behavior

Availability: Available on branch — stage 00. Validated on 2026-10-07 in the version2 working tree based on 43b34cd; the stage changes are uncommitted and no package release is claimed.

Stage 00 delivers a small repository evaluator, not a new production API. It runs four workloads through the existing managed Agent loop: chat, a large tool observation, research with retained source IDs, and an external-workflow simulation with host cancellation, checkpointing, and continuation in a fresh agent. Completion requires the requested answer and actual tool evidence where relevant.

From a checkout with development dependencies installed:

npm run example:agentic-baseline
npm run example:agentic-baseline -- --held-out
npm run build
npm run test:agentic:compat

Offline runs need no keys and use strict replay: changed tool arguments or results cannot receive a future response from the original branch. Both splits should report four passing workloads, correlated runs/steps, call counts, and usage availability. Offline usage is synthetic; durations may vary. See the evaluation guide for the fixture contract, completion gates, extension steps, and separately opt-in live commands using named provider connectors and .env credentials.

Existing integrations need no changes. Public signatures, defaults, algorithmic compaction, tool result shapes, and shared tool ownership are unchanged. A consumer compile fixture checks built-package imports, and a pinned synthetic format-v1 session checks restoration and round-tripping. Reports collect metadata rather than prompts, credentials, arguments, results, or provider errors. Unknown usage stays unknown; this does not change existing application logging.

The recorded live pilot combines 24 passing OpenAI/Anthropic/Google workload/split runs using gpt-4o-mini, claude-haiku-4-5-20251001, and gemini-2.5-flash. Anthropic passed after the user provided a workspace-scoped key. The two validation batches have separate timestamps; earlier failed configuration/model attempts are recorded separately. The pilot has one sample per model/workload/split and makes no comparative quality or savings claim. It observes managed non-streaming events; complete helper/retry accounting and model routing remain future work. The small held-out marker/identifier variants are a plumbing check, not an independently representative benchmark.

The workflow demonstration uses local mock tools and an explicit host transition. It preserves pending input alongside committed context; it does not supply a durable effect ledger or guarantee that cancellation stops an in-flight request. Consumers can keep existing behavior by not running the evaluator. Evaluator-owned agents, listeners, and connectors are cleaned up; caller-owned connectors remain. Existing AMOS inspection commands are tested without adding an app feature.

Better continuity during long tasks

Availability: Stage 01 available on branch; Stage 03 available on branch; Stage 07 available on branch, experimental; review corrections validated.

Stage 01 rebuilds the working-memory index, plugin instructions, catalog schemas, and token estimates after compaction. Its budget counts the sanitized request, including visible dynamic definitions and separate instructions. Both managed run() and stream() use the selected snapshot and check hook-modified requests before dispatch. The corrective pass also covers synchronous request listeners, actual dispatch-model capacity, structured formatting/repair and replay signatures. The second corrective pass brings known schemas/native tools and initial provider capacity into the compaction decision, counts function-result errors, and prevents separate spills from overwriting existing keys, including after saved-state restore.

Existing agents need no configuration changes. The default critical trigger remains 90% and algorithmic compaction remains the default. Preparation invokes a strategy at most once; protected current input, its tool dependencies, and outstanding native async calls remain intact. A request that still cannot fit fails clearly. Duplicate final results are reported as invalid tool protocol; supported asynchronous text updates remain available. Legacy plugin and strategy interfaces and session format are preserved.

Inspect agent.context.lastPreparation for its revision, selection timestamp, and estimated budget. AMOS /context budget and /context breakdown label that revision and distinguish estimates from provider usage. The breakdown includes overhead. An inspection does not select another request or trigger compaction.

Run npm run example:context-freshness, npm run example:context-budget, and npm run example:amos-context after building for offline demonstrations. See context preparation for the additive low-level options, fit errors, race handling, estimate limitations, and legacy side-effect boundaries. Live checks require actual evidence retrieval, not only successful provider responses; their record covers OpenAI, Anthropic, and Google through both managed paths.

Stage 03 implements large-tool projections. Stage 07 adds opt-in experimental observation masking and structured summaries. Its initial functional gate and all three review corrections pass:

• Observation masking: Keep a useful preview or projection of a large tool result in the prompt, with a reference to its retained source where available.
• Structured summaries: Carry forward task-relevant findings, source references, unresolved questions, and constraints through a bounded helper-model operation.

Algorithmic compaction remains the compatibility baseline. Selecting a new strategy must state its helper-model needs, failure behavior, and retention guarantees. Schema validation and valid references do not establish that a generated summary is semantically accurate; examples and evaluations must show what happens when a summary omits or misstates information.

A smaller active prompt and retained evidence serve different purposes. Evidence references state whether they survive only within a process or across a restart, which backend acknowledges storage, and when records expire or are deleted. Existing nonblocking history logging alone is not an acknowledgment guarantee. Applications must be able to inspect the original result rather than receive only the model-facing projection.

Stage 03's evidence recipe documents acknowledgement, retention, bounded retrieval, missing/expired/corrupt references, host recovery, save/load, cleanup and AMOS views. Its offline example verifies exact recovery in a separate Node process. Stage 07 adds automatic strategies and a bounded functional comparison; see Context Strategies. Statistical quality promotion remains future work.

Reliable tool outcomes and cancellation

Availability: Stage 02 available on branch; Stage 03 durable evidence available on branch.

Applications need to distinguish a successful action from a tool execution that returned a normalized error. Stage 02 makes those outcomes inspectable in the execution pipeline while preserving existing raw result shapes and public behavior wherever possible. An arbitrary application payload containing success: false must not automatically be reinterpreted as a library execution failure.

Cancellation belongs to the individual execution. A timeout does not prove that an external operation stopped, and an accepted asynchronous request does not prove that the requested workflow completed. Unknown outcomes, particularly writes, need an explicit recovery or reconciliation path. Late results must stay attached to the original execution and must not double-count usage or outcomes.

An evidence-storage or projection failure must not turn a completed external action into a failed action, or cause that action to run again just to recreate its evidence. Durable replay and effect reconciliation are separately scoped conditional work in stage 11.

Adopt now: agent.tools.executeWithOutcome() returns { result, outcome }; execute() retains raw returns and the existing extension point. Optional execution options supply signals, deadlines, call/run IDs, and a host observer. Results, stream events, and managed errors expose optional outcome metadata. The existing ToolContext.signal reaches cooperative calls; host/account bindings are captured per invocation. Async acceptance placeholders no longer count as completed work.

Connector defaults remain header timeouts and legacy retries. Opt in to timeoutScope: 'operation' and retryPolicy: 'safe' where appropriate. A timeout is local uncertainty, not evidence that an external write was prevented. See the complete recipe for public signatures, raw-result compatibility, cleanup, persistence, extension and provider boundaries.

After building, run npm run example:tool-outcomes and npm run example:amos-tool-outcomes for offline demonstrations. OpenAI and Google live validation and the initial Anthropic revalidation remain historical. The named-tool correction described below passes all three providers: 34 live test cases / 46 scenarios, with no failures or skips. See final validation. No skipped provider is counted as passing. Earlier live scenarios had two initial completion failures that passed unchanged targeted reruns; both attempts remain in the validation evidence.

A main model with bounded helper models

Availability: Available on branch — stage 06. Validated on 2026-10-13 in the version2 working tree based on dcc8dad; changes are uncommitted and no package release is claimed.

Optional modelExecution.helpers configures stateless compactor, extractor and verifier roles through named connectors. invokeHelper() accepts an explicit text packet or a builder invoked after model/capability resolution, plus a host JSON schema. Helpers have no tools, history or opaque provider state. The main model and shared ToolManager remain fixed. Defaults are 512 output tokens and at most one locally validated repair; escalation requires an explicit host decision.

Share a host-owned ModelTask through { modelTask } for managed/direct calls, helpers and explicit rollover. It reserves call/token/deadline and model token-cost capacity across concurrent in-process calls, counts physical SDK retries and logical repair/wrap-up invocations, and reports known usage once with explicit unknowns. Reservations use full provider capacity, so a small prompt can still need a large temporary allowance. Cost bounds apply to model tokens under known upper rates; external fees and external-runtime admission remain host-owned.

A configured compactor is used by explicit rolloverContext() between executions. Cross-connector history transfer requires allowContextTransfer: true. Algorithmic remains the automatic default; selecting a Stage 07 structured strategy explicitly uses the role during bounded pre-call preparation. Its comparison is a functional pilot, not proof of general quality preservation or cost savings. No helper is invoked by merely configuring a role.

The complete recipe covers public options, defaults, unknown pricing, scope, failures, cancellation, persistence and support boundaries. Run npm run example:purpose-models and npm run example:shared-budget after building for offline demonstrations. The purpose example's explicit -- --live mode uses gpt-4.1 plus gpt-4o-mini and .env OpenAI credentials; small marker checks make no comparative quality/cost claim. AMOS adds /helpers role selection, explicit calls/rollover and purpose usage, plus an offline command walkthrough.

Task state that survives compaction

Availability: Stage 04 complete on branch; both reviews' findings fixed and validated.

All four original runtime findings are fixed and validated. The second corrective completion also restores legacy resolved-feature values and external registry configuration. Fresh validation passes 7,795 units, unchanged root/types consumers, public ESM/CJS controls and both task-state examples. Live contexts retain their defaults; constructed legacy feature values can omit later optional additions. Generic plugin configuration accepts external records; use TaskStatePluginConfig for strict built-in declarations. Earlier corrective validation remains historical evidence of 7,784 units, 117 live cases / 129 scenarios in one batch and 19 offline examples. No new billable provider run was needed for the second pass's type-contract fixes; the earlier live results remain historical.

The opt-in context.features.taskState enables a host-selected TaskStatePluginNextGen (plugins.taskState supplies scope/task/optional association). Revision-checked host APIs preserve objective, constraint/correction, decision, question and artifact records with sources. propose/assume remain unconfirmed and cannot supersede host state. There are no model-facing mutation/store tools.

Explicit recordAction stores a ToolManager execution receipt independently of confirmAction, the host workflow confirmation. Succeeded/settled submission can remain waiting_external; unknown timeout never proves whether a write happened. Recording is host-driven, with no implicit action subscription/replay. A failed notebook admission never authorizes repeating an action.

The full bounded view is noncompactable, counted in managed requests, and checked after hooks/listeners, including JSON repair. Version-1 optional plugin snapshots preflight scope/task/association/binding before replacing history. Legacy snapshots clear the enabled view. Existing Task/routine statuses are reused; MemorySystem remains the lifecycle authority for linked memory tasks, refreshed explicitly with host permissions. Direct calls bypass the view.

Defaults: disabled; 100 notes/actions, 8,000 estimated content tokens, 256 KiB strict JSON. No automatic eviction/extraction or semantic truth/model-obedience guarantee. Hosts explicitly resolve/prune; snapshots are trusted host checkpoints, not signed authority imports. Complete recipe, offline workflow and AMOS /context task document source/uncertainty, recovery, capacities and support limits.

Bounded recovery and verifiable completion

Availability: Stage 10 complete on version2, base d8fce94; both review passes fixed and validated. No verified package release.

The second review/fix resolves the recorded Google empty-summary failure by validating content inside the existing helper repair allowance, and rejects completion/progress verdicts after tool principal/account/identity/role/session or connector-scope rebinding. Optional HelperCallOptions.validationSchema adds local constraints without changing the portable native format or weakening schema; no additional repair loop. Real Google recovery is tested by deliberately injecting the exact recorded bad body after a real call, then requiring a real repair and exact source/constraints without masking fallback. This replaces reliance on a passing rerun alone.

The corrective completion and validation cover async outcome/effect preservation, stopped connected history and class callbacks. Normal run and explicit continuation share observation import; uncertainty and failure limits preempt receiving dispatch/checks. Admitted effect remains attached to authentic delivery across re-registration, including optional outcome omission. Legacy uncorrelated deliveries use receipt effect or unknown, never current tool metadata. Scope is rechecked after awaited imported progress callbacks.

Normal policy stops commit settled input without another model response or duplicate journal entries. Stopped-turn JSON formatting appends a separate final answer; exact calls/arguments/results survive new input, file resume and host evidence repair. Class/prototype callbacks retain the original receiver/private state; callbacks/options are captured per execution. These are internal corrections, with no new required public/session/storage members or restored async authority.

Set AgentConfig.loopPolicy or a per-execution RunOptions.loopPolicy to enable bounded managed run/stream recovery. A per-call null disables the configured policy. Omission preserves existing chat prompts, hooks, events and stopping behavior. No workflow verifier is mandatory, and the main model stays fixed.

Recovery defaults to two shared interventions for actual tool failures, repeated normalized read observations, optional unchanged host progress keys and unmet completion predicates. Repeated admitted writes/unknown effects stop before identical replay in that execution. Unknown action completion requires host inspection. Declared repeatable reads support intentional polling; existing iteration, permission, tool deadline and ModelTask limits still apply. The policy does not provide durable or semantic exactly-once execution.

Host completion(context) checks actual scoped evidence/state and returns {complete, reason?, feedback?}. A successful response, accepted submission or model claim alone is insufficient. Optional response.loop, metadata on existing iteration/complete stream events and agent.getLoopDiagnostics() report phase, recovery, stopping reason and existing task status separately from provider status. An unchecked answer reports answer_returned without a workflow completion status. Public root and /types exports include the six AgentLoop* policy/check/result/ diagnostic/observation/reason types.

Callback packets are frozen detached data: bounded candidate text, last-100 actual observation metadata, explicit truncation counts/flags, optional full built-in task state and cancellation signal. Deadlines, local result validation, task generation/owner/plugin/conversation checks prevent late/stale confirmation. Callbacks are cooperative host reads, not an automatic model verifier or effect executor. Explicit helper checks must pass the same explicit ModelTask to share budget. Callback exceptions/timeouts stop with sanitized diagnostics.

Callbacks/counters are process-local and never restored as session authority. Fresh agents need an explicitly configured policy; same-agent load retains live host configuration/latest diagnostics. Existing task/evidence persistence remains available. Async/suspended work reports waiting-external without inventing remote completion. Direct, realtime, remote-native and external SDK-owned internal steps remain outside this managed text policy.

Configured streaming uses shared before:tool skip/argument preparation; unconfigured streaming retains its legacy hook trace. Stream chunks remain provisional, including rejected candidates. JSON final repair remains run-only, with the checker seeing the repaired final candidate. No existing event discriminant, provider status, required session field or default was changed.

Build first and run npm run example:feedback-agent, npm run example:loop-equivalence, or npm run example:amos-loop offline. AMOS supports optional JSON thresholds, an idle host-only policy setter and /context loop; phase/reason/recovery/completion notices render separately from assistant prose. Missing evidence reports input needed without a fabricated approval request. Read Loop Policies for exact bounds, failure/persistence/support behavior and setup. The implementation record and validation preserve final and initial results. Live probes use synthetic local reads and establish functional wiring, not general quality/cost improvements or deterministic model adherence.

Easier configuration and capability inspection

Availability: Complete on branch, including all review corrections. No verified package release. See the latest corrective completion.

Public createAgentPreset('research' | 'workflow', config) returns ordinary AgentConfig with no IO or model calls. Research selects observation masking and 12 iterations; workflow selects algorithmic compaction, protected task state and 8 iterations. Both enable evidence and bounded recovery. Plain Agent keeps its existing defaults. Helpers, task budgets, permissions and completion predicates remain explicit host choices.

Require explicit matching evidence scope/backend/userId and workflow taskId/scope. Existing settings override defaults; false disables features and null disables loopPolicy. Undefined feature entries are absent. A disabled evidence flag also requires a compatible strategy. Registered custom strategies/plugins remain host extensions; the factory does not instantiate them. Unknown/unavailable features and scope/dependency conflicts fail before Agent creation.

agent.inspectCapabilities() reports current managed plugins/features/strategy, provider capabilities and registry agreement, helper configuration, evidence durability and default loop/completion-check presence without private content or model/storage calls. Custom-provider capability reports must be cloneable metadata; class data is detached and invalid reports propagate inspection errors. It does not prove authentication, semantic quality or workflow completion, nor replace task-usage/permission inspection. Per-call overrides, direct/realtime/external SDK execution retain their existing boundaries; use RuntimeAgent.inspect for drivers. Selecting masking/summary does not enable native compaction or native tool search. No coding/adaptive/conditional preset is supplied.

Portable hydration's existing trusted agentConfig now additively accepts loopPolicy and modelExecution. They remain excluded from serialized runtime configuration; no wire/session protocol changes. Hosts reconstruct policy through contextFactory/agentConfig. Legacy unscoped state can adopt a receiving-host preset; foreign scoped evidence/task checkpoints reject restoration and are never rebound.

AMOS /preset (/profile) selects and persists next-agent policy after preflight. /session new applies it. /preset inspect distinguishes active and saved choices; save failure restores the previous value/property absence without changing the live Agent/history. Invalid next-agent initialization also preserves the active runner. Existing explicit settings and optional maxIterations override defaults; missing/null preset preserves legacy behavior. Off removes preset defaults, not existing explicit features. Explicit session saves record descriptive agenticPreset metadata; loading it never restores authority. AMOS supplies no automatic host completion checker.

Read the recipe, delivery record, runnable preset example and AMOS walkthrough. Offline modes require no keys; test:presets:live is separately opt-in and billable. Stage 07's bounded comparison remains the quality evidence; preset assembly makes no new quality or cost claim. A package release remains unverified.

Provider-native compaction — Stage 16A

Availability: complete on branch, opt-in; all review corrections validated; package release unverified. See the latest completion. Revision 2 was approved on 2026-10-22. The native recipe documents the built public API; the approved design and validation record retain scope and evidence.

context: {
  model,
  features: { evidence: true },
  compactionStrategy: new ContextCompactionStrategy({
    plugins: 'auto',
    history: 'native',
  }),
}
// Between executions, optional manual scheduling:
await agent.compactContext({ target: 'history' });

Import the class from the public package. Both controls are required; automatic scheduling defaults to true and native history keeps two recent completed user turns exact. The four auto/off and native/off combinations work independently. Plugin reduction does not enable/disable plugin features or tools. Under pressure, eligible plugins reduce once, the full frame is rebuilt/count-checked, and native history runs only if still needed. Manual targets are all (default), plugins and history; automatic: false retains explicit operations. Plugin-only mode needs no native adapter/evidence. Existing strategy instances/names/defaults and custom plugin/storage/strategy contracts remain supported; no replacement context configuration or migration is required.

OpenAI standalone and Anthropic on-demand adapters use the main connector/model, whole-window provider counting, faithful scoped archival and shared ModelTask compactor accounting. Verified live models are gpt-6-astra and claude-sonnet-4-6. A configured local helper remains a separate summary choice. Native source/history operations preserve canonical provider messages/opaque or signed blocks, protected recent/current input, pending dependencies, fresh plugin contributions and host task state. Older user/settled action exchanges can leave the active prompt; exact source archival does not guarantee model recall.

Reports distinguish plugin/history outcomes, before/after counts, provider/local accounting, source references, invocation IDs and checkpoint acknowledgement. lastPreparation.compactionDetails and capability inspection expose detached optional diagnostics. budget.providerCountedInputTokens is capacity provenance, not usage; existing component estimates remain local. Discarded/billed and late native usage remain visible. Missing counters stay unknown. OpenAI native compact cannot honor a hard per-call output cap; read the recipe before imposing limits.

Optional version-1 continuation metadata binds model, connector/endpoint, host account/principal and evidence scope. File-backed source/session storage and separate-process run/stream recovery are verified. Incompatible switches reject; use trusted pre-native checkpoint or explicit fresh-context recovery. Archival or count/native failures preserve history; prior plugin reductions can remain. A failed post-commit checkpoint reports committed state instead of repeating actions. Existing sessions remain loadable. Native retained metadata/source quotas and backend retention still apply.

AMOS supports /context policy, /context compact and per-phase inspection, independent persisted controls and provider-counted capacity displays. Five runnable examples cover targets, restart/recovery, four-policy comparison, the actual AMOS adapter and preservation through beforeCompaction memory writes. They default offline and provide bounded opt-in live modes where relevant.

Latest validation: 8,507 units / 377 files; 199 live tests / 12 suites across three providers; nine native cases; 33 offline programs; 158 ESM/CJS public controls. Build, types, lint, strict core/AMOS, generated docs and 171 focused cases pass. The original bounded four-policy live pilot remains functional historical evidence, not a general quality/cost ranking. Server-owned/in-request automatic, broader request/ runtime shapes and Stage 16B remain deferred. No further stage is authorized.

Conditional extensions

These are optional tracks. Stages 05 and 16A, including all review corrections, are complete on branch. See the latest Stage 16A completion. Other entries remain Conditional / deferred. Existing memory, tool catalogs, orchestration, asynchronous tools, and provider options remain usable; the entries below describe enhancements to those foundations.

New sections and runnable recipes belong here only when a conditional scope is selected. Research evidence for a technique does not establish its availability or effectiveness in OneRingAI.

Compatibility and adoption

Existing supported APIs and defaults are the starting point. New configuration should be optional, new behavior opt-in where it changes semantics, and existing custom plugins, tool results, event consumers, settings, and saved sessions should continue to work. Correctness fixes still need their behavior and compatibility effects documented.

Disabled new features must contribute no prompt content, tools, helper calls, or background activity attributable to those features. This does not disable or change existing default plugins. Provider and runtime support must be stated per feature; selecting a preset does not make an unsupported capability available.

For each available stage, this guide will explain how to keep the existing setup, enable the new capability, verify it, and disable or roll it back. If persistence changes, document old-snapshot loading, any optional migration, backend requirements, retention, and cleanup before recommending adoption.

No breaking API change is approved. A concrete breaking proposal requires stopping the affected work, explaining the reason, affected API/behavior, alternatives and migration, and obtaining the user's explicit approval before implementation. The Version 2 label, roadmap acceptance, and stage authorization do not provide that approval.

Stage availability register

Update this register when a stage starts, passes its completion gate, or appears in a verified release. The roadmap owns execution details and dependencies; this table owns the reader-facing availability record. Replace each dash with an actual revision, version, or link only when that evidence exists.

An internal stage such as baseline evaluation may have no new consumer API. Record that explicitly, together with any visible diagnostic or example benefit; do not invent an API to fill the table.

Delivered-stage adoption record

Append one record per delivered stage or separately delivered conditional scope. Update the relevant capability section above to describe actual behavior. Until a public signature and example are verified, keep them as pending entries rather than copyable speculative code.

Stage and delivered scope:
Availability; first validated revision; first published package version:
User problem and resulting behavior:
How an existing application adopts or keeps its current behavior:
Verified public exports, signatures, options, and defaults:
Minimal runnable recipe or tested example link and exact command:
Required setup; offline versus opt-in live behavior; expected output:
Supported providers, models/capabilities, drivers, and execution paths:
Unsupported configurations and preflight diagnostics:
Host permissions and account/tenant scope:
Usage, budgets, helper calls, and unknown/external costs:
Persistence, retention, old-session compatibility, and cleanup:
Failure, cancellation, retry, fallback, and recovery behavior:
Known limitations and rollback/disable steps:
Tests and evaluations supporting the claims:
AMOS walkthrough and help links, or why no app change applies:
Canonical-document handoff rows and their current status:
Deferred extensions that this delivery does not include:

The record is a user-adoption checklist. Keep implementation decisions and raw validation logs in the roadmap's stage record, linking them where useful.

Stage 00 adoption record — 2026-10-07

• Delivered scope and availability: Repository-only evaluator and compatibility fixtures; available on version2 in the validated working tree based on 43b34cd. No first published version or new public export. Existing applications retain their configuration and behavior.
• Recipe and setup: The two offline commands above require a source checkout and development dependencies; expected result is four passing workloads per split. Live modes require explicit named provider/model selection and the matching credential, and make billable calls. No external job/service is contacted by the mock workflow. The host owns connector and tool scope.
• Support and accounting: Managed, non-streaming Agent execution. The observed pilot covers OpenAI/Anthropic/Google; Anthropic uses a workspace-scoped key. Fixtures limit iterations, tool calls, execution time, and output tokens, with thinking disabled and a model-specific explicit Gemini setting. Recorded usage covers emitted calls; unknown prices, provider-internal retries, external fees, and helper/hosted work are not a complete task cost. No hard monetary ceiling is claimed.
• Persistence, failure, and cleanup: Pinned old-session loading and round-trip checks; explicit pending-input checkpoint for the cancelled mock workflow. False completion, changed replay branches, missing usage, correlation errors, aborts, and cleanup are tested. Failed runs exit unsuccessfully; there is no automatic effect retry/reconciliation policy. Running the evaluator is optional.
• Evidence: 33 new tests pass; full unit suite 6,775/6,775 across 320 files; evaluator-helper coverage 99.43% lines and 94.81% branches. Build/type/lint, public-consumer compile, examples, and ESM/CJS smoke checks pass. The live pilot has 24 passing runs with 49 model and 30 tool calls; 19 existing OpenAI and 11 existing Anthropic integration tests also pass. Anthropic's legacy test model was refreshed to available Sonnet 4.6 without changing assertions or production code. These are compatibility/plumbing findings, not a powered quality comparison. Detailed commands and limits are in the roadmap record.
• AMOS and handoff: Current context help/overview/statistics behavior has regression tests. No app update applies to repository-only evaluation. README discovery, User Guide recipe, examples index, agent instructions, Changelog, and packaged evaluation documentation are synced below. API regeneration and specialist guide updates are not applicable because production contracts are unchanged.
• Deferred: All production correctness, context, helper-model, outcome, recovery, and preset stages remained planned at Stage 00 closeout. Stage 01 was subsequently authorized; its delivery record follows.

Stage 01 adoption record — 2026-10-07

• Delivered scope and availability: Fresh final request accounting, bounded compaction, protected protocol groups, and prepared-revision diagnostics. Available on version2, base 43b34cd, in the validated uncommitted working tree; no published package version is claimed. Existing managed agents adopt the correctness fixes without changing configuration. Strategies, features, plugin interfaces, shared tool manager, hook semantics, and session format remain.
• Public surface and recipe: Additive exported ContextPrepareOptions and ContextPreparation, optional PreparedContext.tools, agent.context.lastPreparation, and validateRequestBudget() for adapters. Existing no-argument prepare() remains supported. The preparation guide documents exact signatures, critical/reclaim behavior, adapter integration, supported async protocol, and limits. After npm run build, run npm run example:context-freshness; it shows the new source index, retained pending call/result, and fitting estimated budget. This source-checkout example requires no credentials or model calls.
• Support and scope: Managed run() and stream() and their tool-free wrap-ups. Live checks pass on OpenAI gpt-4o-mini, Anthropic claude-haiku-4-5-20251001, and Google gemini-2.5-flash; this is tested scope, not a claim that every provider/native-tool configuration was exercised. Direct APIs retain their existing context policy. Host connector identity/tenant scope remains host-owned; no additional permissions or storage backend are required.
• Estimates and failure behavior: Counts describe the last selected request revision, using the existing estimator. They include rendered contributions, actual visible schemas, sanitized history, pending input, and separate instructions, and remain distinct from provider usage. Preparation invokes its compaction strategy at most once and then either returns a fitting estimate or reports overflow. Protected dependencies cannot be reclaimed; duplicate final results/call IDs within one namespace report invalid protocol. Native async calls and library completion messages remain supported. Rendering churn and stale index proposals fail with clear retry errors. Arbitrary plugin/backend side effects are not rolled back. Remote file contents and hidden provider state are outside the local estimate. Existing emergency tool-text truncation and oversized-user rejection remain; no valid current input is truncated merely to reach a reclaim target.
• Persistence and inspection: No session migration or new durable format. Revisions are process-local diagnostics and reset with a new context. lastPreparation returns a detached snapshot; later mutation or consolidation does not relabel it as current mutable state. Legacy cached budget APIs remain. Disposable agents and contexts still require destroy().
• AMOS: /context budget and /context breakdown show either the initial estimate or the last prepared revision, explicitly label estimates, and include overhead in totals. Inspection does not prepare or compact again. Run npm run example:amos-context for the actual offline command rendering; see the transcript and AMOS guide. Existing overview and subcommands remain.
• Evidence and limits: 50 new unit regressions pass; full suite 6,825 tests / 324 files passes. Scoped coverage passes at 86.92% lines, including 100% lines for protocol grouping and AMOS inspection. Build, types, lint, examples, unchanged public-consumer/session compatibility, and AMOS checks pass. The final six real-provider retrieval checks plus a new 24-scenario Stage 00 live regression pass: 30 scenarios / 61 observed managed model calls in the two retained batches. Initial stream-collector mistakes and rerun limits are recorded in the validation record. One sample per configuration supports compatibility and retrieval claims; it does not establish quality/cost/latency improvements or full monetary cost. Full commands and decisions are in the roadmap record.
• Handoff and deferred work: Relevant current documentation, generated public API, examples, AMOS, Changelog, and packaged records are synced below. No new configuration needs disabling to retain the existing compaction strategy or feature defaults. Helpers, summaries, acknowledged evidence storage, typed contributions, and retention/routing policies remain separate planned stages.

Stage 01 corrective adoption record — 2026-10-08

• Availability: All five review fixes are validated on version2; no package release is claimed. Earlier adoption/validation entries above remain history.
• Recovery: Mixed message/native function/custom results sharing an assistant message are stored together before spill removal, including small results and multimodal attachments. Failed/evicted writes leave history intact; unsupported serialization groups are retained. The working-memory index exposes each key, including disambiguated collisions. Ordinary rolling retention and the existing emergency tool-text truncation policy remain in place; this is not durable evidence acknowledgment or a backend/session migration.
• Dispatch and compatibility: Existing synchronous request listener and hook mutations remain usable. The final check runs after them and captures counted fields before budget-event reentrancy. It checks the dispatched model's provider capacity while respecting explicit host limits and preserving the owning model. Direct APIs, event shapes, plugin/strategy interfaces, defaults and format-v1 sessions remain compatible. Streaming keeps its existing hook-return semantics.
• Optional validator fields: model, response_format, and native_tools participate in final estimates. The optional second argument accepts modelMaxContextTokens and recordPreparation. The default updates diagnostics for the same preparation; recordPreparation: false checks auxiliary fit without mutating context state. Managed JSON formatting/repair uses that policy, stops oversized auxiliary requests before dispatch, and preserves fitting output, history replacement and aggregate usage. This adds no helper-routing API.
• Signature policy: Tool-call thought signatures and thinking signatures use the same conservative local replay estimate and keep their bytes. Estimates do not assert provider tokenization/billing. Real Google signature replay after serialized context passed; it is not a durable remote-session guarantee.
• Examples and AMOS: npm run example:context-freshness now recovers connected native evidence. npm run example:structured-budget demonstrates fitting/rejected repair offline with public exports and cleanup. AMOS inspection is tested against the final dispatched budget and keeps the main revision through auxiliary calls. No new AMOS option or command is required.
• Validation: 38 new regression cases; 325 files / 6,863 unit tests, plus 10 live correction cases / 24 baseline scenarios across OpenAI, Anthropic and Google passed. Build/types/lint, examples, pinned consumer compatibility, AMOS, generated API and scoped coverage passed. The corrective record retains the initial retrieval-fixture failure and the final passing evidence. One sample per configuration supports functional claims only. Standard documentation and this handoff ledger are synced; Stage 02 still needs separate authorization.

Stage 01 second corrective adoption record — 2026-10-08

• Availability and scope: S1–S4 from the second review are fixed and validated in the version2 working tree, base 43b34cd. Package remains 1.2.0; no published Version 2 release is claimed. Stage 02 remains separately authorized.
• Existing applications: Managed run()/stream(), suspend/final wrap-up, and later dispatch checks use the existing connector and shared ToolManager. Known structured constraints/native tools and the initial provider capacity now guide compaction, so fitting-after-eviction requests can proceed. Hook model changes still receive a final check without another preparation pass.
• Verified additive adapter options: ContextPrepareOptions.getRequestOptions is a synchronous callback receiving selected function definitions and returning instructions, response_format, and/or native_tools. It is resolved again after compaction. modelMaxContextTokens supplies initially known provider capacity with explicit host limits retained. Old no-argument preparation, instructions, and getTools remain supported. No new feature flag/default, direct-call behavior, extension interface, or session format change is required.
• Evidence and failures: Stored raw keys participate in collision allocation across passes and restored state. Ordinary unused keys/values keep their format; collisions use distinct namespace suffixes visible in the notes index. Spill values are verified before history removal. A failed partial attempt can leave earlier writes and a retry can leave a duplicate copy. Normal capacity eviction still applies; no atomic transaction with concurrent external writes is claimed. Function-result error text is counted alongside content/images. An oversized protected error is preserved and rejected before dispatch.
• Recipe and cleanup: Build, then run npm run example:context-budget without credentials. It demonstrates one schema/capacity-driven compaction and one model call, retrieves both colliding source markers, and rejects a protected error. Fixture agents, contexts, and connector are destroyed/removed. The existing AMOS offline example shows the smaller selected window and schema contribution through /context budget and /context breakdown; no new command/setting.
• Evidence and handoff: 326 files / 6,895 unit tests, including 32 new regressions, passed. Scoped context/AMOS coverage passed (806 tests, 85.13% lines / 85.34% branches); Agent behavior tests are included but Agent.ts is not part of that coverage denominator. 16 context live cases and 24 Stage 00 live workload/split scenarios passed across OpenAI, Anthropic, and Google. Build, types, lint, examples, strict core/live-test compilation, pinned built consumer, AMOS, and generated API documentation passed. See the validation record. Current usage docs and the handoff ledger are synced; release-wide edits remain tracked separately. One sample per configuration is functional evidence, not a comparative quality/cost result. The main routing/helper/retention redesigns remain future work.

Stage 02 adoption record — 2026-10-12

• Scope/revision: Existing pipeline and shared ToolManager, managed Agent run/stream/external tools, background execution, generic connector API tools, and AMOS. Branch version2, base fa8f911; no published release verified.
• Public additions: ToolExecutionOutcome, ToolExecutionOptions, ToolExecutionReport, PipelineExecutionOptions; executeWithOutcome(); optional execution options/observer; tool:outcome and tool:late-complete; optional result/stream/error outcome; async ToolResult.pending; connector timeoutScope and retryPolicy.
• Defaults and compatibility: Existing raw values, normalizer payloads, default-disabled manager deadline, header timeout/retry defaults, breaker settlement policy, saved formats, two-argument pipeline implementations, and execute overrides remain supported. Legacy async override deadlines are retained. No breaking change proposed or approved.
• Corrections: Framework-normalized failures and streaming counters are accurate. Async placeholders defer success counts. skipRetry now skips status retries as documented. Manager safety nets still constrain async calls.
• Lifecycle/security: Trusted identity/correlation snapshots, per-call signals, disposed listeners/timers, one initial outcome, separately correlated late settlement, no duplicate late accounting, and no cross-account background delivery. Noncooperative tools can still perform effects; no remote rollback is claimed.
• Persistence/support: Controllers/provenance are process-local. No new session/config schema, durable outcome/effect ledger, automatic tool retry, or origin restriction. Existing pinned consumers and saved sessions remain valid. Generic API tools forward signals; specialized tools/transports need their own support. Provider-hosted tools/external drivers have independent lifecycle controls.
• Review corrections: All seven findings in the review are implemented: execution-bound connector authority and tool/permission selection, delivery-time scope checks, contained async observers, settlement before streamed completion, abort-aware cleanup, and metadata-preserving chained clones. Internal registry capture introduces no mandatory custom-registry API. Existing counters, explicit host continuations, formats, raw results, and defaults remain supported. Existing injection notification ordering is retained. Reentrant scope changes clear invalid pending input and stop delivery before the provider call.
• Examples/app: The offline library example now demonstrates replacement during a plugin wait and the replacement's use by the next invocation. Existing AMOS outcome rendering remains appropriate; its build, adapter tests, and offline example pass without adding a new UI for these library corrections.
• Validation: 7,010 unit tests / 332 files pass, including 53 corrective regressions in addition to the original 62 Stage 02 cases. Scoped coverage is 83.45% lines / 90.48% branches / 83.33% functions; Agent and the large AMOS adapter remain outside that denominator and have mock integration coverage. Build, strict types, lint, examples, public consumers, AMOS, package checks and offline examples pass. See corrective evidence; original evidence remains historical. 30 unique OpenAI/Google live scenarios pass. One existing OpenAI separate-spill retrieval scenario failed twice unchanged, returning index keys/descriptions rather than source markers; the Google counterpart passes. Anthropic was attempted in both Stage 02 modes and remains unvalidated because the current key returns 401. This is not an all-provider/all-scenario passing result or a release claim. Follow-up diagnosis identified misleading keyless store_get guidance: notes returns index metadata, while the tool description implies full retrieval. A description-only diagnostic intervention passed five trials. The production correction and its passing revalidation are recorded below; the diagnosis and earlier failed attempts remain historical evidence.
• Next: The corrections and all-provider validation below complete Stage 02. Separately authorize Stage 06 — fixed main model, bounded helper roles, and aggregate task usage/budgets. Stage 03 follows its dependency sequence.

Stage 02 notes retrieval correction — 2026-10-12

• Delivered: Accurate keyed/keyless retrieval guidance in tool definitions, store overview, notes instructions and memory index. Notes keyless reads return metadata; pass each exact index key to store_get for source contents, and use store_list for omitted entries. The original optional key, return shapes, custom-store behavior and legacy WorkingMemory formatting are preserved.
• Adoption: Existing managed agents receive the corrected prompt automatically. No configuration, saved-state migration or new public package API is required. The formatter's optional store selector is internal to the library. See the preparation guide and updated npm run example:context-freshness, which demonstrates metadata versus content. AMOS uses this library guidance automatically; existing adapter tests, typecheck and offline context inspection example pass without a new UI control.
• Validation: 7,016 unit tests / 333 files, including six new retrieval regressions, pass. Build, types, lint, consumers, examples, AMOS, generated API and package checks pass. The original OpenAI collision scenario passes in all six production trials, with both keyed reads and source markers. There are 31 distinct passing OpenAI/Google live scenarios; repetitions are not counted as additional scenarios. Both Anthropic Stage 02 modes still fail with 401 before validating behavior. Full stage completion remains pending that blocker. See retrieval-fix evidence and correction record.

Anthropic authentication and live revalidation — 2026-10-12

The user's updated .env key authenticates successfully: a direct Messages API call returns HTTP 200. The unchanged Anthropic live suites pass 10 of 11 test cases: eight Stage 00 workload/split scenarios, all five Stage 01 context scenarios, and the Stage 02 stream case. The Stage 02 run case fails because its observed outcome order is failed, succeeded rather than succeeded, failed. The 23 filtered OpenAI/Google test cases are not passes in this follow-up.

A diagnostic confirms correct classification by tool name, but also observes a repeated failure-probe call. The dispatched named choice is domain_probe, yet the response selects failure_probe. A separate direct request to api.anthropic.com/v1/messages, bypassing OneRingAI and the SDK, reproduces that selection with HTTP 200. This remains an unresolved validation failure, not an authentication blocker or an all-provider passing result. No source, assertion, model, prompt, or limit was changed, and no retry-until-pass was performed.

The previous 7,016 passing unit tests and 31 passing OpenAI/Google scenarios are retained validation; their recorded source/test/example fingerprints still match. They were not rerun after this credential-only change. See Anthropic evidence for the failure, correct tool/status correlation, repeated execution, and direct API probe.

Stage 02 final correction and validation — 2026-10-12

• Delivered: Explicit Anthropic named choices advertise the selected local function while retaining native tools and history. A mismatched local response raises the existing ProviderError before execution, in both generated and streamed paths. The provider stream is cleaned up, and no automatic retry or model switch is added. Default auto/required behavior remains unchanged.
• Fixture correction: Both live modes now mutate before:llm options in place, preserving existing streaming hook return semantics. Single-call requests are explicit; the original marker, order, call-count and metric assertions remain, with stricter tool/status correlation. A separate live diagnostic using the original failing request configuration passes as well.
• Compatibility/adoption: No public signature, default, raw return, event shape or saved format changes, and no breaking change needed. Existing agents receive the provider correction automatically. Named-tool requests on unsupported models/settings retain their existing rejection. See the selection contract.
• Examples/AMOS: npm run example:tool-outcomes remains offline by default. With .env credentials, -- --live-anthropic adds real calls in both managed modes and verifies exact probe names/statuses and markers. Both modes pass. Existing AMOS provider-error rendering needs no new controls; its unit/type checks and both offline demonstrations pass.
• Final validation: 334 files / 7,030 unit tests, including 14 new provider/Agent regressions, pass. The full live suite passes 34 test cases / 46 distinct scenarios: 24 baseline workload/splits, 16 context scenarios and six tool-outcome modes across OpenAI, Anthropic and Google. There are zero failures and zero skipped cases in both final suites. Build/24 exports, source/strict/examples/AMOS types, lint, original/additive public consumers, generated API, public offline/live examples and package checks pass.
• Availability: Stage 02 is complete on the current branch; no package has been published. Earlier failures and reports remain historical evidence. The final evidence records current checks and source fingerprints. These are functional samples, not a statistical reliability or comparative model-quality claim. Stage 06 still requires separate authorization.

Stage 06 adoption record — 2026-10-13

Review status: The subsequent review reproduced eight defects absent from the original passing suite. All eight are fixed and validated in the corrective evidence. The original validation below remains historical; the corrective adoption record following it gives current totals and support details.

• Scope: Optional static role profiles and a shared process-local model task; explicit helpers/rollover and AMOS controls. No main-model routing, new context framework, automatic summary strategy or distributed budget.
• Public APIs: ModelTask, ModelBudgetExceededError, HelperOutputError, role/ configuration/result/snapshot types; optional modelExecution and modelTask; agent.invokeHelper() and getModelUsage(). All root package exports are additive.
• Defaults and adoption: Omitted configuration preserves old single-model behavior with no new calls/tools/prompt content. Helpers require named connectors, a text packet and a synchronous schema. Output defaults to 512 tokens, at most one repair. Share the same task explicitly to aggregate calls; otherwise enabled configuration creates owned per-execution tasks. Main provider and tools stay fixed.
• Accounting and failures: Physical built-in SDK attempts are admitted separately; logical usage is copied before hook/repair mutation. Unknown charges remain conservatively reserved; known cache/reasoning subsets are not double-counted. Host price bounds survive settlement. Unsupported capability/scope, malformed output, deadlines and budget exhaustion fail explicitly. Late settlements remain diagnostic on their original task. External final usage is recorded once; mixed pricing remains unknown and external admission is outside local enforcement.
• Persistence/compatibility: Context, old AMOS configuration/session loading, events, raw returns and custom provider signatures remain compatible. Reapply profiles from trusted host configuration; neither snapshots nor context hydration restore task authority. No break was required or approved.
• Support: Native OneRingAI run/stream/direct/repair/wrap-up and helpers integrate. OpenAI/Anthropic/Google are live-tested; Vertex/DeepSeek/inherited OpenAI-compatible adapters have local regressions. Injected providers need a single-attempt host attestation for hard limits. External SDK internals, batches/media and raw provider use remain outside automatic admission. Service fees and invoice accuracy are not model token-cost guarantees.
• Examples/AMOS: Public offline extract/main/verify and concurrent-budget demos; opt-in OpenAI stronger-main/smaller-helper example; AMOS /helpers with no-call profile changes, busy/rollback handling, usage/unknown display and explicit rollover. Static connector names, not keys, are persisted. Independent commands have separate tasks.
• Validation: 339 files / 7,131 unit tests, including 101 new Stage 06 tests, pass. Final live suites pass 42 cases / 54 distinct scenarios across OpenAI, Anthropic and Google, with zero failures/skips in those final runs. Scoped new-runtime-module coverage is 97.93% lines / 84.97% branches. Build/24 exports, strict/source/examples/AMOS types, lint, original/additive public consumers, generated API (1,640 items), AMOS build, public offline/live examples, package inventory and artifact checks pass. See evidence. Earlier Google development-chat exact-text failures include unrelated model output; wire checks found no request defect and the subsequent unchanged full suite passed. Those failures remain evidence, not a claimed model reliability fix. No published release, statistically measured reliability or comparative quality claim.
• Next: Separately authorize Stage 03 — acknowledged evidence references and projections. Stage 07 structured compaction follows Stage 03 and Stage 06.

Stage 06 corrective adoption record — 2026-10-13

• Availability: All R1–R8 fixes are available on the uncommitted version2 branch, base dcc8dad; no release or breaking API change.
• Budget/accounting: The cost guard covers raw hosted-tool/MCP aliases and nested request configurations. Tier overrides require host price bounds. Google GenerateContent/Vertex output is inclusive of thinking in the ledger and helper output checks, with legacy response/event counts preserved. Terminal stream usage survives subsequent failure/cancellation; unknown retry charges remain reserved and duplicate conflicting terminal reports fail explicitly.
• Helpers/lifecycle: Ajv is invocation-scoped; IDs/local references/formats work without a global schema registry or clone retention. Standalone helpers own independent tasks even during a main execution; pass modelTask explicitly to share. Direct cleanup preserves caller ownership despite options mutation. Anthropic extended thinking is supported with provider mode/budget preflight.
• External usage: Empty/metadata-only/partial core counts stay unknown. Explicit zero counts and split incremental counts work; final fields override accumulated counterparts. recordExternal adds optional outcome status, defaulting to succeeded; Agent completion records actual failure/cancellation. Legacy response defaults and external host-owned admission remain unchanged.
• Validation: 7,179 units / 339 files, including 149 Stage 06 cases and 48 corrective regressions; 45 live cases / 57 distinct scenarios across OpenAI/Anthropic/Google, with no failures/skips in final runs. Scoped runtime coverage: 98.14% lines / 88.34% branches. Build/exports, all type/lint, built-package compatibility, generated API, examples and AMOS checks pass. The initial two new Google thinking fixtures returned prose instead of the requested numeral. Explicit native-JSON fixtures now validate the exact answer and accounting. Those failures and all earlier evidence remain recorded; established gates were not weakened and no reliability rate is claimed.
• Handoff/AMOS: Recipe, standard docs, generated API, example/index and AMOS support notes, release notes and package inventory are synchronized. Existing AMOS helper/usage commands require no new UI; adapter/command tests and the offline walkthrough pass against the corrected runtime. Stage 03 remains next and separately authorized; Stage 07 automatic compaction is deferred.

Stage 06 second review — 2026-10-13

The second review reproduces four further gaps: multi-candidate output reservations, post-admission vendor-option mutation, final external metadata overwriting mixed pricing, and helper repair losing its original packet. All 149 focused tests passed at that snapshot; the missing cases are documented in review evidence. Runtime/test fingerprints match the prior corrective pass. No production fix, new stage or breaking change was implemented in that review. The subsequent corrective adoption below records their resolution; prior validation remains historical evidence.

Stage 06 second corrective adoption — 2026-10-13

All S1–S4 findings are fixed and validated. Google/Vertex reservations include all candidates; the optional per-call output cap is aggregate. Without an explicit per-candidate limit, divide that cap by candidate count and round down; preserve explicit limits/counts and reject excessive or unsafe bounds. Tracked requests capture records/arrays before admission while preserving live signals, registries and opaque SDK values. Default untracked behavior remains unchanged.

Mixed external pricing uncertainty survives final metadata/count snapshots; contradictory/composite modes cannot receive a known registry cost. Helper repair retains the selected evidence and rechecks its complete input fit, without extra history, silent trimming or additional retries. Public signatures, legacy returns/ events, old sessions and host task ownership remain compatible. No API break was needed. Internal request capture and pricing normalization add no public API.

Current validation: 7,228 units / 339 files, including 198 Stage 06 cases and 49 second-pass regressions; 48 live cases / 60 scenarios across OpenAI/Anthropic/Google, with no final failures/skips. Scoped runtime coverage is 98.24% lines / 90.10% branches. Build/exports, all static/consumer checks, generated API, examples and AMOS gates pass. Three new controlled helper-repair cases use real model calls; the library and AMOS offline demos now exercise deliberate schema repair with preserved source IDs. Earlier failed/passing records remain history. See second corrective evidence.

The recipe, standard guides, generated API, examples/index, AMOS guide/transcript, Changelog and package inventory are synchronized. Existing AMOS helper/usage commands demonstrate the fixes; no additional command or config migration is needed. Availability remains branch-only, with no release or comparative model quality/savings claim. Stage 03 remains separately authorized.

Stage 03 adoption record — 2026-10-13

• Availability: Implemented on version2, working tree based on Stage 06 commit a98a498. All six review findings are corrected and validated on 2026-10-14. The second review findings are also corrected and validated. The third review findings are now corrected and validated as well. Stage 03 is complete on branch; original and intermediate validation remain historical evidence. No published release claimed.
• Public APIs: IEvidenceStorage, scoped record/reference/chunk types, InMemoryEvidenceStorage, FileEvidenceStorage, optional StorageRegistry.evidence, EvidencePluginNextGen, ToolEvidenceMiddleware, delivery/receipt configuration, ToolOutputHints.effect, optional execution evidence callbacks/reports and AgentContextNextGen.acknowledgeToolEvidence(). Enabled plugin tools are evidence_read and evidence_list; ID lookup is optional on custom backends, and full-reference reads remain valid. No new required tool/plugin methods.
• Setup/defaults: Enable context.features.evidence and configure a stable host-owned owner/tenant/namespace and backend. Without one, a new in-memory store is process-local. File default is ordinary restart; optional fsync is local, filesystem-dependent acknowledgement, never replication. Defaults: 4 MiB blob, 64 MiB/1000 records per scope, 8192-character chunks, 8 read slots, 32 queued mutations, 20 metadata receipts, 8192-byte projection threshold, 2000-character summary and 4096-character envelope caps, 5000ms write deadline, no default expiry.
• Usage: output.summarize receives detached redacted JSON and preserves essential IDs/status. Projection is acknowledged and opt-in; raw application returns, managed result content and execution events remain raw. Outcomes expose storage diagnostics separately from actual tool status. Index/listing contain metadata, never source blobs; model reads prefer scoped IDs and storage resolves integrity metadata. Reads verify integrity and respect configured scope.
• Persistence/cleanup: Optional version-1 plugin/content fields supplement the existing session format. Configuration/authority/credentials/functions are not restored. Old sessions load; a smaller current index truncates valid older state. Scratch eviction, context compaction, teardown and session deletion do not remove evidence. Expiry pruning/deletion are explicit host policy; missing/expired reads are distinct from corrupt data. Source data may remain sensitive after key redaction.
• Failures/recovery: Serialization/storage/projection error does not turn a successful effect into failure or repeat an action. Unacknowledged raw groups remain protected, or dispatch stops explicitly if retention cannot fit. Async storage failure stops before lossy text injection. The host can persist a retained observation and acknowledge the original invocation without executing it again. Unknown write completion and later observations remain separate immutable receipts.
• Compatibility/support: Disabled features add no prompt/tools/storage/model work and preserve legacy result/hook/override shapes. Existing external evidence feature factories and arbitrary configuration remain valid. Bundled stores require strict JSON, do not encrypt/replicate data, and coordinate writer admission only within one process. Legacy overrides bypassing ToolManager also bypass evidence handling. No new automatic compaction, distributed effects or replay.
• Examples/AMOS: Durable search and separate-process recovery, ambiguous local action, and AMOS offline runner/command walkthrough all pass. AMOS persisted host settings enable scoped file storage, /context evidence lists metadata, explicit previews cap at 1024 characters, and run views distinguish storage failure from unknown effects.
• Original validation (2026-10-13): 7,337 units / 343 files pass, including 109 new Stage 03 cases. New evidence-component coverage: 99.81% lines / 91.48% branches. All 13 offline stage examples, build/exports, root/AMOS/example/test types, lint, built public compatibility and generated API pass. The full 57-case / 69-scenario live gate passes across OpenAI/Anthropic/Google, including all nine evidence probes. Earlier failed attempts remain recorded. ESM/CJS public runtime and declaration checks pass; no package release is claimed.
• Corrective adoption (2026-10-14): Queued async completions survive failed delivery and pause automatic retries until host repair/explicit continuation. acknowledgeToolEvidence() requires a result-bearing matching invocation; function/custom call-ID namespaces remain independent. Complete evidence snapshot preflight leaves active context intact on rejection. Mutable hooks and retained result changes invalidate stale projections without freezing application objects. Cancellation settlement preserves returned observations and original IDs.
• Serialization options: Optional IEvidenceStorage.serializationLimitBytes lets bundled/custom backends supply an early byte budget. Optional ToolEvidenceConfig.maxSerializationBytes (also in plugins.evidence) can set the source/redaction budget independently of the final backend quota. Existing custom adapters need no new required member and retain their own capacity policy without either setting. Incremental encoding and admission replace unbounded pre-quota expansion; no automatic model call or new storage framework is added.
• Corrective validation: 7,397 units / 344 files pass, including 60 new regressions and 169 total Stage 03 cases. Four evidence components have 99.83% line / 92.36% branch coverage. The 60-case / 72-scenario live gate passes across OpenAI/Anthropic/Google; all 12 evidence cases pass again on final source. All 14 offline examples, local checks and public ESM/CJS consumers pass. The initial Google chat completion failure and three bounded diagnostic calls remain in corrective evidence. The recovery example, usage/API/agent guides, AMOS support notes and package records are synchronized; no release is claimed.
• Second corrective adoption (2026-10-14): Protected pending groups survive async insertion and follow-up runs. Authentic deliveries carry original recovery correlation internally when optional outcome is omitted; their scope/call is checked before projection/admission. Pending failed observations are included in detached snapshots using the existing conversation field, with no live-input commit or required schema addition. Same-instance restoration avoids duplicates.
• Second corrective validation: 7,435 units / 345 files, 38 new regressions / 207 Stage 03 cases, 63 live cases / 75 scenarios and 14 offline examples pass. All three providers read restored exact markers without repeating the action. Public ESM/CJS, source/test types, build/lint, examples, AMOS real interrupted save/load, generated API and package checks pass. The extended recovery example demonstrates delivery-only pending save/load and later acknowledgement. Second corrective evidence preserves initial failures. New provenance/preservation methods are internal; no release, new public API or changed evidence durability is claimed.
• Third corrective adoption (2026-10-14): Completed unacknowledged batches survive managed fail-fast exits and stream closure at a completion event, retaining their original assistant state and correlation. Receipt-only delivery is diagnostic; it does not authorize dropping the retained raw observation or async continuation. Store the result body and acknowledge it through the host recovery API. Restore/load reconciles by content namespace, call and execution identity across acknowledgement changes; the loaded checkpoint owns matching invocations and unrelated pending blocks survive. Older failed checkpoints can require acknowledgement again. All new provenance/settlement helpers are private, with unchanged saved-session schema, public signatures, default behavior and raw return/event shapes.
• Third corrective validation: 7,473 units / 346 files, 38 new regressions / 245 Stage 03 cases, 66 live cases / 78 scenarios and 15 offline examples pass. Three live stream-closure probes recover exact markers without repeating their action. AMOS real-runner run/stream interruption and file save/load/save pass; no new command is required. Public ESM/CJS, build/types/lint/compatibility, examples, AMOS, regenerated API and package checks pass. Run npm run example:evidence-interruption for the credential-free public example. Third corrective evidence preserves initial failures, including the AMOS stale-build check and successful rerun, the initial 65/66 live batch, four actual Google diagnostic answers, and the final unchanged 66/66 live rerun. The original failed Google answer was not captured; one fresh diagnostic violated the required exact text format. No completion rule was relaxed or provider reliability guarantee added.
• Handoff/internal changes: Standard guides, agent instructions, connector/tool catalog, context-preparation notes, examples/index, AMOS, Changelog and generated API are synchronized in this stage. Internal-only changes capture execution-owned projections, protect unacknowledged protocol groups, and preserve original late outcomes; they create no new default pipeline. Earlier rejected Google schema, legacy-message regression and live fixture output/extra-turn failures remain recorded rather than counted as passing. See implementation and validation. Stage 07 is the next suggested core stage and remains separately authorized.

Stage 07 adoption record — 2026-10-14

• Availability: Implemented on version2, based on Stage 03 commit 224e395; initial and corrective gates validated 2026-10-15. All three review findings are fixed; see the corrective completion and evidence. No package release or default promotion is claimed.
• Public APIs: ObservationMaskingStrategy, StructuredSummaryStrategy, their optional constructor settings, StructuredContextSummary, ContextSummaryEntry, ContextSummaryRequest, ContextSummaryGenerator, ConversationCompactionOptions and ConversationCompactionReport. Two new StrategyRegistry registrations. Optional ContextPrepareOptions.signal/summarize, ContextPreparation.compaction, CompactionResult.report and CompactionContext.compactConversation preserve old callers and extension implementations.
• Defaults/behavior: Algorithmic remains default. New strategies are opt-in, pre-call only and require the enabled built-in evidence plugin. Sources are retained through its existing storage/redaction/acknowledgement policy. Helpers use a two-entry-per-section compact schema, local safety checks and the active ModelTask. No new backend, role, prompt content or tool is mandatory for old agents.
• Retention/security: User messages and call/receipt metadata remain exact; only matched settled read observations are masked. Redacted mismatches protect the source instead of silently creating an unredacted archive. Unknown/write effects, pending dependencies, recent turns/items and opaque/multimodal groups remain protected. Source expiry/eviction and stale history/input/scope/strategy reject apply. Internal source bookkeeping is visible through evidence_list/read. Summary capsules are assistant data, not host rules or semantic proof.
• Budgets/failure: One bounded transaction, at most one schema repair, one masking fallback and a final recount/fit check. A valid partial reduction can remain on a later fit error. The helper callback can be requested without a model dispatch; actual usage comes from the task ledger. Google helper reasoning can remain active despite a unified disable request; its functional probe uses explicit output headroom and records inclusive reasoning usage.
• Persistence/compatibility: Existing session schema, raw return/event shapes, custom strategies and explicit between-execution rollover remain supported. Capsules/references persist as ordinary history; diagnostics, helper roles, storage authority and task budgets are host configuration. Process-local sources do not gain restart durability merely by saving a session.
• Examples/AMOS: Deterministic development/held-out comparison and a real AMOS masking/selection walkthrough. Live comparison freezes six independent local task variants, two repetitions and three strategies in seeded shuffled order. AMOS persists optional contextStrategy, switches without recreating the agent, reports last transaction and points to complete helper accounting. Selection makes no immediate helper request; failed settings persistence restores selection.
• Original validation (2026-10-15, before review): 7,594 units / 349 files, 121 new Stage 07 cases, 66 retained baseline plus 39 fresh new live cases (117 distinct scenarios), 17 offline examples and 18 held-out scripted cases pass. Build/types/lint, compatibility, strict tests, public ESM/CJS, AMOS and regenerated API (1,671 items) pass. Three strategy modules have 97.22% line / 88.70% branch / 100% function coverage; integration code is outside that percentage scope. Validation and comparison evidence preserve earlier failed/unknown-charge batches, actual source/answer traces, consumed splits and diagnostic artifact limits. The final 12/12 per strategy uses 24/24/36 model attempts respectively, with 12 source reads each. Historical notes now follow their source and explicitly defer to current instructions; exact observed facts take priority over progress chatter. Full tenant/namespace and configured AMOS headroom/config roundtrip regressions pass.
• Corrective validation: All R1–R3 fixes pass 7,631 units / 350 files, including 158 Stage 07 cases and 37 new regressions; 105 live cases / 117 scenarios in one batch; 17 offline examples and 18 retained scripted regression cases. Strategy module coverage is 97.59% lines / 92.01% branches / 100% functions. Exact users no longer consume standalone source allowance, known no-ops avoid writes/helpers, and AMOS restores absent settings across actual save/reload. Public signatures, defaults, sessions, raw returns/events and partial merge behavior are unchanged. The reused comparison is regression evidence, not a fresh held-out quality claim. All standard docs/API, examples/AMOS and corrective package records are synced.
• Evaluation limits: Offline answers/usage are scripted. The bounded live pilot checks exact completion and hard constraints; it does not establish statistical non-inferiority, a reliability rate, general savings or a cheapest-model recommendation. Alternatives ship experimental under the roadmap's explicit limited-scope rule. Actual final results and initial failures are recorded in the stage evidence.
• Handoff: Recipe, standard guides, agent instructions, examples/index, AMOS, Changelog and generated API are synchronized. Final validation and package/ documentation checks are recorded below. Internal-only changes are private source retention, canonical JSON and revision-guarded pre-call planning; no new execution framework is added. Stage 04 remains separately authorized future work.

Handoff to the standard documentation

This ledger prevents improvements, changed guarantees, and limitations from being lost during the final documentation refresh. Its initial rows are pending targets, not claims that the corresponding pages already contain Version 2 instructions.

Use Pending, Synced (with destination/revision), or Not applicable (with a reason) for each applicable destination. Split the rows by delivered scope and destination as stages progress so that partially completed handoffs remain visible. Documentation describing current behavior must be corrected in the delivering stage; a later broad README refresh is not a reason to leave incorrect usage instructions in place.

Cross-cutting release handoffs must also be checked:

• README: Quickstart, feature claims, requirements, and documentation links.
• User Guide: Copyable recipes, defaults, lifecycle, persistence, supported paths, failure behavior, and upgrade guidance.
• API Reference: Regenerate from implemented public exports with the repository generator; do not hand-edit generated signatures.
• Examples index: Exact run commands, setup, credentials, expected behavior, side effects, and cleanup. Verify consumer-facing snippets through documented package exports.
• AMOS documentation: Relevant settings, commands, walkthroughs, limitations, and old-setting/session migration.
• Connector & Tool Catalog, Memory Guide, and Memory Permissions: Update only where delivered behavior affects them; check related specialist docs.
• Agent Guide: Current API routing, invariants, and verified patterns.
• Changelog: Actual delivered changes and release versions; distinguish planned work from released functionality.
• Package documentation inventory: Include guides referenced by installed-package documentation, and check which example links require the source repository.

Stage-by-stage maintenance

Before calling a stage complete, update its availability row, relevant capability text, adoption record, and handoff status. Record an explicit “no externally visible change” entry for internal-only work. A required example, test, or applicable AMOS demonstration cannot be replaced by a documentation placeholder.

At each delivery, verify the public signatures against exports and tests, run the documented examples in their stated modes, and check links and support claims. Model/provider recommendations need current primary-source checks when introduced or refreshed. Report measured findings with their workload, comparison, costs, quality limits, and uncertainty; do not generalize offline mock results into model-quality claims.

Before a Version 2 release, audit every delivered scope against this guide and its handoff rows. Ensure that all applicable standard-document destinations are synced, generated API docs are current, examples and AMOS help match the release, compatibility and migration notes are complete, and package inventory includes the referenced public guides. Deferred scopes must remain visibly deferred. Retain this guide as the adoption/release record or explicitly document its successor after handoff.

Update log

| 2026-10-13 | Implemented Stage 06 static helpers, shared model-task admission/accounting and AMOS commands. | Available on branch: 7,131 units and final 54 live scenarios pass; initial Google answer failures retained. No release or API break. | Recipe, generated API, adoption/standard guides, examples/AMOS, package inventory and evidence synced. | | 2026-10-13 | Corrected all eight Stage 06 review findings and added 48 regressions plus live Google/Anthropic thinking checks. | Complete on branch: 7,179 units and final 45 live cases/57 scenarios pass. Initial new Google output-format failures retained; no release or API break. | Corrective adoption, recipe, standard docs, generated API, AMOS support notes, review/stage records, release notes and packaged evidence synced. | | 2026-10-13 | Reviewed Stage 06 again and reproduced four further cases with controlled providers and actual SDK/mock HTTP. | Available on branch with two P1/two P2 findings open; fresh 149 focused tests pass. No production fix or API break. | Second review/evidence and current availability/stage records updated; earlier evidence retained. | | 2026-10-13 | Corrected all four second-review findings with 49 regressions and three new live helper-repair cases. | Complete on branch: 7,228 units and 48 live cases/60 scenarios pass; no release or API break. | Second corrective adoption, standard docs/API, library/AMOS repair demos, stage/review records, release notes and packaged evidence/transcript synchronized. | | 2026-10-13 | Completed Stage 03 scoped evidence, ID/full-reference reads, opt-in projections, protected failure/recovery and AMOS inspection. | Available on branch: 7,337 units, 57 live cases/69 scenarios and 13 offline examples pass; earlier schema/model/fixture failures retained. No API break or release. | Recipe, standard guides/API, outward adoption/handoff, examples/AMOS, package inventory and validation/transcript synced. | | 2026-10-13 | Reviewed Stage 03 and reproduced six recovery, cancellation, snapshot, hook and serialization defects. | Three P1/three P2 findings open; 109 existing focused tests and the built consumer pass. Original full/live evidence retained; no runtime fixes or release. | Review/fix plan, executable evidence, current availability/adoption/handoff and package documentation inventory synchronized. Corrections precede Stage 07. | | 2026-10-14 | Corrected all six Stage 03 review findings and added bounded capture settings plus failed-write recovery example. | Complete on branch: 7,397 units, 60 live cases/72 scenarios and 14 offline examples pass; prior failures retained. No release or API break. | Corrective availability/adoption/handoff, standard docs/API, examples/AMOS support notes, review/stage records and packaged validation/transcript synchronized. | | 2026-10-14 | Reviewed Stage 03 again and reproduced loss of protected input during async insertion, delivery-only retention and interrupted-run save/load. | Three P1 findings open; fresh 7,397 units and public compatibility pass. No runtime fixes, new live validation or release. | Second review/fix plan and executable evidence recorded; availability, recipe warning, roadmap and adoption/handoff updated. Corrections precede Stage 07. | | 2026-10-14 | Corrected all three Stage 03 second-review findings and added interrupted save/load coverage. | Complete on branch: 7,435 units, 63 live cases / 75 scenarios, 14 offline examples and all local gates pass; no API break or release. | Recovery example, AMOS real runner save/load, standard docs/API, outward adoption/handoff, roadmap and packaged second corrective evidence synchronized. | | 2026-10-14 | Reviewed Stage 03 after its second corrective pass and reproduced partial-batch data loss, receipt-only admission and post-recovery restore duplication. | Two P1/one P2 findings open; fresh 7,435 units and public compatibility pass. No runtime fixes or new live gate. | Third review/fix plan, executable evidence, current availability/adoption/handoff, recipe warning and roadmap recorded; corrections precede Stage 07. | | 2026-10-15 | Completed Stage 07 opt-in masking and historical structured summaries with full scope guards and AMOS selection/headroom. | Complete on branch: 7,594 units, 66 baseline + 39 new live cases, 17 offline examples and local/public gates pass. Earlier failed pilots retained; experimental, no default promotion or release. | Recipe, standard guides/API, adoption/handoff, comparison/example/AMOS, package records and validation synchronized. | | 2026-10-15 | Reviewed Stage 07 and reproduced source-budget starvation, repeated no-op retention/helper work and failed AMOS restore-to-absence. | Three P2 findings open; fresh 7,594 units and local public/type/lint gates pass. No runtime fixes or new live calls. | Review/fix plan and executable evidence, current availability/adoption/handoff, recipe, roadmap and package document inventory synchronized. Corrections precede Stage 04. | | 2026-10-15 | Fixed all three Stage 07 review findings: eligible source allocation, known no-op preflight and exact AMOS setting rollback. | Complete on branch: 7,631 units, 105 live cases / 117 scenarios in one batch and 17 offline examples pass. No API break, default promotion or release. | Corrective completion/evidence, recipe, standard guides/API, examples/AMOS, adoption/handoff and package records synchronized. |

Stage 04 adoption record — 2026-10-15

• Availability/revision: Implemented in the uncommitted version2 tree based on 152a0a3; all four review findings are now fixed and validated. No npm release or later-stage delivery is claimed.
• Verified surface: Public TaskStatePluginNextGen plus ten note/source/action/ lifecycle/snapshot/config/delta types; optional features.taskState (false) and required enabled-plugin host configuration. One task per context, immutable scope/task/optional association/lifecycle binding. No new required session or storage member. Third-party same-name plugins keep their existing contract.
• Usage/authority: Atomic updateHost, unconfirmed propose/assume, explicit recordAction, separate host confirmAction, guarded pruning and detached inspection. Source and uncertainty stay with proposals. No model mutation/store tools; hosts route authentic outcomes and never blindly promote external text.
• Capacity/failure: Defaults 100 combined records, 8,000 estimated content tokens, 256 KiB strict JSON; no eviction. Active/unknown state survives compaction/rollover or fit fails. Generation/presence checks cover final managed hooks/listeners and JSON repair. Revision/capacity failure never authorizes action replay; host retains original outcomes/evidence. Direct calls bypass the view; in-flight requests cannot be revoked. Structural protection is not proof of obedience/semantic truth.
• Recovery/lifecycle: Optional version-1 plugin state preflights scope/task/ association/binding before history mutation. Legacy snapshots clear enabled state. Host checkpoints are trusted, not signed authority imports. Existing Task/ routine status types and MemorySystem transitions keep authority; explicit memory refresh uses host scope/principals, rejects cancellation/stale results, and does not restore clients or create parallel state facts.
• AMOS/examples: Optional config and /context task inspection/add/correct/ resolve; revision checks and busy rejection; edits in memory, checkpoint through /session save. Model commands stay text. Actual runner/command transcript and public offline workflow demonstrate correction, pending action, rollover, file restart and separate-process recovery. No automatic AMOS receipt/memory linkage.
• Original completion validation (before review): 7,743 units / 354 files; 112 Stage 04 cases; plugin coverage 99.55% lines/statements, 85.81% branches, 100% functions. Full local/public/type/AMOS gates, generated API (1,682 items), 19 offline scripts, CJS smoke and 18 retained scripted comparison cases pass. Final real-provider gates: 117 tests / 129 scenarios, no final failures/skips, OpenAI/Anthropic/Google all verified. The initial combined batch's legacy Google chat marker failure, exact-output diagnostics and unchanged full baseline revalidation are retained. Final counts span the successful six initial files and baseline revalidation, not one all-green batch. No predicate was weakened; the original failing output/cause is unknown. Previously consumed comparison tasks are regression coverage, not fresh held-out research.
• Handoff: Recipe, README, User Guide, generated API, AGENTS, memory guide, examples/index, AMOS, Changelog, roadmap and package inventory are synchronized. Evidence and AMOS transcript accompany the branch.
• Limits/next: Host APIs first; automatic extraction remains deferred, with explicitly invoked extractor proposals verified as a synthetic pilot only. No action journal, duplicate-effect guarantee, new workflow engine or completion- policy loop. Stage 10 is next and needs separate authorization. No breaking change.

Stage 04 review — 2026-10-15

Four defects are reproduced against unchanged delivery source/public builds:

• P1: A final budget:updated listener can change protected host state after validation; both run and stream dispatch the obsolete constraint.
• P2: Reusing a pruned correction ID can save a checkpoint that cannot restore.
• P2: At exact token/byte capacity, resolution growth fails while pruning rejects the still-active record; the default 8,000-token boundary is reproduced.
• P2: AMOS has no safe prune/recovery command after its 100-entry task cap, even for resolved records.

Fresh 7,743 units / 354 files, types, lint and built public compatibility pass. Executable evidence records 31 defect/control observations, source/public ESM/CJS, real file recovery and actual AMOS commands. No billable/live calls were needed; the original live evidence and earlier failed attempts remain preserved. A successful reproduction script asserts existing defects, not fixed behavior. See the fix plan.

Availability, recipe/standard-guide notices, adoption/handoff, roadmap, implementation record and packaged review records now show corrections pending. No runtime fixes, permanent tests, API changes, commit, push or release are included in this review. Corrective tests/examples/docs and fresh local/live validation are required before restoring completion or proceeding to the separately authorized Stage 10.

Stage 04 corrective work in progress — 2026-10-15

User authorized all four fixes. Final managed admission now spans budget observers; ID reuse detaches obsolete links while preserving inactive history; optional TaskStateHostDelta.confirmActions/prune supply atomic bounded recovery; AMOS exposes explicit prune/resolve-prune/prune-action/confirm-prune commands. Existing signatures, defaults, limits and host authority remain supported. Regression tests, workflow/restart examples and current recipe are updated; full final gates are in progress. No completion, API break, release or Stage 10 delivery is claimed yet.

Stage 04 corrective adoption — 2026-10-15

All four findings are fixed and validated; Stage 04 is complete on branch again. Corrective completion and evidence preserve earlier delivery/review artifacts and their failed attempts without relabeling them.

• Additive API: Optional TaskStateHostDelta.confirmActions (executionId, TaskStatus, source) and prune (noteIds/executionIds). Notes, resolutions, host confirmations and explicit pruning form one atomic revision-checked candidate; the final snapshot must fit, and input bounds still apply. No automatic eviction, completion, external action or replay. Archive proof before explicit reclamation.
• Correctness: Final protected task validation spans budget observers and repair. Reuse detaches obsolete correction/conflict links, keeps historical predecessors inactive, and never retargets them to unrelated data. All committed snapshots pass restoration consistency checks. IDs remain reusable after pruning.
• AMOS: Existing host adapter now accepts the optional delta fields; no required runner member. Explicit prune, resolve-prune, prune-action, confirm-prune commands reject stale/busy/invalid/unsafe operations and provide actionable capacity recovery. Terminal confirmation requires host proof. Commands make no model call; existing checkpoint semantics persist recovered state.
• Compatibility/defaults: Disabled by default; 100 records, 8,000 content tokens, 256 KiB JSON unchanged. Existing signatures, version-1/legacy snapshots, raw returns/events, lifecycle authority and one tool manager remain supported. No API break, configuration migration, new required backend/session field or release.
• Validation: 7,784 units / 356 files; 153 Stage 04 cases and 41 new regressions; plugin coverage 99.61% lines/statements, 88.21% branches, 100% functions. One final seven-file live batch passes 117 cases / 129 scenarios with no failures/skips; OpenAI, Anthropic and Google all verified. Twelve task probes add ID reuse and post-response atomic recovery without extra model/submission calls. All local/ public/type/AMOS gates, API generation (1,682 items), 19 offline scripts, 18 fixed source/ESM/CJS observations and 18 retained scripted comparisons pass. Comparisons use previously consumed fixtures, not fresh held-out quality/cost evidence.
• Handoff/examples: Recipe, README, User Guide, generated API, AGENTS, examples/ index, AMOS, Changelog, implementation/roadmap and package records synchronized. The workflow reclaims/reuses an ID and restores a second checkpoint. Actual AMOS recovers at 100 records, adds a constraint and reloads with one total synthetic response; transcript included.
• Limits/next: Host-controlled bounded notebook, not an audit archive or proof of remote completion/model obedience. Automatic extraction/replay/completion-policy loops remain deferred. Stage 10 is next and requires separate authorization.

Stage 04 second review — 2026-10-15

The four runtime corrections remain validated. Two public TypeScript compatibility regressions are now reproduced; stage completion is provisional pending compatible fixes. See the review and fix plan and executable evidence.

• P2: Adding an optional known feature makes taskState required through the exported ResolvedContextFeatures mapped type. Unchanged legacy feature objects fail compilation even with the new capability disabled.
• P2: The known plugins.taskState property narrows arbitrary configuration previously accepted for an external registry factory using that feature key. The extension still works at runtime, but its unchanged TypeScript consumer fails.
• Validation: Fresh 7,784 units / 356 files and a separate 153-case Stage 04 run pass; root typecheck, lint, existing built-package fixture and example types pass. Both task-state offline examples and source/public ESM/CJS registry controls pass. New adversarial consumers reproduce two diagnostics that disappear when only the two new declaration members are removed in memory. The first full unit attempt hit four sandbox localhost errors; the unchanged full rerun passed with socket access. No fresh LLM calls, source/build changes or permanent tests in this review.
• Adoption/handoff: Existing runtime defaults, snapshot/recovery behavior, commands and examples remain as documented. Consumers constructing legacy resolved feature values or configuring an existing external taskState factory should wait for the compatible correction. Do not adopt a workaround requiring an API break or irrelevant built-in configuration. Recipe, README/User Guide, stage/roadmap/current availability and packaged review records track this status; generated API remains unchanged because source declarations were not edited.
• Next: Fix these two contracts, add unchanged public consumers, validate and regenerate affected documentation before restoring completion. Stage 10 remains separately authorized; no breaking API change or release is approved.

Stage 04 second corrective adoption — 2026-10-16

Both TypeScript compatibility findings are fixed and validated; Stage 04 completion is restored on branch. See the completion and evidence.

• Public types: ResolvedContextFeatures retains the original eight required keys. New known additions remain optional in constructed feature/snapshot values, preserving old consumers as future opt-in features are added. Live context defaults remain unchanged. Inspect potentially older values with features.taskState ?? false.
• Extension configuration: KnownPluginConfigs.taskState accepts the explicit TaskStatePluginConfig or an existing factory's record. A registered external taskState factory retains precedence and can use its own configuration without irrelevant built-in fields. Use the explicit type/satisfies for strict built-in declarations; built-in runtime scope/task validation still applies when no external factory is registered. No new mutation tool or authority is added.
• Compatibility evidence: The new pinned root/types consumers construct old feature values and snapshot fragments and supply custom configuration without spreading current defaults or suppressing their type errors. They reproduce nine diagnostics before the fix and compile against the rebuilt package after it. The original review consumer also compiles unchanged; the intentional negative built-in type assertion continues to reject missing scope/task fields.
• Validation: 7,795 units / 357 files, including 164 Stage 04 cases and 11 new default/registry/checkpoint/failure/lifecycle regressions, pass with no final failures/skips. Eighteen source/public ESM/CJS observations, build/export checks, root/strict/example/AMOS types, expanded public consumer gate, lint, AMOS build, both task examples and API regeneration (1,682 items) pass. The expected pre-fix compiler failure and initial sandbox IPC build failure are retained; final build passes with local IPC access. No new live run for type-only production changes; earlier 117 live cases / 129 scenarios remain historical evidence.
• Handoff/examples/AMOS: Recipe, README/User Guide, generated API, example index, Changelog, stage/roadmap, package records and current availability/adoption/handoff are synchronized. Existing library/AMOS walkthroughs remain current. These type contracts need no new AMOS command/configuration or example behavior; actual app tests/types/build/session recovery and its offline workflow pass.
• Boundaries/next: No execution implementation, runtime default, limit, required storage/session/runner member or host authority changes. Tool generation refreshes transitive implementation fingerprints. No API break, package release, commit, push or Stage 10 implementation; Stage 10 remains separately authorized.

Stage 10 adoption record — 2026-10-16

• Authorization/availability: The user authorized Stage 10 with “proceed” on version2, base d8fce94 (Stage 04). Complete in this working tree; package version remains 1.2.0 and no published release is verified.
• Verified surface: Optional AgentConfig.loopPolicy, per-execution RunOptions.loopPolicy including null disable, six AgentLoop* types at root and /types, agent.getLoopDiagnostics() and optional loop metadata on existing responses/iteration/completion stream events. Internal-only pieces are the per-execution controller, response/empty-retry decisions, shared before-tool preparation and safe feedback append; these are not new public execution APIs.
• Defaults/usage: Disabled by default. Enabled recovery allowance 2; repeated-result/failure/stalled thresholds 3; callback deadline 10000 ms; repeatable-read allowlist empty. Progress/completion callbacks are optional. Existing iterations, tool deadlines/permissions and explicit ModelTask budgets still constrain execution. No automatic helper, routing, retrieval or write replay.
• Failure/effect boundary: Actual outcomes determine framework failure, preserving application success:false data. Identical admitted write/unknown calls stop in the same execution; uncertain effects require reconciliation. Fingerprinting, admissions (including pending async calls), observations and failure identities are bounded. This is not semantic or durable idempotency. Read the recipe for exact byte/count bounds and intentional polling.
• Host authority/persistence: Completion requires a bounded locally validated host verdict against actual evidence/state, separate from provider completion. Frozen packets expose omission flags/counts and optional full built-in task state. Cancellation/deadlines and stale identity/generation checks reject late verdicts. Callback functions/counters never restore as session authority; configured evidence/task recovery keeps its existing scope and durability.
• Support differences: With a policy, stream invokes shared before-tool preparation; its disabled legacy trace stays unchanged. Chunks are provisional; repaired final JSON verification remains run-only. Existing suspend/correlation flow and explicit async continuation remain, with waiting-external diagnostics. Direct/realtime/external SDK and remote-native internal steps retain their owner and are not individually controlled by this policy. Runtime observer detachment does not cancel a run; closing the owning Agent stream keeps its existing lifecycle.
• Examples/AMOS: feedback-driven-agent.ts and run-stream-equivalence.ts are public-package offline examples. The actual AMOS example uses optional JSON limits, host-only in-memory override, /context loop, blocked checkpoint recovery and a fresh verifier. AMOS displays notices separately from prose, preserves event discriminants and tests busy/cancel/late-verdict behavior.
• Validation: 7,895 units / 359 files, including 94 core and six AMOS Stage 10 cases. Policy-module line/branch coverage 96.46%/91.70%. One final eight-gate batch passes 129 live cases / 141 recorded scenarios across all three providers, including 12 new policy probes; no failures/skips. All 22 offline examples, old/new public root/types fixtures, eight new ESM/CJS controls and eighteen unchanged legacy source/ESM/CJS controls pass. Root/AMOS builds, types, lint, examples and separate project-strict checks pass; API regenerated and package dry-run inventory verified.
• Evidence/uncertainty: Validation and live history retain initial synthetic attestation/setup failures, sandbox socket denial, two Anthropic probe failures before the bounded prompt/cap change, and one unchanged Google exact-marker failure followed by recheck/final success. The initial Anthropic report lacked exact stop reasons, so no exact cause is asserted. The final source is fully validated; these functional probes do not establish statistical reliability, free-planning quality or cost improvements.
• Handoff/next: Recipe, README, User Guide, generated API, AGENTS, examples, AMOS, Changelog, roadmap/stage records and package inventory synchronized. Release-wide promotion remains tracked in the handoff ledger. No break, commit, push or release. Next core stage is 12, requiring separate authorization; conditional stages remain deferred.

Stage 10 original review — 2026-10-16

Historical pre-correction findings, superseded by the corrective adoption below. At review time, five open findings made completion provisional:

• P1 R1: Normal run injection consumes authentic async outcomes as text without importing them into its controller. An unknown write can reach the checker with no observations, while explicit continuation correctly blocks the same case.
• P1 R2: Explicit continuation without evidence derives past effect from the current registration. Re-registering a pending write as a read bypasses the uncertain-effect guard. Admission effect must remain attached to the invocation.
• P1 R3: Structured repair after a tool-induced policy stop replaces the tool call with formatted JSON. Its result becomes unmatched; even an internally retained unacknowledged raw result is omitted from later prepared requests.
• P2 R4: Without structured output/evidence, stopped run and stream leave ordinary results in pending input. The next input discards those observations.
• P2 R5: Class/prototype policy methods compile against the public type but are silently omitted by the spread copy; completion becomes unchecked.

Fresh 7,895 units / 359 files, root types/lint, examples checks, public compatibility and AMOS types pass. Deterministic scripts reproduce the missing contracts; a public class consumer compiles. No runtime fix, permanent test or new live call was added. Original delivery/live evidence stays unchanged. See the fix plan and executable review evidence. Current recipe, standard-guide notices, stage/roadmap and package inventory reflect this review. Corrections and expanded validation precede restoring completion or Stage 12.

Stage 10 corrective adoption — 2026-10-16

All R1–R5 findings are fixed on version2, base d8fce94; no package release. Async observations are imported before receiving dispatch/checks with original admitted effect, deduplication, failure bounds and scope checks after awaited host callbacks. Uncorrelated legacy possible actions block conservatively when outcomes are missing. This correlation is internal/process-local and not saved authority.

Stopped connected calls/arguments/results remain available through new input, file checkpoints and failed-evidence host repair. Normal stop commits add no model response or duplicate journal entry; JSON formatting appends a separate answer after a stopped tool turn. Early-close retention remains unchanged. Class/prototype callbacks keep the original host receiver/private fields; callback selection/thresholds are captured per execution. No new required API, session/storage field, default, discriminant, or automatic replay behavior.

Fresh final gates: 7,950 units / 360 files, including 155 Stage 10/AMOS cases; 135 live cases / 147 scenarios in one unchanged eight-file all-provider batch; 22 offline examples, 16 ESM/CJS and 18 legacy controls. Root/AMOS builds, types/lint/examples/project-strict checks, generated API and package inventory pass. The first batch's Google schema-valid empty summary was correctly rejected before main dispatch and remains recorded; no evaluator or prompt was weakened.

The run/stream example adds stopped-receipt/JSON preservation. The AMOS example uses class callbacks/private verification state with fresh host authority after checkpoint. All affected recipe/standard/generated guides, AGENTS, examples/AMOS, Changelog and availability/handoff are synced. Internal-only helpers are recorded; release-wide promotion remains pending. No later stage is implemented. See completion, validation, live history and AMOS walkthrough.

Stage 10 second corrective adoption — 2026-10-16

The recorded Google empty-summary failure is fixed. Optional public HelperCallOptions.validationSchema adds local synchronous constraints to the portable native schema; both must pass within the existing 0/1 repair allowance. No new defaults, required members, provider role, event shape or saved authority. Compactor nonempty/nonblank/600-character requirements now participate in helper repair and validation accounting. Failed generation and repair are separate task records. Repair retains original evidence and respects input/output/call/token/ deadline/cancellation bounds; exhaustion retains mask/error behavior. Custom standalone summary callbacks keep their one-call transaction contract.

An actual Google call receives an explicitly labeled substitution of the exact recorded all-empty body; one actual Google repair passes, the agent reads the source and returns exact marker/account/status without masking fallback. Normal OpenAI/Anthropic/Google probes also pass. Two rejected native-schema prototypes are development history; delivered native schema stays unchanged.

The second review also fixes pending completion/progress authority after tool user/account/connector selection/identity/role/session or registry scope changes. Such verdicts now stop as state_changed; this is internal and policy opt-in.

Final gates: 7,988 units / 360 files, 38 new regressions; 136 live cases / 148 scenarios, zero failures/skips/unavailable providers; 22 offline examples, 18 ESM/CJS, 18 legacy controls, builds/types/lint/examples/strict checks and AMOS/public/generation/package gates pass. Selected helper/compaction/loop coverage is 97.06% lines / 90.13% branches, not whole-Agent coverage.

The public purpose-model example demonstrates empty-but-shape-valid repair. AMOS uses the existing helper usage/strategy views; its guide explains recovery, with no new command/configuration required. Recipes, README/User Guide/generated API, AGENTS, examples/AMOS, Changelog, stage/roadmap and packaged evidence/handoff are synced. Branch-only availability, no package release or later implementation. See review/fix, validation, live proof and offline transcript.

Stage 12 adoption record — 2026-10-16

Core roadmap delivery is complete on branch. Public APIs are createAgentPreset, AgentPresetName/AgentPresetConfig/AgentCapabilityInspection, Agent.inspectCapabilities and the additive trusted hydration agentConfig fields loopPolicy/modelExecution. Defaults, precedence, disabled behavior, explicit host scope, custom extension identity, helper/completion/budget authority and failure behavior are covered in the recipe.

AMOS is the reference application: next-agent selection/inspection, current-config preflight, exact save rollback, explicit settings, migration, descriptive saved metadata and preserving a live agent on failed next initialization. Existing runtime host factories/bindings and driver inspection are reused. Native compaction, adaptive routing, coding profiles, automatic learning and conditional stages stay deferred. No second external SDK loop or portable/session protocol change.

Validated: 8,038 units / 363 files, 48 preset regressions plus two baseline calibration regressions, 24 live tests / 36 scenarios across OpenAI/Anthropic/Google with zero failures/skips/unavailable providers, 24 offline examples, 20 ESM/CJS public controls, builds/types/lint, strict new-test and AMOS checks, legacy/new built-package compatibility and public API generation. Focused preset factory/command coverage is 100% lines / 97.22% branches, not whole-Agent coverage. Unrelated stage live suites remain their historical validation; this stage reruns the unchanged baseline and preset smoke.

README, User Guide, generated API, AGENTS, recipe, examples/index, AMOS, release notes, roadmap/stage record and package evidence/handoff are updated. Release-wide Version 2 publication remains pending; no commit, push or package release. Next: independent review/release readiness or an explicitly selected conditional scope. See delivery, validation, live evidence and offline transcript.

Stage 12 final-gate calibration also pins supported-model baseline temperature to zero and adds payload-free response status/length/hash diagnostics. Two regressions retain strict rejection of capped/wrong outputs; no model retry, cap increase or ordinary Agent default change. Earlier vendor-default pilots remain historical; new reports record actual sampling. See baseline calibration.

Stage 12 review — 2026-10-16

At review time, seven confirmed findings were open: host-principal erasure/connector visibility, app-level failed replacement, rejected-resume cleanup, capability projection, opaque plugin config preservation, built-in protection verification, and autosave metadata retention. Nine deterministic observations reproduce them against matching source/public build with local providers and real registries/app/storage/timers. Existing focused suites pass 75 cases; strict public consumer types also pass. No full-unit or live suite was rerun for this review; previous results are historical, not proof that these missing paths work. No runtime fixes or API breaks were made.

The review withdrew Stage 12 completion pending the fix plan. The corrective adoption below records all fixes, fresh validation and restored completion. The review evidence distinguishes new preset/inspection defects from existing integration issues exposed by adoption.

Stage 12 corrective adoption — 2026-10-16

All seven findings are fixed on branch. The preset context uses the validated host principal even for explicit undefined inputs, and enabled scoped protections remain checked at managed dispatch. Compatible built-in evidence/task factories are supported; incompatible replacements fail at creation before model/action work. Plain Agent custom-plugin contracts are unchanged. Accessor/class/symbol plugin configurations retain their original receivers. Capability inspection projects only declared getter-backed basic/advanced data, rejects invalid declared values locally, and never traverses unrelated provider fields or callbacks.

Agent.resume cleans failed candidates and preserves load errors/caller-owned resources. Its session type additively accepts existing optional settings such as autosave. AMOS performs the real app/SessionCommand handoff after candidate validation/loading, keeps the old session on failure, checkpoints unstored raw observations before fresh release, and refuses active/background delivery replacement. Titles/preset labels survive periodic and unnamed saves and resume; AMOS checkpoint saves are ordered per process/location across old/new adapters. Metadata is descriptive and never restores policy or completion authority.

Internal-only changes: the preset requirement symbol and projection helpers are not root APIs or serialized authority; the metadata adapter and session-change callback belong to AMOS. No new required config member, protocol, event/status, workflow engine, implicit helper/verifier/permission, default change or API break. Host contexts/portable packages must reconstruct selected configuration explicitly.

Final gates: 8,073 units / 365 files, 35 corrective regressions / 83 Stage 12 cases; 148 live tests / 160 scenarios in one nine-suite batch with all three providers, zero failures/skips/unavailable providers; 24 offline examples, 32 ESM/CJS controls, builds/types/lint/examples, public compatibility, strict core/AMOS checking, API generation and package inventory pass. Selected new factory/inspection/command/storage helpers have 100% line / 97.09% branch coverage, not whole-Agent coverage. These are functional synthetic tests, not a general quality/cost/reliability claim.

The AMOS walkthrough now uses candidate-first replacement, checks named/unnamed save retention and proves a failed candidate leaves the live runner ready. All recipe/standard/generated docs, AGENTS, examples/index, AMOS, release notes, roadmap/stage and packaged evidence/handoff are synchronized. Earlier review/live artifacts are historical and unchanged. Core delivery is complete on branch; release promotion and conditional stages require separate scope. See completion, validation and offline transcript.

Historical Stage 12 second review — 2026-10-16 (resolved)

At second review, four additional findings reopened completion; the first seven fixes remained present. Failed resume with caller-owned context can leave a destroyed permission manager installed: the same blocklisted local tool is denied before/during loading and executes after rejected-candidate cleanup. A rejected foreign scoped session load also changes the live checkpoint ID before preflight; real AMOS periodic autosave then overwrites that foreign/task checkpoint while the configured pointer still names the original session. These are P1 permission/integrity issues.

Two P2 findings: host-local requirement snapshots spread raw scope objects and lose valid prototype getter fields; one plugin's teardown exception prevents the remaining rejected candidate resources, timers and managers from being released. The raw-load/destroy behavior has existing roots, distinguished from the newly introduced constraint/cleanup paths in the report.

Fresh review validation passes 114 focused tests / seven files and strict built-public input compilation. Six deterministic observations reproduce the four findings with actual APIs/app/storage/timers and a local write counter. Runtime/build/test/example fingerprints still match the prior final validation; no full-unit or real-provider batch was rerun. Prior 8,073-unit/148-live passing results do not cover these paths. No runtime fixes or permanent tests were made in this review; completion/handoff were pending at that time. The latest adoption below closes all four findings. See fix plan and evidence.

Stage 12 second corrective adoption — 2026-10-16

All R1–R4 findings are fixed on branch. Failed caller-context resume now preloads before candidate binding, retaining the original permissions, prompt, compaction callback, roles/tools and save target on load rejection. Success retains the same context and one read; the host coordinates shared-context handoff. High-level Agent/context loads preflight protected state, restore through existing extension hooks and commit the target only on success. Autosave/explicit checkpoint operations serialize, retaining immediate first IO. Deferred managed snapshots avoid observing tentative state; existing snapshot overrides and raw-load activation remain usable. The optional third context.save argument additively accepts a sync/async snapshot builder. No required storage/config/session/event/result member changed.

Context/plugin state rolls back on custom restore failure; if a plugin refuses rollback, saving is blocked until a valid load or host rebuild. Private/external hook effects are host-owned; restore hooks cannot await checkpoint IO on the same context. Loads require idle execution/host edits; independent contexts/backends need host concurrency policy. Normalized getter scope requirements retain tenant checks and mutation rejection. Cleanup attempts all reachable owned resources, finalizes destruction and respects shared skip ownership; direct destroy reports its first error afterwards. Original creation/load failures stay original. A throwing destructor remains responsible for its own private resources.

Internal-only: the checkpoint queue/rollback guard, restoreSession coordination and preload flag; no saved authority or new framework. The factory/inspection/ permission/provider defaults stay unchanged. The examples now show getter-backed host scope and AMOS rejected-load/subsequent-save checkpoint integrity. Public ESM/CJS consumers also prove failed shared resume leaves blocked tools denied.

Fresh final gates pass 8,116 units / 366 files, 43 new regressions / 126 Stage 12 cases, 148 live tests / 160 scenarios / nine suites with OpenAI, Anthropic and Google, zero failures/skips/unavailable providers; 30 additional load-path live rechecks pass on the final build; 24 offline examples, 44 public ESM/CJS controls, builds/types/lint/examples, strict core/ AMOS, compatibility and API/package gates. Selected new helper coverage is 100% lines / 97.07% branches, not whole-Agent/context coverage. The original six review observations verify the fixes against the final build with actual app/storage/ timers and local counters. First full unit scheduling failures were fixed while preserving existing race tests; no failure is waived. These are synthetic functional tests, not general model quality/cost claims or real service writes.

All affected standard/generated docs, recipe, examples/index, AMOS, AGENTS, Changelog, roadmap/stage records and package handoff are synchronized. Historical review/validation records are preserved. Core stages are complete on branch; no commit, push, package release, breaking change or later-stage work. See completion, validation and offline transcript.

Stage 12 third review — 2026-10-16

At review time, three findings reopened completion after the second corrective pass. Shared-context resume preloads before candidate construction but still leaves a destroyed policy manager attached when a successful-load notification throws: the original Agent is alive and its blocklisted local tool executes. A constructor rejection also leaves preloaded B history/prompt/session on the original A context. These two observations share the incomplete handoff transaction and form one P1 finding.

Two P2 findings affect the new rollback path. structuredClone rejects an existing JSON-serializable plugin state with a toJSON conversion hook, despite successful FileContextStorage serialization and direct public restoration. A valid legacy checkpoint missing a damaged plugin clears the save guard without restoring that plugin; saving then persists its unchanged UNCERTAIN_STATE.

Fresh review validation passes 222 focused tests / nine files and strict built-public input compilation. Four deterministic observations use public APIs, real file storage and a local counter; no new credentials/network/real-model calls or service writes. Runtime/build/test/example fingerprints match the previous final validation. Previous 8,116-unit, 148-live-test and 30 targeted live-recheck results remain historical and did not cover these paths. No runtime fixes or permanent tests were made in that review. Completion/handoff were pending then; JSON-only extension contracts and existing callback/event errors must remain compatible. See fix plan and evidence.

Stage 12 third corrective adoption record — 2026-10-16

All T1–T3 findings are fixed on version2, base 393b10c. Shared resume now preflights the named connector, then keeps restoration, candidate construction and the existing synchronous loaded notification inside one checkpoint transaction. Rejection restores original tool registrations, permission authority, roles, prompt, compaction callback, conversation and session target before candidate cleanup. Partial constructor failures release initialized framework resources; original notification/construction errors retain their identity even when teardown throws. Ordinary managed loads also roll back a rejected synchronous loaded notification.

Rollback snapshots follow the existing JSON serialization contract, including own/prototype toJSON and Date conversion; serialization failure precedes mutation. The save guard tracks actual damaged plugin instances. Missing legacy keys or a custom restore hook that ignores them cannot release protection. Every affected instance must actually restore successfully from a checkpoint or through existing trusted host context.restoreState(goodSnapshot); otherwise saves stay blocked. No plugin/storage/session schema, event field, required API, default, or supported JSON extension contract was removed or narrowed. No breaking change was proposed.

Permanent regressions add 27 unit cases: constructor/registry/tool-registration/ provider/connector/notification failure, policy/tool/role/prompt/callback/history/ID rollback, original continuation, queued saves/autosave, original errors and cleanup, JSON own/prototype/Date conversions in contexts/Agents/presets with real file storage, serialization-before-mutation, multi-plugin/omitted-key/ignored-hook/host repair, and actual AMOS commands/checkpoints. Three permanent live tests additionally verify original-history continuation after all three recovery paths against each provider, with zero blocked local writes. The existing preset example now shows rejected shared resume, preserved authority/checkpoint and JSON plugin restoration; built ESM/CJS/type consumers exercise the same compatibility contracts. AMOS needs no new command: fixes apply to its existing /session load and /session save flows, covered by actual app/command/file-adapter regressions and updated guidance.

Final gates pass 8,143 units / 367 files, 153 Stage 12 preset/AMOS unit cases, 151 live tests / 163 scenarios / ten suites (148/160 in the nine-suite batch, plus three focused session-continuation cases) with OpenAI, Anthropic and Google, zero failures/skips/unavailable providers; 24 offline examples, 54 ESM/CJS public controls, root/AMOS builds, types/lint/examples, strict core/AMOS, legacy public compatibility, generated API, documentation and package checks. Selected preset/inspection/AMOS helper coverage remains 100% lines / 97.07% branches, not whole-Agent/context/ToolManager coverage. All four original third-review observations verify fixed behavior on the final build. Functional synthetic fixtures and local effects do not establish general model quality/cost or real-service writes.

Internal-only plumbing comprises the synchronous checkpoint admission callback, ToolManager binding rollback, partial-construction capture and failed-plugin identity/restoration tracking. No authority is serialized. Loads require idle host execution/edits; separate contexts/backends need host concurrency coordination. Successful shared-context handoff still needs host ownership coordination. Rollback cannot undo model calls, external actions or arbitrary private listener/hook effects; restore hooks must not await checkpoint IO on their own context. Rebuild the context if a custom plugin cannot recover. Existing advanced loadRaw behavior is retained.

Recipe, README, User Guide, generated API, examples/index, AMOS, AGENTS, Changelog, roadmap, stage records, Version 2 availability/adoption/handoff and package evidence are synchronized. Historical review/validation records remain unchanged; no failure is waived. See fresh validation and offline transcript. The core sequence is complete on branch. No commit, push, package release or later-stage work was performed.

Stage 05 delivery — 2026-10-20

Historical delivery record. Current readiness is superseded by the 2026-10-21 review/fix plan.

Stage 05 is complete on version2, base 539bbd1, with no package release or breaking API change. The selected conditional scope is explicit selectable data companions, a built-in whiteboard adapter and optional stable-prefix layout. It reuses existing plugin state, storage, ToolManager, compaction, provider conversion and usage fields; it adds no retrieval index, router, sandbox or cache service.

The measured offline need fixture estimates 7,174 tokens for an overflowing legacy view and 1,284 tokens for a fitting selected view, preserving both source whiteboard entries. The selected 114-token data message includes the protected receipt, a dependent third-party provenance block and an explicit projection. These are local estimates for one synthetic fixture, not measured cost savings or proof of better general task quality.

Verified public APIs/options: optional AgentContextNextGenConfig.assembly, ContextAssemblyConfig, ContextContributor, ContextContributionRequest, ContextBlock, ContextSelectionEntry, ContextSelectionManifest, explicit registerContextContributor/unregisterContextContributor, createInContextMemoryContributor, lastPreparation.selection and host recordProviderUsage. Assembly is disabled by default. Enabled defaults are 2048 estimated data tokens, 1000ms cumulative contributor time, 128 blocks, 65536 characters per text/projection, legacy layout and zero extra reasoning reserve. Source caps, expiry, priority, protected full dependency closure and explicit projections are supported. Optional host tokenEstimator reuses ITokenEstimator, checks nonnegative safe counts and preserves method receivers; default estimation remains unchanged.

New data is JSON user data, never host authority. Reserved evidence/task-state/ persistent-instruction views cannot be replaced. Companions attach only to existing plugins, carry scoped/revision-checked source data and observe cancellation. Missing/ expired protected dependencies, cycles, malformed/oversized blocks, stale input/ model/principal/account/roles or changed selected prefixes reject explicitly. Deadlines count contributors across rebuilds, excluding existing legacy hooks and compaction. Legacy observation hooks remain nonblocking. Exactly the existing bounded compaction path remains; final dispatch and JSON repair retain all selected protections. Formatting reuses frozen selected data without new contribution or compaction work, preserving main diagnostics.

Stable-prefix layout retains legacy authority while moving dynamic data/date later and sorting visible tools deterministically. Host dynamic instructions may still change that prefix. Manifest fingerprints are scoped local diagnostics, not provider cache keys. Actual normalized provider input/cache counters remain distinct from local estimates, with null for unknown and zero for observed zero. Host/provider/ registry/fallback capacity is attributed honestly; opaque/multimodal estimates remain uncertain. No automatic cache hit, provider cache policy or estimator tuning is claimed.

Existing plugin/storage/session/event/result interfaces and defaults are preserved. No structural method discovery occurs, including existing similarly named helper methods. Sources persist normally; callbacks, policy, selected views and diagnostics are not restored as authority. Reattach trusted companions after restart. Trusted host callbacks must maintain pure revisions and scoped access; the framework cannot undo private side effects or preempt synchronous host JavaScript. Legacy/default execution and direct/external paths retain ownership. All adaptation is opt-in.

AMOS accepts JSON contextAssembly (no callbacks/tokenizer), optionally attaches the whiteboard adapter at initialization/resume, and shows selected/omitted/projected IDs/reasons plus actual/unknown provider cache counters in /context breakdown. Inspection does not prepare, compact or call a model. Actual runner/command tests and three new public offline examples cover this adoption. No new workflow completion, permission authority or default preset behavior is introduced.

Final validation passes 8,217 unit tests / 371 files, including 74 new Stage 05 core/AMOS cases; 166 live tests / 178 scenarios / 11 suites with OpenAI, Anthropic and Google, zero failures/skips/unavailable providers; 27 offline examples, 12 new ESM/CJS controls plus 54 existing preset controls, root/AMOS builds, types/lint/examples, strict core/AMOS, legacy/public consumers, generated API and package checks. Selected new assembly/inspection coverage is recorded in the validation artifact; it does not describe whole-Agent/context/AMOS coverage.

Development failures are retained and fixed: JSON repair needed the frozen selected prefix after normal history commit; cumulative deadline needed to exclude old hooks/ compaction; host-capacity attribution and changed-model admission needed explicit checks. Pre-preparation inspection is metadata/legacy estimation only and never starts new contributors. A queued history-journal teardown race is fixed by awaiting admitted IO before deleting temporary fixtures. An existing comparison reader now returns bounded scoped raw notes keys on selector errors, never answers; its explicit zero-temperature main/helper sampling is recorded and differs from older pilot conditions. An initial Anthropic cache fixture refused repetitive directive text; the normal synthetic catalog lookup retains actual answer, output/call budget and usage assertions, without requiring cache hits. The final full provider batch passes; there is no automatic retry, skip or waiver or output-cap increase. AMOS example/mock type assertions were corrected without weakening runtime tests.

Recipe, README/User Guide/generated API, AGENTS, examples/index, AMOS, release notes, roadmap, Version 2 availability/adoption/handoff and packaged records are synchronized. See validation and offline transcript. No commit, push, release, approved API break or implementation of another conditional stage was performed.

Stage 05 corrective adoption — 2026-10-21

All R1–R5 findings are fixed and validated on version2, base 539bbd1. No breaking API change, commit, push, package release or later-stage implementation was performed. The original review and delivery results remain historical.

• Effective accountId, connectorAccounts, taskId and opaque registry-instance identity join existing principal/identity/role/session guards. Credentials and registry internals are never serialized; same-instance custom scope changes still require host-scoped contributor revisions.
• Managed hook/request-listener history/input edits get one bounded selection refresh against the actual sanitized submitted input, sharing the preparation's remaining contributor time. Hooks and compaction are not repeated; concurrent mutation, cancellation, stale scope/revision, expiry and overflow fail before dispatch. Failed refresh consumes its attempt. Original source history ownership is preserved.
• JSON formatting permits the normal answer commit while checking the current host prompt and original history/input prefix, plus existing task/scope/source/fit guards. Main diagnostics stay intact; stale repair never repeats a settled tool action.
• Selected-store overview and store_get guidance describe partial visibility and exact recovery. Native schema objects/CRUD returns stay unchanged, including frozen class-backed schemas/private getters; unregister restores legacy guidance.
• Max-iteration run/stream and suspension wrap-ups record actual last-request input/ cache counters, distinct from stream aggregates. Missing counters stay null and measured zero stays zero. Post-cycle consolidation performs no contributor fetches outside preparation ownership/deadlines.

The new dispatch-safety example demonstrates hook refresh, stale-prompt repair rejection and synthetic wrap-up accounting. The selection example now verifies exact omitted-source recovery and stale-account rejection: its retained-source fixture estimates 7,174 → 1,295 tokens, with both entries preserved. The AMOS walkthrough forces one local read and a wrap-up, showing per-request usage and retained whiteboard data. Usage in offline providers is explicitly synthetic.

Final validation passes 8,291 unit tests / 372 files, including 74 new corrective cases (72 library and two AMOS); 184 live tests / 196 scenarios / 11 suites, OpenAI/Anthropic/Google, zero failures/skips/unavailable providers; 28 offline examples; 28 Stage 05 ESM/CJS controls and 54 retained preset controls. Root/AMOS builds, types/lint/examples, strict/legacy/public consumers, generated API, selected coverage and package checks pass. Coverage of assembly.ts and the AMOS inspection adapter is 100% lines / 91.19% branches; this does not claim whole Agent/context/store-manager/AMOS coverage.

Validation also corrected fixture setup instead of waiving failures: wrap-up tasks explicitly include their source marker in summaries, retaining exact completion, read and accounting assertions; the Google compactor probe explicitly requests 128 reasoning tokens and temperature zero within its unchanged 4096-token output cap, with actual request capture and injected-empty recovery. Production thinking and output defaults remain unchanged. The exact default/disabled prompt comparison freezes Date, and AMOS teardown awaits admitted checkpoint/journal IO before deleting fixtures. No sleeps, automatic test retries, cap increases or skipped providers were added. Historical failed batches and resolutions remain in the validation record.

All adaptation uses existing connectors, sources, tools, ModelTask and usage fields. Registry identity/input/repair bookkeeping and prompt-only schema overlays are internal; no required plugin, public signature, saved configuration/session or storage contract changed. Version 2 availability/adoption/handoff, the recipe, README/User Guide/AGENTS, regenerated API, examples/index, AMOS, Changelog and packaged evidence are synchronized. Release-wide handoff remains tracked; another conditional stage requires separate authorization.

See validation, completion and transcript.

Stage 05 second-review adoption status — 2026-10-21

Current completion is withdrawn pending S2-R1/S2-R2 (P2) and S2-R3 (P3). See the review/fix plan and evidence. The library's own post-cycle consolidation and first suspension/session assignment can invalidate structured formatting; uncertainty metadata misses native image/file result arrays and opaque tool signatures. These are correction requirements, not completed limitations.

All 34 prior runtime/build/test/example fingerprints still match. Fresh validation passes 241 tests in eight files, the built public compatibility consumer and 82 ESM/CJS controls. Ten assertion-backed offline observations establish the findings and controls. Full units and actual-provider suites were not rerun for this framework-only review. Prior R1–R5 fixes and their 8,291-unit / 184-live-test / 196-scenario validation remain historical coverage. No runtime/API changes, external service writes, commits, pushes, releases or later-stage implementation.

Correct internal lifecycle coordination without dropping current host/scope/revision guards, replaying accepted actions, adding required session fields or expanding preparation work. Recheck examples/AMOS, update affected standard/generated docs, and record full corrective validation before restoring completion.

Stage 05 second-corrective adoption — 2026-10-22

All S2-R1/S2-R2/S2-R3 findings are fixed and validated; the prior first-review corrections remain implemented. See the latest completion. Selected structured formatting precedes consolidation and suspension persistence; source/scope/host/task guards remain intact. Failure preserves the accepted observation for explicit checkpoint recovery without action replay. Native result images/files and opaque tool signatures set uncertainty; AMOS shows a source-free notice. The dispatch-safety example illustrates both lifecycle corrections.

Final validation: 8,340 unit tests / 373 files, 190 live tests / 202 scenarios across all three providers, 28 offline examples and 92 public ESM/CJS controls. All build/export/type/lint/examples, strict/public/AMOS and generated API gates pass; no live failures/skips or unavailable providers. The six added live cases cover actual provider formatting under controlled candidate pressure and structured local submission/suspension. Offline/public tests force default spill, native repair, storage/cancellation recovery and restored continuation. Public signatures, defaults and session/event/result shapes remain compatible; internal execution-local coordination adds no persistent authority.

Recipe, standard/generated docs, examples/AMOS, release notes, availability and handoff are synchronized. Historical evidence remains intact. No commit, push, release, breaking API change or later-stage implementation.

Stage 16A adoption record — 2026-10-22

• Current review status: Third-review T1–T3 are corrected and validated. Prior R1–R5 and second-review S1–S3 corrections remain present. Provider construction-time service selection, shared OpenAI wire/count normalization, bounded frame reuse/cancellation, early ownership rejection and stable-clock compatibility are verified. Plugin-only mode ignores a previously bound native driver. No new public configuration or mandatory migration is added.
• API/defaults: ContextCompactionStrategy, configuration/report/target types, optional ITextProvider.compaction and Agent.compactContext() are public. Algorithmic stays default; instance-over-name precedence and old signatures, feature defaults, return/event shapes and session version remain compatible. Persisted native digests normalize JSON object-key ordering for faithful JSON/JSONB storage. A private symbol bridge avoids colliding with old custom-context methods and works across public ESM/CJS formats. There is no new registry strategy name.
• Support/protection: The native recipe records verified providers/models, text/local-function support, exact recent/ pending/host state, source acknowledgement, counted-frame fit, contributor and transport freshness, and deferred hosted/multimodal/SDK/realtime ownership.
• Usage/failures/persistence: Native calls share the main connector/model and active ModelTask, including late or unusable billed responses. Anthropic uses iteration/cache counters. Optional bound snapshots require faithful source and session storage; authority/configuration is reconstructed by the host. Errors distinguish uncommitted history from an already committed checkpoint failure. Recovery never repeats a historical action. Source/metadata/backend quotas and lossy recall boundaries are explicit.
• Examples/adoption: example:native-compaction, example:native-recovery, example:native-comparison, example:native-hooks, example:amos-native-compaction; all default offline. Recovery runs in a separate process; native provider tests exercise repeat, persist, resume and stream with actual APIs. AMOS persists both controls, protects incompatible switches and distinguishes actual input counts from component estimates.
• Prior corrective validation (historical; does not close T1–T3): Evidence and offline transcripts. All 8,507 units, 199 live tests across three providers, 33 offline programs and 158 public controls pass with no failed/skipped required cases. Nine native live cases include hook facts, selected data, cancellation/recovery, repeat/restart/ stream and actual raw-input counting. All build/type/lint/examples/AMOS/strict/ generated-doc gates and 171 focused cases pass. The initial delivery, first corrective record and both review repro records remain historical evidence.
• Comparison boundary: One fixed held-out task passes all exact answer, account/status and no-repeat/write predicates under all four policies. Actual task usage and registry cost estimates are retained in the evidence; no general quality/cost improvement or retention-policy result is claimed.
• Documentation handoff: Native recipe, standard README/User Guide, generated API, preparation/strategies/selection/evidence/model-task guides, AGENTS, examples, AMOS, Changelog and package inventory updated. Internal frame/usage/binding guards are implementation details. Package version remains 1.2.0 with an unreleased entry; no package release, commit or push is asserted. Stage 16B and all additional stage work remain unauthorized.

Historical Stage 16A second-review status — 2026-10-22 (resolved)

The second review reopened hook memory, proof cancellation and Anthropic reasoning findings despite the passing 8, 454-test suite. Eight deterministic repro/control cases are retained in review evidence. The completion below closes all three with actual runtime corrections and fresh validation; those findings are not supported behavior or outstanding limitations.

Stage 16A second-corrective adoption — 2026-10-22

• Available on branch: Existing beforeCompaction hooks may save whiteboard/ notes data. One bounded refresh incorporates changed plugin content/revision; unchanged hooks reuse the first frame. Source, host controls, scope, identities, tools and later async changes stay guarded. No hook replay or second compaction pass is added.
• Cancellation and persistence: Execution/ModelTask signals stop read-only native evidence proofs, including action acknowledgements and archive readback. Late reads cannot resume dispatch/commit. Admitted writes retain ownership until settled. Cancelling an execution waiting on an independently started session load releases its slot; the next execution still waits for the original checkpoint and cancelled startup input is not committed. Standalone load APIs keep their storage lifecycle. No storage interface or saved-session field is added.
• Provider support: Anthropic native operations reject top-level Responses reasoning before discovery/counting/archival instead of dropping it. OpenAI reasoning, supported Anthropic signed thinking and ordinary non-native conversion keep their existing behavior. Hosted/multimodal/server-owned and 16B extensions remain deferred.
• Adoption: npm run example:native-hooks defaults offline and has bounded -- --live=openai/anthropic modes, expected behavior and cleanup. AMOS uses its existing cancel and compaction commands; a real runner/command regression verifies recovery before an old file-backed read resolves. No new AMOS setting or command is required.
• Validation/handoff: 53 new unit regressions and two new live cases; 8,507 units, 199 live tests on all three providers, 33 offline programs, 158 public controls and all build/24-export/type/lint/examples/strict/AMOS/generated-doc gates pass. Focused coverage is explicitly narrow. Recipe, standard guides, generated API, agent instructions, example index, AMOS docs, Changelog, roadmap and packaged evidence are synchronized. No public API/default/extension/event/ return/session break, verified release, commit/push or additional stage is claimed.

Historical Stage 16A third-review status — 2026-10-22 (resolved)

The review/fix plan reopened completion for T1–T3 at the review-only checkpoint. The completion below closes all three; the following reproduction evidence is historical. Native admission can silently omit incompatible nested thinking; explicit compaction skips the preservation hook; and valid fixed Anthropic thinking can conflict with the native operation's forced output cap. Existing source archives remain intact in the reproductions. These are defects to correct, not newly accepted support limitations.

Fresh validation passes 8,507 units / 377 files, 171 focused cases / 5 files, root/consumer types and 66 native ESM/CJS controls. Nine synthetic repro/control cases expose the untested paths. The earlier 199 live tests are historical; no real model call was required to establish these local control/conversion defects. Runtime and test-suite files are unchanged. The correction handoff must include regressions, relevant live/provider verification, examples/AMOS checks and current standard/generated docs/package inventory. No API break or Stage 16B is proposed.

Stage 16A third-corrective adoption — 2026-10-22

• Available on branch: Explicit compactContext() targets run the preservation hook once with automatic mode disabled, retain the same bounded refresh and measured events, and preflight scope before hook/counting work. Checkpoint retry preserves memory without replaying compaction. No new configuration is needed.
• Replay: First-party nested thinking needs a faithful provider representation; foreign/incomplete replay fields reject before I/O/reduction/archive. Exact matching-provider fields and custom native-adapter contracts remain supported. Ordinary non-native converters and legacy defaults are unchanged.
• Thinking and budgets: Anthropic native calls preserve main thinking. Fixed budgets get budget + 4096 summary tokens by default, bounded by model output capacity. Explicit caps are respected; known conflicts reject before archival. Actual wire caps, source headroom and ModelTask reservations agree. Streaming transport remains internal; cancellation closes it, and unusable summaries keep acknowledged iteration usage. No public return/session field is required.
• Examples/AMOS: npm run example:native-hooks-manual defaults offline; add -- --live=anthropic for fixed thinking budget 8192 or -- --live=openai. Existing AMOS manual commands preserve and checkpoint the host note. No new app setting or command is added.
• Validation/handoff: Evidence records 8,584 units / 77 new regressions, 248 focused cases, 201 live tests on all three providers, final-source revalidation of all 11 native cases, 34 offline programs/modes, 158 public controls and all build/type/lint/examples/strict/AMOS/ generated-doc gates. Focused coverage is explicitly narrow. Recipe, standard guides, generated API, AGENTS, example index, AMOS docs, Changelog, roadmap and package inventory are synchronized. No break, release or Stage 16B is claimed.

Stage 14A adoption record — 2026-10-22

Current review status: All S1–S3 findings are corrected and validated. Completion and compatibility and new validation supersede the historical review and first corrective gates below.

• Availability: Implemented on version2, based on cf87b4a; second-review corrections complete. 8,775 units / 385 files, 224 live tests / 13 suites across OpenAI, Anthropic and Google with no required skips, 39 offline modes and 202 public ESM/CJS controls pass. Package release remains unverified. The user approved 14A with “proceed”; 14B remains separately reviewed and deferred.
• Adopt: Configure optional modelExecution.routing.routes with named connector/model profiles and optional bounded select. Use managed per-run routing hints, explicit route or null opt-out. default is the configured main identity. Complete recipe.
• Defaults/limits: Routing disabled when absent; no hidden classifier. Up to 16 alternatives, 64-character names, 128-character hints and 512-character reasons. Default selector timeout 1000ms, fallback default only for selector exception/timeout, stickiness run. Invalid/incompatible routes and budget/ cancellation failures do not silently fall back. Phase pins require this exact explicitly shared ModelTask and latest nonempty phase, and only follow dispatch.
• Context and authority: Same plugins/tools, selected-model preparation and capacity, one run binding through tools/recovery/retries/repair/compaction. Public default model/connector/context remain unchanged. Other accounts require explicit transfer approval; signed/native state requires exact compatible owner. Host-configured authorized routes resolve native checkpoints with existing scope and evidence proof; saved policy never grants authority. Authentic async/suspended continuation keeps the original task, route and output settings.
• Persistence: Optional credential-free origin metadata; no required snapshot fields/version change. Callbacks, pins, budgets, approvals and ModelTask authority are not restored. Existing sessions/default APIs remain supported.
• Usage/failures: Optional response/existing stream-completion routing and getRoutingDiagnostics() identify selection, source/reason and wall time. Actual per-model calls, repairs, compaction, unknowns and costs remain in the shared task ledger. No cross-model replay, hidden allowance reset or workflow success assertion. Scope/endpoint/hook drift fails before dispatch.
• Support boundaries: Managed run/stream only; helpers, direct/external loops and explicit maintenance keep configured owners. Cross-vendor vendor options require explicit compatible replacement. Native model support/hard-cap limits still apply. Streaming repair remains unsupported. Managed non-streaming repair now retains original admitted task evidence and host instructions even without routing or selective context. Anthropic native count uses compaction mode for exact terminal assistant bodies; final native source guards survive budget observers.
• Examples/AMOS: example:model-routing, example:routing-context and example:amos-routing default offline, assert lifecycle and clean up. Explicit live modes use .env and bound billable calls. /routing configures named alternatives, saved JSON host category rules/hints, explicit choice/default/ auto/off and shows actual decisions; helpers remain independent.
• Historical initial delivery evaluation: All 8,688 units / 382 files, 216 live cases / 13 suites, 37 offline modes, 182 public ESM/CJS controls and build/type/lint/examples/AMOS gates pass. The live gate uses the complete matrix plus an entire 14-case accounting-suite rerun after a fixture correction; earlier failures remain in the evidence. The fixed six-task pilot compares main-only, fast-only and routing across three providers with exact held-out oracles and uniform settings. Main/routed quality and >=5% registry token-cost reduction are required; all failures/repairs/unknowns remain accounted. The pilot supports only its recorded fixtures, not a blind benchmark or general savings/quality claim. Evidence.
• Handoff: Recipe, approved design/delivery, this availability/adoption/ledger, roadmap, README, User Guide, generated API, AGENTS, affected specialist docs, examples/index, AMOS docs/commands/tests, Changelog and package inventory are synchronized. Release-wide publication remains pending.
• Internal-only corrections: Execution-owned provider binding, effective preparation model, native restore resolver, dispatch callback for actual phase admission, source-preserving repair frame, task retention and exact compaction count mode require no new storage/provider members or extra stream event kind.

Historical Stage 14A review checkpoint — 2026-10-22 (resolved)

Reviewed routing/configuration, binding/authority, managed run/stream, structured repair, async/suspended lifecycle, budgets, native restore, AMOS and documentation. Three deterministic counterexamples were reproduced through the built public API; 275 existing focused tests and the public compatibility consumer still pass. The implementation matches its 44-file delivery manifest. No runtime changes, new full-unit/live validation, release or Stage 14B implementation is claimed.

That review required R1–R3 fixes before restoring completion; the corrective record below closes them. Retain original routes/tasks, local JSON parsing/repair and host completion checks, checkpoint proof and portable legacy contracts. Corrective delivery must add regressions, validate affected/full gates, and synchronize the recipe, standard/generated docs where affected, this adoption record and package inventory. Review/fix plan.

Historical Stage 14A first corrective adoption — 2026-10-22

8,723 units / 383 files, 221 live cases / 13 suites, 38 offline modes and 194 public ESM/CJS controls pass with no skipped required case. The complete live matrix uses OpenAI, Anthropic and Google and includes five new suspension/native cases. 35 new unit regressions and the extended ESM/CJS controls close all three findings. The focused routing module has 100% lines/functions and 92.89% branches.

• Saved opaque history keeps post-hook/retry/reservation owner guards when routing is omitted. Newly observed opaque output retains its admitted identity; portable legacy model hooks remain supported. No new required session member/version.
• Suspended run(event) inherits format/route/task, applies supported explicit options consistently and performs bounded JSON parsing/repair before the host completion check. Data prohibitions remain restrictive. Local JSON remains parse-only; streaming retains its no-repair boundary.
• Native binding follows route selection, so an unsupported unused default does not prevent a supported alternative or exact-owner checkpoint restoration. Actually selected unsupported routes fail before generation/new input. Explicit idle maintenance and nonrouting constructors retain their existing owner rules.
• example:routing-suspension adds a deterministic wait/resume/repair/check recipe; example:routing-context demonstrates an unsupported default with a supported native alternative and unchanged plugins/tools. AMOS has matching adapter coverage; no new command/configuration field is needed.

The corrective evidence records resolved fixture/mock/temporary-journal incidents without treating earlier failed runs as passing. Original evidence remains unchanged. No breaking API, default change, additional required provider/storage interface, later stage or release.

Historical Stage 14A second review — 2026-10-23 (resolved below)

At review time, three confirmed findings reopened completion:

• S1 / P1: Structured repair can retain signed/provider-owned content without origin bookkeeping, allowing a later nonrouting hook to dispatch it on another model. Top-level repair reasoning is omitted from persisted history.
• S2 / P1: A budget-rejected event resume clears its suspended origin before admission; an ordinary retry can use a fresh ModelTask, choose another route and lose the inherited format.
• S3 / P2: Ordinary-context suspension saves/publishes before formatting, so the durable assistant history can differ from the returned parsed answer; a formatting failure can follow an already published suspension.

At review time all 60 source-manifest files matched the first corrective delivery. Those review checks passed 830 tests / 19 files, public types and 194 ESM/CJS controls. Eleven additional asserted observations through the built public package establish the defects and controls, including real file checkpoint/correlation storage. No runtime, shipped test/example or package configuration was changed; no new full-unit or live-provider gate is claimed. Original evidence remains unchanged.

Keep legacy portable hooks, parse-only JSON coercion, direct/idle ownership, supported snapshot/provider/storage contracts and the streaming no-repair boundary. Durably preserve acknowledged waits; never register them again to repair state. Fix plan and review evidence.

Stage 14A second corrective adoption — 2026-10-23

The three second-review findings are corrected and fully validated on branch. 8,775 units / 385 files, 224 live tests / 13 suites across OpenAI, Anthropic and Google with no required skips, 39 offline modes and 202 public ESM/CJS controls pass. All build/type/lint/strict/AMOS and generated-documentation gates pass. The completion record and machine evidence retain the original review separately from this corrective delivery.

• Adoption: No new required API, provider/storage member or AMOS setting. Existing optional routing, response formats and task sharing keep their defaults. Repair preserves ordered opaque state and its actual admitted origin even when routing is absent. Portable-only history keeps supported model hooks. Managed replacement rejects a changed response boundary instead of overwriting another observation; the public content-only helper is unchanged.
• Recovery: Rejected resumed preparation/hook/budget attempts keep the same task, selected owner, effective options and limitations. Success releases them; host cancel(reason) deliberately abandons pending execution authority without undoing an action or deleting its receipt. A terminal stream event releases ownership even if the consumer closes there. Streaming still gains no JSON repair.
• Persistence/failure: Structured suspension finalizes before saving/correlating and publishing success. Failed finalization preserves the actual registration with optional snapshot metadata.suspensionFinalization diagnostics and its correlation, without claiming a valid suspended answer. Dual finalization and recovery failure retains both errors. Storage failure needs explicit host repair; preserve live observations before teardown. No action is repeated to recover bookkeeping. Snapshots keep existing versions and do not restore budget, callback or authorization authority. Journals keep their existing optional replacement extension point and ordered correction behavior.
• Examples/AMOS: example:routing-suspension -- --failed-finalization demonstrates a two-call allowance, repeated denied event retries, one actual wait and its saved diagnostic. Existing success mode still demonstrates inherited JSON repair/host completion. Real AMOS runner tests cover both run/stream rejection and explicit cancellation; no new command is needed. Public ESM/CJS controls exercise repaired protocol ownership; live provider controls check checkpoint ordering and spent allowance without replaying registration.
• Handoff: Routing recipe, README, User Guide, AGENTS, generated API, examples index, AMOS guidance, Changelog, roadmap/design/delivery/review records and package inventory are updated in this delivering slice. Prior review and validation records stay historical. Branch availability remains separate from publication; no breaking change or later stage is authorized.

The final live gate additionally found that Google GenerateContent ignored explicit thinking.enabled: false. Supported Gemini 2.5 Flash/Flash-Lite models and preview aliases now send zero thinking budget through the shared Google/Vertex converter. Undefined defaults, enabled thinking, raw vendor overrides and other models/APIs retain their behavior. Fourteen new regressions cover this mapping; the original pilot quality/cost thresholds remain intact. See the recipe and its linked Google documentation for model-specific support. No default or public signature changes.

Consumer execution hardening — final plan revision 5, 2026-10-23

Historical planning checkpoint: revision 5 was subsequently approved and C1 implemented; see the C1 delivery below. C2–C9 remain proposed and unimplemented. The review totals in this checkpoint describe planning validation. Read the validated plan, final API design, holistic review and revision-3 evidence, the registry follow-up and its revision-4 evidence. The consumer investigation found real integration gaps, not missing foundations in every managed Agent. Do not advertise composed support before its delivery.

Breaking old agents is excluded. Existing signatures/defaults, callbacks/statuses, raw results/events, configurations/session/storage contracts and literal protocol v2/strict messages remain unchanged. Upgrading alone enables nothing new. The selected new facades reuse existing engines and separate types where needed. No automatic preset change, migration or future default flip is planned.

Revision 4 replaces only the unimplemented C6 built-Agent factory proposal: full configuration must precede plugin/tool/lifecycle initialization. Returned complete config has no hidden deep merge; library hierarchy/required tools/workspace are composed with collision rejection. Workers never automatically inherit incompatible root inference/account/identity policies. C9 tracks are independent and require their own API/evidence gates. Current strict temperature rejection is intentional; native count currently does not run that validator. No default behavior is changed to reconcile these surfaces by this plan.

Revision 3 removes the duplicate legacy mode, public enhanced-factory registry, universal inspector and implied optional workflow database. Durable routine restore is deferred C3-R; durable cursor codecs, production backend design, distributed hard-budget authority, Stage 14B/16B and consumer upgrades are separate. After restart, acknowledged evidence may recover; no workflow cursor/task authority or exactly-once effect is invented. Uncertain writes are never automatically replayed.

Current public RunOptions has no signal. Private selected-path cancellation must respect the actual Agent lease/controller; supported helper/tool APIs receive signals directly. Child timeout does not cancel a borrowed shared task/siblings; host-shared cancellation can intentionally stop the operation. Verification checks task readiness before dependencies and the final artifact after post-steps. Waiting routine-tool children retain their Agent/receipts until terminal cleanup/recovery.

Fresh holistic validation passed 334 tests / eight files, 202 public ESM/CJS controls, the existing built-package TypeScript consumer and the strict compile- only API prototype. 17 characterization observations still match the current legacy gaps/support/constraints; these are not 17 fixes. Proposed API declarations are not a runtime implementation. No live calls/full-unit rerun are claimed for this design-only work. Earlier Stage 14A full/live evidence remains historical.

The inspected backend/web consumers pin Git 991a977b769eabe6c43ec8eff6d057b20f0663d9, labelled 1.1.8 in lockfiles. The new follow-up reports desktop 33d70ade5 uses that same 1.1.8 pin, superseding its author's earlier 1.1.1 claim; desktop installation remains report-attributed. Before delivery freeze exact consumer-pin and current-branch fixtures, then require paired legacy/new-path gates. No application file or dependency was changed. Historical revision-2 document hashes remain in the original investigation record; the holistic record owns revision-3 artifacts, and the follow-up record owns revision-4 artifacts and fresh follow-up checks.

Approve the roadmap/core direction/exclusions; select implementation one slice at a time, starting with C1. C7 exact wire schema is a stage-entry review, with no change to the compatibility requirement. C8 coverage starts in C1; C6 and C7 are independent. C9-A/B/C are separately selectable. ICOS retains its current temperature guard, VAD/email/context/identity fixes and presentation until explicit adoption. Realtime companion adoption needs selector integration as well as a normal pin upgrade; unknown provider support is never converted into a guessed effort or default.

Fresh revision-4 follow-up validation passes 196 existing tests / nine files, 202 public ESM/CJS controls, the legacy TypeScript consumer and the revised strict proposal with 12 negative type controls. Seven mocked offline observations confirm current gaps/controls; all 63 earlier runtime hashes still match. This is planning evidence, not runtime delivery, a full/live rerun or app validation.

Consumer plan simplicity review — revision 5, 2026-10-23

This historical planning checkpoint preceded C1 selection and delivery below. The final review resolves nine design issues and owns the current approval boundary. Core API ownership/precedence is canonical in the API proposal, with C9 evidence/constraints in the follow-up. Direct calls reuse their existing signal; selected routine continuation has explicit failed-admission behavior and bounded observations. Enhanced-tool adoption includes connector-source registration and no accidental legacy aliases; manager-local catalog integration is a required C5 gate. C6 distinguishes shared board/evidence/task scope from exclusive conversation ownership. Its forbidden keys apply to variables and JavaScript, not just fresh TypeScript literals. C8 requires current backends, without an unapproved production backend. C9 reuses model/parameter facts and pure presentation.

Fresh checks pass 500 tests / 16 files, 202 public ESM/CJS controls, the legacy TypeScript consumer and strict proposal with 14 negative controls. All 29 offline characterization observations match current gaps/compatibility controls. The revision-5 record owns current artifact hashes and exact commands. Earlier review/full/live totals remain historical. No runtime or consumer code changed and no new capability is available. C5 catalog adapter/C7 wire/C9 exact signatures keep explicit stage-entry API gates; unresolved required gates block completion. Select one slice after plan approval; all existing test/example/AMOS/handoff requirements remain.

Consumer C1 — invocation-owned failure reporting, 2026-10-23

Availability: complete on branch; no package release. The user approved revision 5 and selected C1. Root createOutcomeTool(), OutcomeInvocation and OutcomeToolOptions provide explicit operational failure provenance through the existing shared tool manager. Existing ToolFunction/ToolContext, raw results, business declines, callbacks, retry/breaker defaults, sessions and v2 messages remain. Read the recipe and delivery/validation.

Adoption is explicit: construct an outcome-aware callback and call invocation.reportFailure(new Error('Public-safe failure message')) for a caught operational error. Read cancellation from invocation.context?.signal. First report wins; its reporter retires after callback settlement. Direct execute has no framework outcome; use executeWithOutcome for diagnostics. Library account wrappers and ESM/CJS/duplicate bundles are supported; arbitrary replacing decorators are not implicit bridges. Large/raw evidence and late/cancelled observations retain the existing protection/recovery behavior; no failure causes action replay.

Examples: example:outcome-aware-tools and example:amos-outcome-tools, both offline with deterministic outputs and cleanup. AMOS already has the needed outcome renderer; its real-result adapter test is extended without new commands/configuration. C1 live run/stream uses synthetic tools on all three configured providers. Rich remote outcome/evidence parity remains C7; bundled connector profiles remain C4/C5. No saved executable authority or new storage fields are introduced.

Final gates pass 8,814 units / 386 files, 230 live tests / 14 files across OpenAI, Anthropic and Google (zero failures/skips), 382 public runtime assertions, 41 offline example modes, build/export/type/lint/compatibility checks, generated API/docs links, AMOS types/build and the 269-file package dry run. The six new live cases preserve raw results while distinguishing business declines from reported failures. See exact validation for resolved fixture incidents and final artifact hashes. Next is private C2 after separate selection; no partial routine facade is published.

Consumer C2 — private foundation, complete on branch

The full remaining consumer sequence is authorized. C2 adds private composition ownership, explicit task/signal binding and late-work occupancy around existing engines. No new public routine options, managed-run signal or status union is available in C2. The complete facade is C3. Read the delivery record and run example:composite-binding for the supported public accounting recipe. AMOS operation commands accompany C3 rather than an incomplete internal API. All gates pass: 8,847 units / 387 files, 236 live tests / all three providers with zero failures/skips, 450 package/runtime assertions and 42 offline modes. The review fixed admission order, cross-bundle and identity guards, native/stream late occupancy, cleanup holds and binding immutability. Public signatures, old routine semantics, callbacks, contexts and sessions remain.

Consumer C3 — verified routine adoption (complete on branch)

createRoutineRunner and its root-exported types are opt-in. Required host verification gates leaf/group readiness and final state after post-steps; strict reflection checks boolean plus score. Shared ExecutionBinding forwards a borrowed ModelTask/signal through nested execution. Authorized opaque continuation preserves the cursor without replay; close revokes it without claiming external writes stopped. Default view/operation limits are 1 MiB/32. Source recovery uses existing backend references and does not waive context evidence protection. Borrowed Agents/tasks remain host-owned; asTool retains and eventually disposes a fresh child. No workflow restart, C3-R backend or old API migration is delivered.

Adoption: read verified routines, run the offline example, then explicitly supply real host/provider checks. AMOS has /routine demo|inspect|confirm|cancel with a synthetic host gate. README, User Guide, examples, AMOS docs and unreleased changelog were updated; regenerate API_REFERENCE from public exports and verify packaging before completion. No package release or ICOS dependency adoption has been verified.

C3 completion gates: 8,885 units, 239 cumulative three-provider live tests plus final three-provider C3 smoke, 594 runtime assertions and 43 offline modes pass. Build, types/lint, compatibility/prototype negative controls, example/AMOS types, generated API, documentation links and 277-file package inventory pass. Read the C3 delivery record and exact validation. The final source distinguishes true scheduler skips from business payloads, correlates repeated nested task IDs, keeps absolute verification deadlines, and retains undelivered/late sources and local cleanup through close. API signatures, defaults, JSON limits, host-only recovery, borrowed/owned lifetimes, persistence and failure boundaries are documented in the delivering stage. All affected standard documents are updated; release-wide publishing and ICOS adoption remain pending. The authorized next slice is C4; no further routine selection stop is required.

Consumer C4 — enhanced connector execution (complete on branch)

The additive ConnectorTools.enhanced method and EnhancedConnectorOptions, EnhancedConnectorAttempt, ConnectorAcceptedResource root types select execution-v1 explicitly. The bundled Microsoft/Google/Slack/GitHub inventory has 40 specialized operations (28 read/12 write) and four optional generic unknown APIs. Names end _exec; schemas/default legacy APIs stay unchanged. Host deadlines default to connector timeout/30 seconds; zero disables the extra limit. Physical attempt observations are separate from model usage. Partial Microsoft draft acceptance remains explicit, without final-completion claims.

Adoption uses actual enhanced-name identity filters, catalog disabled and source-tagged registration under existing host approval. Acknowledged evidence projections preserve source IDs/metadata and exact allowed raw results; the profile does not enable plugins or promise complete remote collections. Read the recipe for origin, lifecycle, source, persistence and support limits, and run the offline HTTP example. README/User Guide/examples/AMOS docs/unreleased notes and generated API are updated. Admission capture and atomic enhanced registration preserve account/connector isolation. All 8,927 units, 245 cumulative live tests plus six frozen C4 checks, 822 runtime assertions and 44 offline modes pass; delivery/evidence records the full gates and review. No release or ICOS adoption is claimed. C5 catalog/page support remains the next required slice.

Consumer C5 — whole pages and selected catalog (complete on branch)

Root ConnectorPage<T>/PagePosition and ConnectorTools.enhanced(..., { profile: 'collections-v1' }) are explicitly adopted. Seventeen _page operations replace affected collections, Slack topic uses _strict, and other tools keep _exec. Page-size hints do not slice over-return; raw allowed provider items/counts, opaque positions and independent coverage preserve source/completeness distinctions. Prior Drive incomplete coverage survives final pagination. Unsupported provider search/branch capabilities fail or remain incomplete/unknown. No new total-data cutoff/crawler/backend is introduced.

Existing source/account registration installs only collections-v1's manager-local adapter; use actual selected identity filters and normal host approvals. Catalog discovery/search/load/unload/compaction, temporary scopes and context rollover retain the selected definitions and cursor key. Invalid/forged/mismatched/oversized continuations fail explicitly; fresh managers/processes/clear lose ephemeral keys. Reapply host selection before loading saved state. Evidence is separately opt-in and protects complete observed source on failure; no cursor authority or key is serialized.

Read the recipe, capacity inventory and delivery record; run the offline traversal. README/User Guide/examples/AMOS/unreleased notes and generated API are updated in this slice. AMOS distinguishes returned/provider totals, position and coverage. All 9,002 units, 251 cumulative live tests across all three providers, 1,062 runtime assertions, 45 offline modes and full build/type/compatibility/package/documentation gates pass. C4 static/execution-v1, old factories/results/defaults, context/session DTOs and literal wire v2 remain unchanged. Release-wide publishing and ICOS adoption remain pending. Continue C6 under existing authorization.

Consumer C6 — complete trusted orchestration (available on branch)

createOrchestratorWithFactory returns a normal Agent and accepts complete plain parent/worker configuration through configureAgent before initialization. The library supplies its owned hierarchy, workspace and required tools. The callback resolves each worker independently; root overrides do not leak accounts/provider controls into workers. Ordinary zero/false/omission and context/session precedence remain intact. Collisions, mismatched principals, duplicate live conversation/ session identities and cancelled pending admissions fail explicitly.

An explicit ModelTask per parent operation binds admitted children and active monitors; async delivery retains its original task and source. Child observations include actual runtime/loop/tool/evidence/usage correlation without proving business completion. Timeout/cancellation quarantines actual pending work, never cancels a borrowed shared task, and retains unstored worker observations for the existing host archive/acknowledgement path. Worker/root async recovery requires authentic retained sources; saved sessions do not restore task/factory authority.

Read the recipe, delivery and machine evidence; run the offline example. All 9,044 units, 257 cumulative three-provider live cases plus six final C6 checks, 1,270 public assertions, 46 offline modes and full build/type/compatibility/package/doc gates pass. Existing createOrchestrator, synchronous callbacks, ordinary Agent APIs, old raw/default/session contracts and literal wire v2 remain unchanged.

AMOS builds a single Agent and has no factory control surface; its guide links the runnable library demonstration. No AMOS command or saved config is invented. No workflow engine/backend, universal inspector, Stage 14B/16B or distributed budget is included. C7 follows under the current sequential authorization.

Consumer C7 — negotiated remote observations (branch implementation)

AgentPackageOutcomeServer, hydrateAgentPackageWithOutcomes and createAgentPackageOutcomeTools select the independent oneringai.tool-outcomes/1 protocol. The old literal v2 APIs, DTOs and defaults stay unchanged. The new session exposes detached inspection, receipt lookup, per-request cancellation, exact bounded source retrieval and proof-checked checkpoints. Source and proxy IDs/completion remain separate; business declines stay data and C1 operational failures remain failures.

Enable evidence explicitly. Tools-first/C6 construction uses the same scoped storage object in the session and ordinary context. Unknown writes stop further managed dispatch until explicit reconciliation; recovery does not resubmit an action. Persisted admission/full-observation proof is required, and restart does not restore workflow authority. Accounting remains external_unknown. Read the recipe and delivery; run the offline example. Full completion validation is recorded in the delivery record; branch code is not a verified package release. AMOS has no portable transport surface; consumer adoption and release remain separate.

C7 offline delivery gates now pass (9,085 units, 90 mixed-package assertions, compatibility/build/types/lint/docs and runnable recovery example). Live testing was explicitly paused by the user on 2026-10-28 after the attempted matrix exposed an Anthropic endpoint-permission failure and an unresolved legacy Google wrap-up trajectory. Four final C7 OpenAI/Google checks passed; full three-provider validation is pending and is not claimed. See machine evidence.

Consumer C8 — conformance and composed evaluation

C8 delivers internal test-only runEvidenceConformance(profile) and public-API examples, rather than another runtime abstraction. Memory/process, file/restart and file/fsync profiles cover exact reconstruction, isolation, immutable records, quotas and concurrency. Two actual child processes recover C7 evidence and refuse uncertain write replay after a server restart. This is evidence recovery, not restored workflow authority.

The meeting composition compares local/remote functional contracts on held-out sources: one submission, explicit host confirmation, exact citations and checked artifact, with zero false verified completion, duplicate effects or unauthorized disclosure in the acceptance set. It reports latency samples and explicit unknown costs without claiming a model-quality or cost improvement. Existing Agent/runtime, routine/remote and child/task reports compose directly; old inspection shapes stay unchanged. AMOS /routine inspect now shows observed verification and honest accounting; the offline command demo is available.

Read the recipe, delivery, and run npm run example:composition-evaluation or npm run example:amos-composition. The reusable harness remains outside production exports. README, User Guide, examples, AMOS docs and release notes are updated here; package publishing and ICOS adoption remain pending. Live testing remains paused by explicit user instruction.

C8 completion: 9,090 units, 369 focused cases, 596 generic conformance assertions (memory/process, file/restart, file/fsync), two real child processes and six composed example samples pass. Machine evidence records actual metrics. No new production API or inspection-shape change was needed. AMOS and standard documentation are updated; release and consumer adoption remain pending. Live validation remains paused.

Consumer C9-A — endpoint capability companions

getRealtimeModelCapabilities and getTranscriptionCapabilities are available on root and browser-safe /shared. Named vendor, actual endpoint/transport and session mode determine sparse facts. Reasoning support is separate from exact allowed sets: GPT-Realtime-2's five documented efforts are verified; 2.1/2.1-mini exact sets and unverified conversation/transcription pairings remain unknown. Dedicated transcription transport/VAD constraints and declared file endpoints are distinct. Unknown metadata does not hide or migrate saved settings.

Legacy registry JSON, Realtime validation and STT streaming flags are unchanged. All 9,114 units, 21 built-package/browser assertions, build/types/lint/compatibility, examples and API generation pass. No live calls were made. Read the recipe, delivery, machine evidence, and run npm run example:endpoint-capabilities. AMOS has no Realtime selector; ICOS adoption and package release remain pending. README/User Guide/examples/unreleased notes and generated API are updated; no consumer setting changes are implied.

Consumer C9-B — effective request parameter policy

Pure assessModelParameters is available on root and /shared. Optional parameterPolicy: { temperature: 'omit-unsupported', observe? } applies to actual selected OpenAI Responses generation/stream/count/batch requests after reasoning, native effort updates, routing and per-call overrides. It omits only unsupported provider-neutral temperature; supported zero and unknowns remain intact. Raw provider controls and invalid reasoning stay strict. No policy preserves legacy validation/filtering and count behavior. Explicit temperature: 'strict' also validates selected counting before its input-only projection.

Runtime host-local snapshots expose configured policy; old portable v2 exports omit it before traversal. Saved configuration, event/session shapes and literal v2 stay unchanged. Native counting keeps its existing replay/ownership boundaries. Raw Responses WebSocket remains strict; no Chat Completions transport or helper policy migration is introduced. Isolated bounded decision observers are diagnostics, not call counters. AMOS defaults and the ICOS guard remain unchanged pending adoption.

All 9,172 units, 58 new cases (30 actual model/effort pairs), 37 built/browser assertions, build/types/lint/compatibility/examples and generated API pass. Live calls remain paused. Read the recipe, delivery and machine evidence; run npm run example:parameter-policy. Standard guides/examples/unreleased notes and API are updated. Publishing and consumer upgrades remain pending.

Consumer C9-C — optional vendor presentation

Immutable VENDOR_PRESENTATIONS and getVendorPresentation(id) are available on root and /shared, with vendor ID, display name and CSS-ready color. Unknown IDs stay unknown. The initial consumer palette is preserved; hosts compose overrides. Vendor IDs, service/auth classification, existing logo/color APIs and model defaults are unchanged. In particular, SDK Custom endpoint presentation does not classify ICOS ordinary custom-service records or grant platform-managed credentials.

AMOS reuses catalog names with its five existing label overrides. All 9,196 units and 53 built root/shared/browser assertions pass, with build/types/lint/compatibility, examples, AMOS type/build and generated API. Read the recipe, delivery, and run npm run example:vendor-presentation. Standard guides/examples/AMOS/unreleased notes and generated API are updated; ICOS adoption and a verified package release remain pending. All authorized consumer-hardening slices are implemented; live testing continues to be paused by the user.

Consumer hardening final handoff — 2026-10-28

All authorized slices are implemented and reviewed. The final offline gate passes 9,196 units, 1,413 public assertions across twelve package fixtures, 52 offline example modes, build/types/lint/compatibility/API-design checks, generated API, AMOS type/build and 3,075 local links. The local package artifact contains its example helper closure and runs all five new library examples after extraction. Final evidence and delivery ledger are the current completion record; earlier stage totals are historical.

The documentation handoff is complete for delivered branch usage: README, User Guide, generated API, examples/index, AMOS docs, agent guide, recipes, roadmap and unreleased notes. Publishing a package and adopting it in ICOS remain separate. Live validation is paused at the user's request, with the earlier Anthropic account permission and legacy Google wrap-up failures explicitly unverified. Exact 2.1/ 2.1-mini effort sets and unverified transcription pairings stay unknown. There is no remaining authorized implementation slice in this sequence.

Consumer review corrections — 2026-10-28

Status: 9,216 cumulative units (20 new regressions), 1,413 public assertions, all 52 offline modes, six examples from the extracted 314-file package, and build/type/lint/example compilation/API-design/generated API/AMOS checks pass. Corrective evidence records the commands, artifacts and current source hashes. The four requested corrections affect only selected C4/C5 generic transport and C7 remote recovery/lifecycle behavior:

• Generic connector credentials remain on the configured origin through every redirect hop. Same-origin method/body semantics are preserved, with a 20-hop bound, per-hop observations and cancellation during intermediate body cleanup.
• An execution handoff without an authoritative source outcome stays unknown. Existing uninstrumented execution overrides cannot manufacture a not-started receipt or clear a potentially committed write's continuation barrier.
• Repeated receipt lookups reuse validated evidence; concurrent lookups serialize per-invocation reconciliation while each still calls the authenticated transport. Missing proof is repaired without resubmission; failed repair preserves protection.
• Shutdown completion errors survive while the settled composition lease is released, preserving reuse of the borrowed source Agent and idempotent close results.

Public signatures, wire/schema versions, old factories and defaults are unchanged. The connector and remote recipes, their runnable offline examples, standard guide handoff, delivery ledger and unreleased notes document the corrections. AMOS has no new control or configuration to expose; its existing adapters remain covered by the cumulative checks. Consumer adoption and publishing remain separate; live validation is still paused.

H1: additive logical definitions, execution bindings, scoped blocking host tools and Codex MCP bridge are on branch, offline tested, unreleased and live-pending. Adoption is optional; legacy specs/defaults remain. Documentation handoff: README, User Guide, AGENTS, runtime architecture, generated API and swappable example. See H-stage ledger.

H2 adoption: optional agent-runtime/claude entry and anthropic.agent.sdk binding. Defaults deny native tools/config/delegation; continuation and terminal limits are normalized without changing old event/status unions. README/User Guide/AGENTS/runtime docs, generated API and Claude example updated. Source/offline availability only; live testing and release pending.

H3 adoption: optional IRuntimeSessionStorage, InMemoryRuntimeSessionStorage/FileRuntimeSessionStorage, StorageRegistry.runtimeSessions, session references, request IDs, getRun/inspectState/detach and reference-based deletion. New observer uncertainty errors retain old terminal unions and legacy behavior. Local idle context/transcript restore is conditional; active local admission/opaque source gaps remain explicit. README/User Guide/AGENTS/runtime/distributed/outcome/evidence guides and the two-process recovery example are updated. Branch/offline only; live/release pending.

H4 adoption: OpenAIManagedDriver in agent-runtime/openai-managed, driver openai.agents.api, durable control storage required. SDK writes do not retry automatically; pending/idle/disconnect remain nonterminal. First-turn format is fixed, native delegation/plugins disabled, endpoint model profiles explicit. README/User Guide/AGENTS/runtime docs, generated API and wire example updated. Branch/offline availability only; live and release pending.

H5 adoption: ClaudeManagedDriver in agent-runtime/claude-managed, binding anthropic.managed.api. Provider-managed placement, owned version-pinned agent/session and owned-or-borrowed environment; only owned resources are cleaned up. Native tools/delegation/memory off by default, budget wait nonterminal, interrupt confirmation separate, native session settings fixed. README/User Guide/AGENTS/runtime/distributed/outcome guides, generated API and wire example updated. Branch/offline only; live and release pending.

Agent harness expansion adoption and handoff — 2026-10-28

Availability means implemented/offline validated source on this branch. Exact current commands/counts, failures/fixes and extracted-package verification are recorded in the H-stage delivery ledger; earlier per-stage totals above are historical. The API reference is generated. No release-wide runtime documentation handoff is deferred. Publication, consumer upgrades and live native provider/platform/account verification remain separate and unauthorized. Existing live-testing pause remains in force. Deferred App Server interactions, remote backend, A2A and native workflows are not completion dependencies for H0–H6.

The 2026-11-01 review corrections preserve admitted input/options despite caller mutation and keep abort signals live. Failed restoration releases writer ownership and native observation, preserves managed work, and keeps partial observers out of the process cache so the original reference can be retried. The public signatures, defaults, native checkpoint formats and legacy runtime remain unchanged. Current verification is tracked in the H-stage delivery ledger; live testing remains paused.

Agent harness documentation and complete AMOS handoff — 2026-11-01

The user requested thorough documentation, extensive examples and full AMOS support for the delivered runtime. The application delegates all currently supported runtime operations through its existing trusted-host mode: per-run options and request IDs, results/activity cursors, explicit transfers, reference/save/startup restore, fresh sessions and owned-resource cleanup. Recoverable open and persistence errors remain visible without resubmitting tasks. Native-only internals and unsupported interaction profiles retain their existing boundaries; standard AMOS behavior is unchanged.

README now leads with reusable definitions. The canonical User Guide, AGENTS, examples index, AMOS setup/command table, new cookbook, Unreleased notes and generated API are synchronized. The trusted host uses ordinary public APIs, atomic locator persistence and separate control/workspace/ transfer directories. The expanded AMOS demonstration covers all five adapters; the new native run-options example covers JSON output, model/reasoning, immutable admission, cancellation and saved-request replay. Final checks are tracked in the delivery ledger. The handoff passes 9,325 tests, all nine examples from source and the extracted package, and the built AMOS workflows for all five adapters, including both managed transfer paths and native OneRingAI restoration after a real CLI restart. No consumer upgrade, package release, native interaction implementation or live-provider verification is included; the live-testing pause remains in force.

Agent harness safety corrections — 2026-11-01

All six findings from the subsequent review are corrected on branch under the user's “fix all” instruction. Native definition tools now enforce resolver and Agent permissions together; Claude SDK streaming and structured output redact credentials; OpenAI managed recovery rejects expanded access/configuration; ambiguous control acknowledgements recover without action replay; late resume observers detach after shutdown; and read-only admission can be stopped during a stalled inspection, including AMOS exit. Saved formats, public signatures, default selection and accepted-action reconciliation remain unchanged.

Adoption requires no migration. Resolver policies are borrowed and cannot override native denials. Use getRun (AMOS /result) to repair retained-result persistence, never a fresh task. The new offline safety example demonstrates denial and post-commit acknowledgement recovery with one authorized tool execution. The canonical User Guide, AMOS cookbook, examples index, AGENTS, release notes and generated API document the changes. The delivery ledger owns final checks; the fixed probes record all-five-harness denial. No package release, consumer upgrade or live-provider verification is implied.

Documentation handoff — 2026-11-02

The entire README and User Guide were reviewed. Current v2 adoption now appears in their main navigation and relevant chapters; v1 upgrade notes moved to MIGRATION_V1_HISTORY.md with compatible guide anchors. All internal navigation is relative. Only the README's npm version switch links pin the required version1 and eventual main pages. The AMOS cookbook stays prominent at the start. Generated source links now resolve relative to each output file; npm run docs:check checks paths, anchors and complete examples. Release readiness and the coverage record own this review's evidence and remaining gates. This does not mark any release as published.

Release hardening handoff — 2026-11-02

The release-readiness corrections preserve the public API and defaults. Routines now advertise unified stores, deliver nested instructions to reused agents, and resolve/clean/restore routine findings-tier spills. Reflection remains opt-in; fold task-output precedence and prompt overrides remain. Adopt through the current routine guide and offline map/fold example; AMOS documents its shared-library behavior without adding another execution/tool pipeline.

The published dependency ranges now include the patched parser/glob/unpdf paths, with production WebSocket declarations for strict consumers. PDF extraction uses selected-page raw pixels encoded as real PNG and releases its private loading task on all exits; caller buffers stay reusable. Metadata/image-page failures retain available text and other pages with warnings. Existing document result shapes remain. The default and optional-SDK production graphs have no high/critical audit entries; the two source-reviewed non-applicable advisories and their propagated moderate entries remain explicit in dependency security.

npm run release:check owns the repeatable build/type/lint/unit/compatibility, 27 offline examples, generated docs, links/snippets and real installed-consumer gates. Core types work without SDK peers; adapter types are also checked with selected peers. The release record owns the final results. README, User Guide, examples index, AMOS cookbook, migration guide, agent guide, generated API, contributing guidance and release notes carry the handoff. No new stage, stable-version selection, live-provider claim, merge or publication is included. Keep existing native/provider and experimental surfaces opt-in.

Final hardening validation is recorded in V2_RELEASE_VALIDATION_2026_11_02.json: the full release gate passes, with 9,374 units / 427 files, 27 offline examples, strict default/optional-SDK consumer contracts, both production audits, nine document formats in ESM/CJS, Node 22.13/24.20 probes, AMOS types/build and Hosea types/build/ six design-storage checks. This closes the earlier November 2 readiness findings within the documented preview and source-reviewed dependency boundaries. The prepared version remains 2.0.0-beta.1; no npm publication or merge is implied.