Part VI Appendices

Chapter 17 – Appendix D: Glossary & Translation Guide

Developing and operating reliable autonomous systems demands a precise, shared vocabulary. This appendix defines the canonical terms used throughout this book and provides a small translation layer to familiar industry language.

Software Development as Code (SDaC)

Software Development as Code (SDaC) is the discipline of turning stochastic generation into a reliable engineering process: deterministic context selection, hard gates, and verifiable loops that produce diffs you can review.

This glossary is tiered the same way the book is: start with Tier 1 and you’ll have enough vocabulary to build a working loop.

Tier 1 (Substrate: use everywhere)

Map: Structured, version-controlled intent (docs, contracts, inventories, derived views).

Terrain: Reality-as-code (source, configs, schemas, runtime behavior).

Ledger: Append-only evidence (diffs, validator output, decision traces, run metadata).

Physics: Deterministic constraints that shape a stochastic process (schemas, linters, tests, architectural rules, budgets, stopping conditions).

Mechanism: A specific, runnable detail (a validator, a parser, a build target, a CI gate) — not a metaphor.

Deterministic Sandwich: The unit pattern for safe autonomy: Prep → Model → Validation.

Validator: One deterministic gate (lint, types, schema, contract, policy).

Immune System: The suite of Validators that defines “good enough” for a surface.

Immune System case: One concrete PASS/FAIL case inside the Immune System suite.

Effector: A bounded transformation that proposes a patch/diff to the Terrain (or a Map surface) under constraints.

Sensor: A read-only measurement of the Terrain that emits structured signals (diffs, counts, failing invariants, hotspots).

Agent: A model running inside a constrained environment with explicit Tools, Physics, and a Ledger. It does not “want” anything; it executes a loop.

Engine: The full system: substrate + Sensors + Effectors + Immune System + Judge + Ledger. The model is a component, not the system.

Mission Object: Typed intent and state. A persistent artifact (YAML/JSON) that acts as an executable pull request: it defines goal, scope, budgets, and gates, and it records lifecycle status (for example status and completed_at).

Judge: Consumes validator signals + evidence and decides the next move.

Adaptation State Machine (ASM): The allowed moves after Judgement: Revert, Iterate, Update Environment (and optionally escalate to a Human).

Tier 2 (Loop: once the loop runs)

The Three-Tier Frame (Substrate → Loop → Governance): A completeness frame: Substrate (Map/Terrain/Ledger + Physics + Context Graph), Loop (Sandwich + feedback), Governance (blast-radius limits + protected graders).

Stochastic Drift: Variance in output and behavior under the same Mission Object and context slice.

Ouroboros Protocol: The iterative loop: Write → Judge → Refine until convergence or a circuit breaker. Refine is the constrained mutation step in response to a specific failure signal, producing a smaller, cleaner diff.

Circuit Breakers: Hard stop conditions that keep loops finite (max iterations, max wall-clock, max diff size, min progress).

Structured Error Objects: Machine-readable failures (file, line, error code, failing validator, suggested fix) instead of vague prose.

Feedback Injection: Feed the exact failing signal back into the next iteration (stderr, linter lines, failing test output).

Salvage Protocol: A loss-aversion mechanism. Failed/reverted candidates are moved into a Quarantine directory (diffs + logs + artifacts) rather than deleted (for example .sdac/workflow-quarantine/) so useful fragments are recoverable.

Context Architecture: Engineering how context is selected, structured, and bounded so the model can act deterministically.

Directives: Human-authored behavioral laws for the Agent (for example agent_directives.md). Unlike Physics (enforced by code), Directives are enforced by the agent instruction layer and review policy. They define “who you are” and “how you act.”

Context Graph: A queryable topology of the codebase. Nodes (apps, packages, modules) carry identity (language, framework, build tooling). Edges encode dependencies and contracts. The graph is what lets Drivers select the correct mechanism without guessing.

Driver Pattern: Decouple intent from mechanism (Mission says “run tests,” driver selects pytest vs vitest vs mvn test).

Map-Updater: Sense → Normalize → Compare → Propose patches to keep Map surfaces synchronized with the Terrain.

CI Gate (Map–Terrain Sync): Divergence between Map and Terrain becomes a build failure.

Mission Gate: Run a Mission’s acceptance criteria (Physics) without running the model.

Meta-Patterns

Meta-Pattern: Don’t Chat, Compile: Use chat for ideation, but ship work through versioned Missions and deterministic runners (diffs + logs).

Meta-Pattern: Physics is Law: If a change fails Physics, it does not exist. No warnings. No loopholes.

Tier 3 (Governance: maintenance and safety)

Immutable Infrastructure: Protected paths and pipelines that grade and govern the system (validators, CI, policy).

Scope Guard: Blast-radius control via explicit path allowlists (the Mission scope).

Ratchet: Monotonic quality metrics: metric_new ≥ metric_old for chosen guardrail metrics.

Neuroplasticity: Safe self-modification capability: the system can accept refactorings and other changes without collapsing into regressions (because it is bounded by Immutable Infrastructure, budgets, and hard gates).

Dream Manifest: Measurable maintenance targets: an entropy backlog expressed as concrete work selectors.

Dream Daemon: Scheduled background maintenance (most teams start with the human-approved 90% solution).

Automated Refactoring Under Guards: Measure → Mutate → Measure → Commit/Revert under strict validators, budgets, and protected graders.

Hofstadter Bridge: The boundary where documentation becomes executable constraints: the Map is no longer advisory; it is enforced.

Mirror: The optional limit case: a system can treat its own docs/spec as an input to its maintenance and governance loops.

Meta-Patterns

Meta-Pattern: Recursion: The same toolchain used by humans is used by maintenance loops (Dream Daemon emits Missions; the loop validates changes under Immutable Infrastructure boundaries).

Translation guide (one-time bridge, then use canon)

Actionable: What you can do this week

Pick one system you operate today and map the Tier 1 terms onto it: what is the Map, what is the Terrain, what is your Ledger, and what is your Immune System? Once you can point to those artifacts, you can start building reliable loops.