GLOSSARY.md

Glossary — canonical terms for the substrate

The single term registry for this repo. Each term has one canonical spelling here; other spellings are listed beside it as aliases to avoid. This file does not re-derive concepts — it points at the source-of-truth doc that owns each one.

Source-of-truth map. Ontology (the four primitives impulse/pointer/resolver/vessel, and activity, which is derived from them) → architecture/IMPULSE_ACTIVITY_FOUNDATION.md. The three states, durability groups, and what is implementation detail → architecture/SUBSTRATE_AS_SOFTWARE.md. The three math lenses and their shared dictionary → architecture/SUBSTRATE_AS_MDP.md, SUBSTRATE_AS_DEC.md, SUBSTRATE_AS_DYNAMICS.md (dictionary in DYNAMICS §0). Idioms (named compositions) → CORE_IDIOMS.md. Shapes vocabulary → shapes/README.md. Operational behavior → CLAUDE.md.

1. The three states (canonical)

One triad, canonical names Informational / Transient / Observational. Full treatment + the durability bridge: SUBSTRATE_AS_SOFTWARE.md §1.

Canonical	Definition	Avoid
Informational state	the durable structure — vessel/resolver code and learned content (shapes, posteriors, topology, goal-paths)	Instructional state, "the structure (i)"
Transient state	the execution in flight — an impulse being resolved, a binding being chosen	Process-of-Becoming, "the becoming (t)"
Observational state	the recorded outcome — traces, validation results, realized artifacts	Functional state, "Instance", "the recorded outcome (o)"

• Recall motion = Informational → Transient → Observational (apply structure).
• Learning motion = Observational → Transient → Informational (mint structure).

2. Durability groups (the software bridge)

Canonical home: SUBSTRATE_AS_SOFTWARE.md §4 ("The durability physics the walk obeys"). The Informational state splits in two by change-authority.

