Glossary, Evidence Catalog, and Source Index

The transition in which a validated contribution becomes visible in a scope; activation must have explicit ownership and disposal.

A runtime object with identity, scope, inbox, status, and a Session-backed execution lifecycle; it is published only after setup succeeds.

A request-scoped human decision with a closed outcome vocabulary; approval is not a reusable ambient permission.

A reusable product-level configuration layer that assembles a coherent set of plugins and defaults.

A model-facing presentation and dispatch mode that exposes generated SDK bindings; it does not create a second, authority-free tool engine.

The exact transition after which a candidate is authoritative; failures before it veto publication, while later observer failures cannot undo the fact.

A logged Surface replacement that summarizes an eligible prefix to reduce future model context without deleting canonical history.

A monotonic client-side epoch that prevents stale work from an earlier transport from mutating the current connected state.

A child whose stable descriptor and Session permit later follow-up epochs; publication occurs only after setup and inbox acceptance succeed.

The share of catalog IDs cited by an eligible chapter corpus, counting one bilingual chapter once; it is not claim coverage, source-file coverage, or proof quality.

The callable cleanup handle returned by a registration; ownership and reverse teardown make it part of the runtime contract, not optional housekeeping.

An awaited boundary that makes the required log prefix durable before a model request, top-level tool body, or another selected side effect proceeds.

A side-effect registration paired with a disposer and owned by the current lifecycle fiber, so replacement can retract what it published.

A stable catalog ID tied to one pinned repository path and line range, with bilingual statements of what that excerpt supports.

The runtime lifecycle node that owns a plugin activation and its effects; disposing it retracts its owned contribution graph.

A revisioned, phase-bearing objective updated through exact-reference checks and a durable Session commit before live publication.

The durable transition that assigns queued input to an execution boundary, preserving ordering and recovery semantics across cancellation or restart.

The typed request, response, and notification carrier used by API and ACP surfaces; envelope validation does not by itself establish user identity.

A policy hook that may deny or abstain but cannot grant authority, so a later guard cannot reverse an earlier veto.

Session-owned freshness metadata recorded by selected filesystem tools; it is narrower than proof that every byte was read or every filesystem access was observed.

A configuration-tree operation that adds, replaces, or removes a row by stable identity as composition layers are applied.

The exact upstream commit against which every path, line range, generated index, and architectural statement in this study is evaluated.

A selected interaction mode whose transition commits immediately when idle or at the next accepted in-Turn pre-Step boundary.

A composable runtime contribution mounted into a context and owned by a lifecycle scope; it may publish services, listeners, and reversible effects.

A named launch composition that selects and layers bundles and patches into an effective plugin tree.

A fold or query-derived view over authoritative records; a projection can accelerate reads without becoming the source of truth.

Reconstructing derived runtime or model-visible state by folding durable facts in sequence order rather than trusting a resident cache.

The canonical logged snapshot of request-shaping context used to reconstruct and compare model requests.

The stable key used to decide which configuration row a later layer replaces; textual position alone is not identity.

A package-owned executable check of a semantic property at runtime; it complements static types and tests rather than replacing either.

Per-call policy for declared process file effects and writable roots; its documented boundary is not general network, syscall, device, or credential isolation.

A visibility and ownership boundary that determines which contributions are observable and which lifecycle must retract them.

A typed capability published under a context key and consumed through scope-aware lookup rather than direct global ownership.

An append-only typed record in a Session log with sequence, time, payload, and optional Surface metadata; it is not a live Cordis event.

A scope-owned browser contribution point whose recursive disposal removes the subtree declared by an entry.

One prompt assembly and model-request attempt inside a Turn, followed by either completion or a tool-continuation boundary.

A child execution created through a provider seam with explicit parent ownership, run identity, settlement, budgets, and optional continuation.

The ordered model-visible message projection derived from eligible Session events; it is a view over the log rather than the canonical log itself.

The append, replace, or delete operation carried by a Surface-eligible event to fold model-visible history deterministically.

A whole-value list state with its own validation and projection contract; it does not inherit Goal or Plan authority semantics.

The ordered execution transaction spanning input materialization, policy, guards, around-dispatch, body execution, post-policy, finalization, and immutable result.

A named transition where identity, authority, data origin, or side-effect capability changes and therefore requires explicit validation or policy.

A user- or system-triggered execution interval that may contain several Steps and ends with an explicit reason.

A named live-bus contract whose TypeScript signature and dispatch mode constrain producers and listeners; it is distinct from a durable Session log record.

An ordered live-event mode in which a listener can transform a value and delegate to the next listener; before/after-next placement is semantic.

The log position and identity metadata that bound what a cached projection has folded and whether tail replay is safe.

A validated orchestration program that composes child runs and combinators under explicit concurrency, total-child, slice, and disposal ceilings.

Per-Session asynchronous persistence that preserves append order but needs an explicit flush barrier before selected external effects.