Group	State	Changes via	Holds
Authored-durable	Informational	deploy / commit	vessel code, resolver implementations, template definitions, shape contracts (= the four primitives)
Learned-durable	Informational	the loop, every trace	Thompson posteriors, shape lattice, composition-edge weights, goal-paths, impulse-relevance (= the system's load-bearing state)
Ephemeral	Transient	per-execution	in-flight impulses, bindings, executing trajectory
Recorded	Observational	append on execution	traces, validation results, failure modes, artifacts

3. The four primitives (authored-durable scaffold)

Canonical: these four are the authored-software layer, not the learning itself (SUBSTRATE_AS_SOFTWARE.md §4.2, "Which primitives are implementation detail"). Foundation: IMPULSE_ACTIVITY_FOUNDATION §"Minimum Self-Stable Set".

Term	Definition	Notes / aliases
impulse	a pointer + metadata + (lazily resolved) body — data in any form	the data envelope; content is ephemeral, relevance is learned
pointer	the shape of an impulse; the bootstrap key all resolution and learning are keyed on	"pointer-as-shape" (the principle); pointer.type dispatches resolution
resolver	a function from pointer → content; lives where the data is	tiers are a binning of its directional certainty (§5); implicit resolvers live inside executors
vessel	a collection of activities and resolvers	two senses — structural (code) vs operational (running service instance); see SUBSTRATE_AS_SOFTWARE §2.1

The minimum set is these four; activity is derived (§4). Impulse and activity are not "the two primitives".

4. Derived constructs

Term	Definition	Source / aliases
activity	a constrained state transition linking input-impulse sets to output-impulse sets; concretely "an impulse of shape activity_template"	FOUNDATION; derived, not a primitive
shape	the pointer's type + metadata, viewed as a learned type; observed/refined/pruned from traces, not declared in a global registry	FOUNDATION; "pointer-as-shape", ImpulseShape
trace / execution trace	the recorded set of impulses (in / intermediate / out) + state transition + outcome for one execution	canonical DB table: activity_execution_traces (plural); impulse shape: activityExecutionTrace; avoid the table names execution and activity_execution_trace (singular)
trajectory	one path through the composition graph; structurally identical to an activity, differing only in granularity	FOUNDATION
composition graph	the graph of templates connected by input/output shapes; discovered through execution, not designed	edges carry α/β posteriors
lifecycle event / hook	an impulse of shape lifecycle:* broadcast to subscribed meta-activities	emitted at well-known points, mostly by the execution engine (the emit helper in ias-executor-ts/src/engine.ts) — among them lifecycle:task:preBinding (before slot binding), lifecycle:task:completed, lifecycle:execution:succeeded, lifecycle:gap:classified — and also from resolvers (e.g. lifecycle:llm:dispatched in the LLM-prompt resolver). Treat the emit sites, not this list, as the live set
state signature	the canonical state key for contextual selection: state_signature (available-shape multiset, canonicalized)	state_signature; its sorted-dedup shape-array core is the shape signature (ShapeSignature); avoid "state-space signature" (idiom 9)
budget	resource ceiling for loading an impulse (tokens / bytes / rows / time)	"resource budget"

5. Learning-loop terms

Term	Definition	Source / aliases
Thompson Sampling	per-candidate Beta(α,β) sample-and-argmax selection; scores computed from traces, not stored on the activity	canonical casing: Thompson Sampling; α = successes+1, β = failures+1
thompson_alpha / thompson_beta	success / failure counts of the Beta posterior per (signature, template)	α / β
forward arm	P(success | activity resolves a pointer of shape Y) — updated per task-completion	"two-direction learning duality"; also the empirical estimate of resolver directional certainty (§ below)
reverse arm	P(success | activity chosen given pool shapes {A,B,C}) — updated per recommendation	symmetry invariant: forward and reverse counts must converge
composition-chain credit propagation	α/β deltas written to ancestors along composition_chain, decayed by an eligibility-trace factor λ per ancestor depth and capped at four ancestors from the leaf	propagateCreditAlongChain (activity-api/src/lib/posterior-update.ts); the decay is TD(λ), not a per-step discount γ — the tuning key is TD_LAMBDA; MDP §3 = n-step TD backup
ribosome	a resolver: trace-shaped → template-shaped; extracts a reusable activity from a successful trace	the ribosome-extract lifecycle template (ias-executor-ts/src/templates/lifecycle/ribosome-extract.json) declares a subscription on lifecycle:activity:postExecution, an event nothing emits, so it is not reached by that path; ribosome-vessel runs extraction as a standing service (CORE_IDIOMS idiom 6)
improvisation	running something new when no activity matches with confidence; must be recorded — the trace-create payload carries the boolean improvisation field and it is persisted on the trace	replaces the dead term trailblazing (§7)
variant / variant family	competing versions of an activity grouped by activity_id, selected via Thompson	variant_id (activity_variant_id on a trace); family keyed by original id
failure-mode taxonomy	six stratified failure types: verifier_negative | budget_exhausted | safety_breach | cascading | user_abort | prediction_disagreement, plus the untyped execution_error recorded for an unhandled resolver throw	failure_mode; canonical schema = FailureModeSchema (activity-api src/models/schemas.ts), a discriminated union on type
prediction_disagreement	the sixth failure mode: a substrate-authored activity emitted a prediction and the observed continuation diverged. Its context is a discriminated union on sub_type with three sub-cases — intent_inconsistency, trajectory_divergence, action_no_effect	PredictionDisagreementContextSchema; the sub-case sets the β step size (§ below and CORE_IDIOMS idiom 5)
impulse relevance	per (activity, impulse): relevance = P(success | loaded) vs P(success | not loaded); the forward arm's implementation	impulseRelevance
directional certainty (resolver)	continuous, per-(resolver, signature) measure that a resolver's output lies along the goal-coplanar tangent of the shape hypersurface; resolver_tier {deterministic, pattern, llm} is a coarse binning of it	canonical reframe: SUBSTRATE_AS_SOFTWARE.md §4.1; = DEC ⋆₁ precision = MDP transition-determinism; estimated by the forward arm
outcome-conditional β step	a failure does not always cost a full β. The failure mode selects the step size, so "how wrong" is carried into the posterior rather than flattened	computeDeltas in activity-api/src/lib/posterior-update.ts; the standing table is in CORE_IDIOMS idiom 5

6. Execution / trace fields & disambiguations

Term	Canonical meaning	Disambiguation
resolver_tier	{deterministic, pattern, llm} — coarse bins of directional certainty (§5)	NOT the dispatch-pathway set; see next row
dispatch pathway	which leg of resolution served the impulse: LOCAL / CUSTOM / DISCOVERY / MCP / FALLBACK / ERROR	a routing fact, not a certainty bin. RESOLVER_TRACKING.md owns both vocabularies and states the separation explicitly — do not conflate the two fields
meta-trace layer	L1 = the per-goal wrapper, L2 = the per-activity wrapper, L3 = leaf / per-resolver impulse_resolutions. The wrappers are recognisable on a trace by their synthetic variant_id: _goal_resolve and _activity_execute	NOT the same numbering as instrumentation level
instrumentation level	tracing overhead tier: Level 1 request / Level 2 function / Level 3 full	distinct axis from meta-trace layer
composition_chain	denormalized root-first ancestor list on a trace	parent_execution_id = direct parent only
input_impulse_ids / output_impulse_ids	the impulse ids a single task consumed and produced, stored per task inside the trace's tasks array (snake_case on the wire). They are the co-occurrence signal: which impulses were loaded together for a task that then succeeded or failed. Always present after normalization, possibly empty. A writer may send camelCase (inputImpulseIds) or leave them off entirely, in which case they are recovered from the task's inputState.impulses / outputState.impulses.	definition and the fallback chain live in activity-api/src/routes/execution-traces.ts (extractTaskImpulseIds, normalizePersistedTask); the impulse-relevance β-penalty path reads input_impulse_ids
vessel_id	the vessel (instance) that executed; doubles as pod/instance id	structural vs operational vessel: SUBSTRATE_AS_SOFTWARE §2.1
goal execution path	curated activity sequence achieving a goal; path_activities, path_signature, endpoint_output_shapes	table goal_execution_paths

6.1 Operating terms

The words used for how the running system behaves and is operated.

Term	Definition	Source / aliases
walk	goal execution: backward-chaining over the shape graph from the goal's target shapes, choosing producers by learned posterior, binding data shape to shape, then judging whether the goal was reached	CLAUDE.md; SUBSTRATE_AS_SOFTWARE.md
reached	the judge's verdict that a goal was actually achieved, read from the produced output; the honest outcome of a dispatch	distinct from status, which is only the template's exit status
hollow completion	status: completed with reached: false: the process exited cleanly but did not do what was asked
satisfier reach	status: failed with reached: true: a step satisfied the goal although the template exited with a failure	walk tier satisfier in GOAL_EXECUTION_PATHS_SCHEMA.md
gap	an observed shortfall against an expectation, filed in the gap store and closed only when the closure is verified	shape substrateGap
gap triple	the measure of progress: gap close rate, latency from detection to close, and durability (a closed gap does not reappear in another form)	CLAUDE.md law 7
feature compose	the code-change path: a goal naming a source file is drafted, typecheck-verified and landed as a traced commit	feature_compose (development-vessel); "the drafter"
mitosis cutover	how a substrate-authored change lands in a running vessel: applied to a staged copy, verified, then committed, pushed and restarted	SUBSTRATE_AS_SOFTWARE.md
ribosome	extraction of a reusable activity template from an execution that reached (see §5)	ribosome-vessel
boredom	idle-time selection: when the substrate is not busy, it chooses what to do from current conditions such as open gaps and due rhythms	boredom-vessel; CLAUDE.md law 5
rhythm	a time-shaped impulse in the pool that the selector reads to pace recurring work, in place of timers	timeShapedRhythm
docs-align	the loop that checks landed code against the documents that expect it, and files drift as gaps	docs-align-scan, doc_drift_fix
concept-db	the store of concepts: typed knowledge units with relevance scores, including each ingested document section	concept-db vessel
memoryNote	the substrate's own memory store; operator-side memory files are a cache of it	development-vessel
pull-sync	the timer that converges each running vessel to its repository's origin/dev: fast-forward pull, mirror, health-gated restart	substrate-pull-sync
profile	which vessels a container runs, named by the data it holds: standalone, hub, hub-minimal, spoke, surface, compute	README § Installation
hub / spoke	a hub holds a network's learning state and the compute next to it; a spoke runs its own vessels and resolves the hub's shapes through discovery	federation: FEDERATION.md
cockpit	the agent-facing tool surface (the metabob MCP server) through which agents dispatch goals and read verdicts	CLAUDE.md

7. Use these terms

Write the term on the right. The term on the left names nothing in the running system.

Avoid	Use
trailblazing	the failure-mode taxonomy + variant creation on failure
improvisation outcome	posterior variance + failure mode
Instructional state	Informational state
Functional state	Observational state
process-of-becoming	Transient state / "the becoming"
"The Two Primitives"	the four primitives (activity is derived)
resolver_tier as a fixed kind	a binning of directional certainty (§5)
table execution / activity_execution_trace	activity_execution_traces

7.1 Names to avoid

These names are not synonyms for anything in the codebase. A new document, shape, repo, package, or identifier never introduces one, and a claim that uses one is worth checking against the running system.

Avoid	Use
metabob-* as a prefix	the vessel's own name — e.g. metabob-activity-api → activity-api
@metabob/* packages	@avigopal/* — e.g. @metabob/cpg-inference → @avigopal/cpg-inference
metabob-devbob (super-repo)	substrate
minibob, MiniBob	nothing; no such component exists, and its signin routes answer 410 Gone by design
devbob	substrate — the self-developing deployment, not a separate agent

One name stays: the metabob MCP server. It is the agent-facing cockpit — the tool surface an operator's agent calls into — and its tool identifiers (mcp__metabob__*) are a published interface.

A refusal that names an avoided term is deliberate. Where one appears in a refusal path — a 410 Gone body naming a method that does not exist — it is a signal, not residue. Deleting it turns an informative refusal into a bare 404. Remove such a route on telemetry showing no callers, not on a name sweep.

8. The cross-lens dictionary (pointer)

Each substrate quantity is named in four charts. The full table is in SUBSTRATE_AS_DYNAMICS.md §0 (math lenses) and SUBSTRATE_AS_SOFTWARE.md §0 (software lens). The spine:

Substrate term	MDP	DEC	Dynamics	Software
learned content	Beta (α,β)	Hodge star ⋆₁	slow variable	learned-durable group
selection	Thompson argmax	sampling against ⋆	fast variable at x*(y)	recall motion
credit propagation	n-step TD	heat flow e^{−tL}	transport along slow flow	learning motion
convergence rate	regret O(√(T log T))	λ₁·ρ_sample·κ(⋆)⁻¹	spectral gap	throughput × headroom
resolver directional certainty	determinism of P(s′|s,a)	stalk-map sharpness ⋆₁	sharp vs noisy direction	resolver_tier bins (§5)
coherence condition	(implicit)	λ₁(L(t)) ≳ ρ_grow	normal-hyperbolicity threshold	learned-mixing > minting rate