Invariant Guarding

batch: First Iteration/Batch 07

source_primes: closure boundedness invariance data_integrity

slug: closure

slug: boundedness

slug: constraint

slug: boundary

slug: transaction

slug: function

components:
Invariant Definition
Transition Scope
Guard Condition
Validation Rule
Violation Response Path
Rollback or Repair Policy
Monitoring Signal
Exception Policy
Invariant Owner
Audit Trace
Drift Review Cadence

mechanisms:
Database Constraint
Safety Interlock
Invariant Test Suite
Contract Check
Policy Guardrail
Integrity Monitor
Rollback Transaction
Two-Person Rule

essence_one_line: Identify conditions that must always remain true and guard operations so those invariants are preserved.

compression_statement: When system viability depends on conditions that must not be violated, define invariants and guard operations against changes that would break them.

core_intuition: Some properties are not goals to optimize after the fact; they are conditions the system must keep true while changing. Invariant Guarding works by naming those properties, checking proposed transitions against them, and refusing, repairing, rolling back, or escalating changes that would break them.

canonical_formula: declare invariant → locate risky transitions → install guard condition → handle violation safely → monitor drift in the invariant or guard

structural_problem: A system changes over time, but some properties must remain stable for safety, integrity, identity, authority, or viability.

condition: Multiple operations can alter a shared state, record, resource, or commitment.

why_it_matters: Even individually reasonable actions can combine into a violation when no one guards the property that must remain true globally.

condition: The property at risk is necessary rather than merely desirable.

why_it_matters: If the property is optional, a preference, or a normal optimization target, strict invariant guarding may be excessive.

condition: A transition may appear locally valid while breaking a wider safety, integrity, authority, or identity condition.

why_it_matters: Local validation is not enough when the decisive failure is loss of a cross-step or cross-component invariant.

condition: The system has exceptions, delegation, concurrency, or automation that can bypass informal judgment.

why_it_matters: Informal memory of the invariant fails under scale, handoff, speed, stress, or adversarial pressure.

condition: Violations are costly to detect or reverse after the state is committed.

why_it_matters: The guard must be placed before commitment, side effects, public action, or irreversible harm whenever possible.

symptom: A system repeatedly reaches states that everyone agrees should have been impossible.

diagnostic_hint: The invariant may be known socially but not encoded into transition rules.

symptom: Downstream teams discover integrity, safety, or eligibility problems only after work has already proceeded.

diagnostic_hint: The guard is too late, missing, or disconnected from the transition that creates the violation.

symptom: Different actors disagree about which exceptions are allowed because the must-preserve property is vague.

diagnostic_hint: The invariant definition may be incomplete or not tied to concrete guard conditions.

symptom: A workflow accumulates compensating fixes, emergency patches, or manual reviews after preventable violations.

diagnostic_hint: The system is repairing invariant breaks instead of guarding transitions before they commit.

symptom: Automation or delegation scales a small rule weakness into widespread state corruption or unsafe action.

diagnostic_hint: A human-dependent invariant has been automated without an explicit enforcement path.

root_tension: The system must keep changing to act, learn, serve, trade, heal, or adapt, but some properties must remain true across those changes or the system loses safety, integrity, identity, or legitimacy.

case: The main problem is that outputs leave a permitted domain after one operation.

why_not_this: Closure-Preserving Operation is likely closer when the central issue is output-domain membership rather than a must-preserve property across many transitions.

case: The main problem is deciding what range or constraint envelope should apply.

why_not_this: Constraint Envelope Adjustment is likely closer when the intervention is setting or adjusting limits rather than preserving an already-declared invariant.

case: The property is a normal objective that can be traded off freely.

why_not_this: Invariant guarding is for properties that should not be violated except through explicit exception governance.

case: The intervention only observes violations and produces reports without blocking, repairing, escalating, or rolling back.

why_not_this: That is monitoring or audit support, not invariant guarding by itself.

case: The system needs a full data governance, provenance, or source-of-truth intervention.

why_not_this: Data Integrity Preservation or related records-family archetypes may be closer when record trust, authority, and provenance are the whole intervention.

structural_intervention: Declare invariants, locate transitions that could violate them, add guard conditions and violation responses, and maintain the invariant as the system changes.

step: Name the invariant.

logic: State the property that must remain true in language precise enough to guide decisions, tests, or accountable judgment.

logic: Identify operations, handoffs, exceptions, updates, approvals, or state changes that could break the invariant.

step: Translate the invariant into guard conditions.

logic: Define observable checks, conditions, rules, thresholds, or review criteria that determine whether a transition is allowed.

step: Place guards before commitment or irreversible effect.

logic: Check at the boundary where a transition becomes accepted state, public action, resource allocation, or safety exposure.

step: Define the violation response.

logic: Specify whether a violating transition is blocked, repaired, rolled back, deferred, escalated, isolated, or allowed only through explicit exception governance.

step: Make exceptions accountable.

logic: Permit justified exceptions only with scope, authority, traceability, and review so exceptions do not silently dissolve the invariant.

step: Monitor invariant and guard drift.

logic: Review whether the invariant remains valid, whether guards match real risk, and whether people bypass the guard because it is stale, overbroad, or unjust.

rule: A proposed transition may commit only if the protected invariant remains true afterward or a defined exception path is invoked.

purpose: Prevents locally convenient actions from becoming globally invalid states.

rule: The guard should be placed at the earliest reliable point before irreversible consequence.

purpose: Reduces harm, rework, and reliance on retrospective cleanup.

rule: A violation response must be safer than silent acceptance of the violation.

purpose: Avoids guards that identify risk but leave actors without a viable path.

rule: Exceptions must be narrower, more visible, and more accountable than the invariant they relax.

purpose: Allows necessary flexibility without turning the invariant into a suggestion.

rule: If the guard frequently blocks legitimate work, review the invariant, the translation into guard conditions, and the response path.

purpose: Prevents brittle or outdated guards from becoming obstacles that people bypass.

Must-Preserve Property

description: The named property remains true across permitted transitions rather than being repaired only after breakage.

Valid Transition Only

description: Committed changes are allowed only when they preserve the invariant or follow an explicit exception path.

Visible Violation Response

description: Blocked, repaired, rolled-back, or escalated transitions are visible enough to learn from and govern.

Exception Accountability

description: Authorized exceptions do not become untracked bypasses of the invariant.

Guard-Invariant Alignment

description: The concrete guard condition continues to test the real invariant rather than a stale proxy.

Fewer Invalid Transitions

description: Changes that would break a must-preserve property are caught before they become normal system state.

Stronger System Integrity

description: Actors can trust that core safety, authority, identity, or consistency properties survive routine change.

Lower Rework and Repair Cost

description: Preventing violations upstream reduces downstream cleanup, compensation, and emergency exception handling.

Clearer Exception Governance

description: Necessary exceptions become visible decisions rather than hidden drift or informal bypass.

Safer Automation and Delegation

description: Work can scale across people or machines without relying entirely on tacit memory of what must remain true.

prose_essence:
Invariant Guarding protects conditions that must remain true while a system changes. The key move is not simply to check quality after work is done. It is to declare the must-preserve property, locate transitions that can break it, and install a guard and response path at the point where an invalid transition would otherwise become accepted state.

This archetype is useful whenever the phrase “that should never happen” describes a real structural requirement rather than a vague hope. A ledger should not become unbalanced. A medication order should not lose patient identity. A safety-critical machine should not start when protective conditions are absent. A delegated decision process should not violate eligibility, notice, or appeal rights just because the local case is unusual.

prose_when_to_use:
Use Invariant Guarding when the system can change in many locally plausible ways but must preserve a nonnegotiable property across those changes. The invariant may be technical, such as referential integrity; operational, such as a safe machine state; institutional, such as separation of duties; or ethical/legal, such as due-process rights in a decision workflow.

The archetype is strongest when the invariant can be named, risky transitions can be observed, and a safe response exists. It is weaker when the protected property is merely a preference, when the relevant evidence is invisible, or when blocking a transition creates harm without a review or repair path.

prose_structural_problem:
The structural problem is that change threatens a property the system depends on. Individual actors, operations, or automated steps may each seem reasonable, but their effects can combine into a state that violates safety, integrity, authority, identity, or legitimacy.

Invariant failures often appear as impossible states: records that should not exist, orders that should not have been released, exceptions that should not have been approved, or configurations that should not have been reachable. These are signs that the invariant may be known culturally but not guarded structurally.

prose_intervention_logic:
The intervention begins by stating the invariant in usable language. Then it maps where transitions can break that invariant. A guard condition translates the invariant into a check, rule, interlock, review criterion, or accountability requirement. The guard is placed before commitment, side effect, or irreversible exposure where feasible. Finally, the system defines what happens when the guard fires: block, repair, roll back, defer, escalate, isolate, or authorize a scoped exception.

The important distinction is that a guard is not just a warning. A warning may be part of the mechanism, but invariant guarding requires a response path that preserves or restores the must-preserve property.

prose_key_components:
### Invariant Definition

The invariant must be precise enough to guide action but not so narrow that it protects an obsolete proxy instead of the real property. Its role in this archetype is: States the condition that must remain true across permitted transitions.

### Transition Scope

A guard that is not attached to the relevant transition point either fires too late or fails to see the violation. Its role in this archetype is: Identifies which operations, decisions, handoffs, updates, exceptions, or state changes must be checked.

### Guard Condition

Guard conditions can be formal rules, tests, interlocks, review criteria, or accountable human checks. Its role in this archetype is: Translates the invariant into a condition that can approve, block, route, or flag a proposed transition.

### Validation Rule

The roadmap explicitly treats validation_rule as a component, not as a standalone archetype. Its role in this archetype is: Checks evidence that the proposed transition preserves the invariant.

### Violation Response Path

A guard without a response path creates delay, workarounds, or hidden acceptance of the violation. Its role in this archetype is: Defines what happens when a transition would break the invariant.

### Rollback or Repair Policy

Rollback is strongest before irreversible side effects; repair is useful when valid correction is possible and visible. Its role in this archetype is: Restores a valid state or repairs the proposed transition when a violation is detected.

### Monitoring Signal

Monitoring is a support component; it becomes invariant guarding only when connected to transition control and response. Its role in this archetype is: Tracks violations, near misses, bypasses, false rejections, and drift in the invariant or guard.

### Exception Policy

Exceptions should be narrow, authorized, traceable, and reviewed; otherwise they become institutionalized bypass. Its role in this archetype is: Specifies when and how an invariant may be relaxed, overridden, or interpreted under unusual conditions.

### Invariant Owner

Ownership is especially important in policy, safety, and organizational settings where no automated rule fully captures the invariant. Its role in this archetype is: Assigns accountability for maintaining the invariant, interpreting edge cases, and reviewing guard drift.

### Audit Trace

An audit trace helps distinguish legitimate exceptions from quiet erosion of the invariant. Its role in this archetype is: Records guard decisions, violations, overrides, repairs, and review outcomes.

### Drift Review Cadence

Stale invariants cause brittle blocking, false assurance, or inequitable enforcement. Its role in this archetype is: Sets a schedule or trigger for reviewing whether invariants and guards still match current reality.

prose_common_mechanisms:
### Database Constraint

Database constraints are a concrete way to enforce record invariants such as uniqueness, referential integrity, and balance. They are not the archetype itself; they implement the archetype when the protected property is encoded in data structure.

### Safety Interlock

Safety interlocks implement invariant guarding by making a hazardous action impossible or difficult unless enabling safety conditions are true. The broader archetype also requires a clear invariant and a response path when the interlock blocks work.

### Invariant Test Suite

Invariant tests explore whether common, rare, and regression cases preserve declared properties. They are strongest when paired with design changes or runtime guards that prevent failed cases from being accepted.

### Contract Check

Contract checks apply preconditions, postconditions, and state assumptions at a boundary. They instantiate invariant guarding when those conditions express a property that must remain true across the handoff or transition.

### Policy Guardrail

Policy guardrails implement institutional invariant guarding by routing, refusing, or requiring evidence for decisions that might violate a rule, right, eligibility condition, or segregation-of-duties requirement.

### Integrity Monitor

Integrity monitors are observability mechanisms. They support the archetype by showing violations, near misses, and bypasses, but they become guarding only when connected to blocking, repair, rollback, escalation, or governance.

### Rollback Transaction

Rollback transactions implement a response path: when a proposed change fails the invariant check, the system returns to a known valid state instead of committing a partial or invalid result.

### Two-Person Rule

Two-person rules implement invariant guarding in high-risk settings by requiring independent confirmation before a transition that could break a safety, authority, or security condition.

prose_failure_modes:
A common failure mode is proxy guard drift: the guard checks something measurable that no longer represents the real invariant. Another is bypass normalization, where a guard is so slow or overbroad that people learn to route around it. A third is overbroad invariance, where a tradition or convenience rule is mislabeled as a necessary condition.

Late guard placement is also dangerous. A check that fires after commitment may document the violation but not prevent it. Exception erosion is another risk: if overrides accumulate without review, the invariant no longer governs the system. Finally, superficial validation can create false assurance when the format passes but the substantive invariant is still broken.

prose_neighbor_distinctions:
Invariant Guarding is close to Closure-Preserving Operation, but the emphasis differs. Closure-Preserving Operation asks whether an operation returns an in-domain output or fails cleanly. Invariant Guarding asks whether a property remains true across transitions, possibly across many operations, actors, and exception paths.

It is also distinct from Constraint Envelope Adjustment. That archetype changes or sets the acceptable envelope; Invariant Guarding protects a declared invariant once the relevant property is known. It is distinct from Data Integrity Preservation because data integrity is one important domain family, while invariant guarding can protect safety, authority, identity, eligibility, resource, or institutional properties. It is distinct from Fail-Safe because fail-safe design focuses on the safe state under failure, while invariant guarding focuses on preventing or responding to invariant-breaking transitions.

prose_cross_domain_examples: In software, a booking service preserves invariants such as valid identity, available inventory, and coherent payment state before confirming an order. In finance, a ledger system rejects commits that would unbalance debits and credits. In clinical care, a medication workflow blocks or routes orders when identity, allergy, dosage, or interaction checks fail. In public administration, a delegated decision process preserves eligibility, notice, and appeal rights across local variation. In manufacturing, interlocks prevent operation when protective guards, emergency stops, temperature, or pressure conditions are unsafe.

prose_non_examples: A general reminder to “be careful” is not invariant guarding because it has no explicit invariant, transition scope, guard condition, or response path. A retrospective quality report is not invariant guarding unless it changes transition control. A format-only validation rule is not enough if the substantive invariant can still be violated. A dashboard that displays errors is monitoring, not guarding, unless it triggers blocking, repair, rollback, escalation, or accountable review.

prose_tradeoffs:
Invariant guarding trades flexibility for integrity. Hard guards prevent violations but can reject legitimate edge cases. Soft guards preserve judgment but may become weak if no one is accountable for override decisions. Early guards prevent propagation but may lack context. Late guards have more context but may detect problems after harm or rework has already occurred.

The most important tradeoff is between stability and adaptation. A must-preserve property should be stable enough to support trust, but the organization also needs a way to revise the invariant when reality changes or when the invariant turns out to encode an unjust assumption.

prose_invariants_to_preserve:
The primary invariant is the must-preserve property itself. The system should not commit a transition that breaks it. A second invariant is valid-transition discipline: changes are accepted only when the invariant remains true or an explicit exception path is invoked. A third invariant is visible violation response: blocked, repaired, or overridden transitions should be visible enough to govern and learn from.

Exception accountability is also an invariant. If exceptions become invisible, the guard dissolves into informal discretion. Finally, guard-invariant alignment must be preserved: the concrete guard should continue to test the real property, not a stale proxy that is merely easier to measure.

prose_target_outcomes:
Successful invariant guarding reduces impossible states, downstream cleanup, and unsafe or illegitimate decisions. It increases trust that core properties survive delegation, automation, concurrency, and change. It also clarifies exception governance: when an invariant is relaxed, the relaxation becomes a visible decision rather than hidden drift.

In mature implementations, violations become learning signals. A blocked transition can reveal a design flaw, a missing case, a stale invariant, a training need, or an adversarial bypass attempt.

prose_parameter_dimensions:
Several tuning dimensions shape how Invariant Guarding should be designed. The first is strictness: some invariants must be enforced with hard stops, while others need reviewable soft stops because context matters. The second is placement: a guard can appear before action, during transition, at commit, during handoff, or after detection with rollback. Earlier placement reduces harm but may require more context or instrumentation.

A third dimension is exception tolerance. Invariant guarding should not pretend that exceptions never exist; it should make exceptions scoped, authorized, visible, and reviewable. A fourth dimension is automation level. Automated guards scale, but human review may be necessary where the invariant is normative, context-sensitive, or equity-sensitive. A fifth dimension is drift review cadence: invariants and guards need periodic review when the domain changes, failure modes shift, or false positives create bypass pressure.

prose_variants_and_near_names:
The draft captures runtime invariant guarding, policy invariant guarding, safety interlock guarding, and data integrity invariant guarding as variants. Runtime variants check live transitions. Policy variants protect institutional commitments across delegated decisions. Safety variants emphasize harm prevention and conservative response under uncertainty. Data integrity variants protect record and ledger properties but should be reviewed against the broader data-integrity family.

Near names include invariant enforcement, invariant preservation, integrity guarding, guardrail, and contract check. Guardrail and validation rule should not be drafted as separate archetypes here; they are components or mechanisms that can serve this archetype and several neighbors.

Runtime Invariant Guarding

short_definition: Guard invariants while a system is operating, so invalid transitions are blocked, repaired, or rolled back before they become committed state.

distinctive_feature: The guard is active during operation, not only during design, review, or retrospective audit.

distinct_from_parent: The parent archetype covers invariant protection across any governance or process setting; this variant focuses on live transition checks in an operating system.

still_same_parent_because: The structural intervention is still to define always-true properties and prevent transitions that would break them.

source_primes: closure invariance data_integrity

use_when: The system changes too frequently for a design-time review alone to preserve the invariant.

use_when: Transitions can be observed at runtime and checked before irreversible side effects occur.

use_when: The cost of a false acceptance is higher than the cost of checking, retrying, or routing for review.

example_domains:
software systems
workflow automation
financial transaction systems

domain: software

example: An account object cannot commit a balance update that breaks the rule that settled debits and credits reconcile.

domain: operations

example: A dispatch system refuses an assignment that would leave a required safety role unstaffed.

failure_modes: The guard checks a stale invariant after the operating context has changed.

failure_modes: The check is placed too late, after the invalid state has already produced side effects.

failure_modes: Operators learn to bypass the guard because the response path is too slow or punitive.

Policy Invariant Guarding

short_definition: Guard institutional or policy conditions that must remain true across decisions, exceptions, delegation, and implementation drift.

distinctive_feature: The invariant is institutional or normative rather than only technical or mathematical.

distinct_from_parent: The parent covers any invariant; this variant emphasizes delegated authority, exceptions, accountability, and appeal in policy environments.

still_same_parent_because: The core move is still to preserve always-true properties across transitions rather than merely documenting rules.

source_primes: constraint accountability invariance

use_when: A rule, right, eligibility condition, or institutional commitment must survive many local decisions.

use_when: Exceptions are necessary but must not dissolve the core policy property.

use_when: Delegated actors need a visible rule for when discretion crosses into violation.

example_domains:
public administration
legal compliance
organizational governance

domain: public administration

example: A benefits workflow may vary documentation requests but cannot approve a case that violates statutory eligibility.

domain: organizational governance

example: A delegation policy allows local decisions only while preserving segregation of duties.

failure_modes: The invariant is framed so vaguely that it becomes symbolic rather than enforceable.

failure_modes: Exception handling quietly becomes a route around the invariant.

failure_modes: The guard protects institutional convenience while obscuring affected-party rights or needs.

Safety Interlock Guarding

short_definition: Guard life, health, or damage-prevention invariants by preventing hazardous transitions when required safety conditions are absent.

distinctive_feature: The guarded invariant is safety-critical and often requires conservative default behavior.

distinct_from_parent: The parent can protect any invariant; this variant emphasizes harm prevention, interlocks, redundancy, and fail-safe response.

still_same_parent_because: The intervention is still invariant guarding: the system blocks or redirects transitions that would break a must-preserve condition.

use_when: Violation could produce irreversible harm, injury, severe loss, or unsafe exposure.

use_when: A transition is permissible only if multiple enabling conditions are simultaneously true.

use_when: The default under uncertainty should be hold, stop, isolate, or route to accountable review.

example_domains:
clinical care
industrial operations
transportation systems

domain: clinical care

example: A medication order cannot be released when the patient identity, allergy status, or dose boundary is unresolved.

domain: industrial operations

example: A machine will not start unless guards are closed and emergency stop circuits are available.

failure_modes: The safety guard is bypassed because it blocks normal work too often.

failure_modes: A narrow sensor reading is mistaken for the full safety invariant.

failure_modes: The response path stops the process but does not make the hazard visible or accountable.

Data Integrity Invariant Guarding

short_definition: Guard record, ledger, schema, or provenance properties that must remain true as information is created, transformed, or reconciled.

distinctive_feature: The invariant concerns record integrity and trustworthiness rather than any system property in general.

distinct_from_parent: The parent can guard non-data properties such as safety, identity, authority, or resource commitments; this subtype is data-centered.

still_same_parent_because: The data case still uses the parent intervention: define must-preserve properties and guard transitions against violations.

source_primes: data_integrity invariance transaction

use_when: Data or records are transformed, merged, or transferred across systems.

use_when: Loss of consistency, balance, provenance, or authority would corrupt downstream decisions.

use_when: A commit, synchronization, or reconciliation step can test the invariant before accepting a new state.

example_domains:
data governance
finance
records management

domain: finance

example: A ledger update cannot commit unless debits and credits remain balanced.

domain: records management

example: A case file cannot be closed unless required provenance fields remain attached.

failure_modes: The data integrity subtype absorbs broader data governance archetypes that need separate treatment.

failure_modes: Technical constraints preserve format while substantive accuracy still drifts.

near_names:
Invariant Enforcement
Invariant Preservation
Guardrail
Integrity Guard
Contract Check


Invariant-Mode Decomposition Design

type: archetype

source: generated

batch: Batch 12

canonical_family: Signal Transformation & Mapping Effects

aliases:
Invariant Mode Analysis
Spectral Mode Decomposition Design
Dominant Mode Analysis
Eigensystem Design
Modal Response Design
Invariant Direction Mapping

source_primes: eigenvalue_and_eigenvector transformation invariance decomposition linearity basis projection linear_combination

slug: transformation

slug: invariance

slug: decomposition

slug: linearity

slug: basis

slug: projection

slug: equivariance

slug: stability

slug: amplification

slug: damping

slug: resonance

slug: feedback

slug: controllability

slug: observability

slug: network

slug: nonlinearity

slug: distortion

slug: convolution

components:
Transformation Scope
State-Vector Definition
Invariant Mode Basis
Modal Gain Spectrum
Dominant Mode Selection Rule
Stable/Unstable Mode Partition
Modal Intervention Map
Reconstruction Residual Check
Mode Drift Monitor
Interpretation Scope Contract
Mode-Coupling Register
Local Linearization Window
Spectral Gap Threshold

mechanisms:
Eigendecomposition Workflow
Spectral Decomposition Report
Power-Iteration Probe
Principal Component Analysis
Singular Value Decomposition
Modal Stability Analysis
Mode-Shape Testing
Spectral Gap Monitor
Reduced-Order Model
Modal Sensitivity Sweep
Network Spectral Centrality Analysis
Residual Reconstruction Test

compression_statement: Invariant-Mode Decomposition Design applies when a system, model, network, process, or repeated operation transforms many interacting variables and ordinary coordinates obscure which directions actually persist, grow, decay, oscillate, or dominate. The archetype defines the transformation and state space, extracts invariant modes, ranks their scalar response, partitions stable and unstable behavior, acts on modal coordinates where intervention leverage is highest, and validates residual behavior so the modal view remains useful rather than mystical.

core_intuition: A complex transformation can look tangled in the original variables while being simple in its own preferred directions. Once those directions are visible, the system can ask which mode is growing, which is dying, which is merely cosmetic, and which intervention actually touches the active structure.

canonical_formula: For transformation T, identify modes v_i such that T v_i = λ_i v_i. Express x = Σ a_i v_i when justified, so repeated action follows T^k x = Σ a_i λ_i^k v_i, with residual r monitored when the modal basis is incomplete or approximate.

structural_problem: A transformation acts on many variables at once, but visible coordinates, surface metrics, or local symptoms do not reveal which directions are amplified, damped, preserved, reversed, or structurally dominant. Interventions then chase components rather than modes, miss unstable directions, or overfit behavior that is residual rather than modal.

trigger_conditions: A process can be represented as a transformation, transition rule, linearized local model, covariance-like map, network update, or repeated operation.

trigger_conditions: Outcomes depend on combinations of variables rather than independent single variables.

trigger_conditions: Some directions persist, grow, decay, or dominate more predictably than others.

trigger_conditions: Compression, control, stability, ranking, or explanation requires knowing which modes matter.

trigger_conditions: A candidate modal model can be checked against raw behavior or residual reconstruction.

trigger_conditions: The system has enough stationarity or local validity for modal interpretation to be meaningful.

symptoms: Many variables move together in repeatable patterns that are hard to interpret one at a time.

symptoms: Small interventions in some combinations produce large effects while obvious coordinate-level changes do little.

symptoms: Repeated application of a process converges to, diverges along, or oscillates around a recognizable pattern.

symptoms: Dimensionality-reduction outputs are useful but lack a transformation-based interpretation.

symptoms: A system appears stable on average while one hidden mode grows toward failure.

symptoms: A control, ranking, or monitoring metric keeps missing the actual direction of amplification.

root_tension: The coordinate system humans can name is not necessarily the coordinate system the transformation uses. Practical control requires translating between surface variables and the transformation’s invariant directions without pretending the modal approximation is exact everywhere.

anti_signatures: The behavior is dominated by one directly observable variable with no meaningful coupled transformation.

anti_signatures: The system changes so quickly that extracted modes have no stable interpretation or use window.

anti_signatures: The decomposition is used only as a mathematical display with no decision, control, compression, or monitoring consequence.

anti_signatures: The transformation is strongly nonlinear and no local linearization window or residual check is possible.

anti_signatures: The goal is simply to reduce variables for visualization without interpreting scalar response under a transformation.

structural_intervention: Define the transformation and state representation, extract invariant or approximately invariant modes, rank their scalar response, choose action-relevant modes, map interventions into modal coordinates, and maintain residual and drift checks so the modal view remains fit for use.

action_logic: Scope the transformation: what operation, transition, matrix, network update, model layer, or repeated process is being analyzed.

action_logic: Define the state representation and preserve traceability from modal coordinates back to original variables.

action_logic: Estimate invariant modes and their scalar responses using eigendecomposition, spectral decomposition, local linearization, or a domain-appropriate analog.

action_logic: Rank modes by growth, decay, persistence, variance, energy, safety consequence, interpretability, or control leverage.

action_logic: Partition modes into dominant, stable, unstable, oscillatory, neutral, and residual categories.

action_logic: Choose interventions, monitors, or simplified models that act on the relevant modes rather than merely on surface coordinates.

action_logic: Validate the modal model through reconstruction, perturbation, backtesting, domain review, and residual analysis.

action_logic: Define interpretation limits, drift triggers, and escalation rules for when the transformation or operating regime changes.

decision_rules: Use this archetype only when the transformation is explicit enough for invariant-mode reasoning or approximate enough for a bounded local analysis.

decision_rules: Promote a mode to decision relevance when its gain, persistence, risk consequence, or explanatory contribution exceeds the chosen threshold.

decision_rules: Do not discard residuals unless reconstruction loss and domain consequences are within an explicit budget.

decision_rules: Treat large unstable or weakly damped modes as monitoring and control priorities even when their original-variable footprint is not visually salient.

decision_rules: Re-estimate modes after regime shift, model update, topology change, distribution shift, or repeated residual failure.

target_invariants: Traceability from modal directions back to original variables and domain meaning.

target_invariants: Explicit scalar response for each action-relevant mode.

target_invariants: Residual visibility for behavior not explained by selected modes.

target_invariants: Interpretation limits for local, approximate, or linearized decompositions.

target_invariants: Stable governance over when modes are trusted, revised, or retired.

expected_outcomes: Dominant or unstable directions become visible before they drive failure or overreaction.

expected_outcomes: Compression and reduced-order models preserve behavior that matters instead of arbitrary variables.

expected_outcomes: Interventions target combinations of variables where leverage actually accumulates.

expected_outcomes: Monitoring shifts from surface symptoms to modal drift, modal gain, and residual growth.

expected_outcomes: Explanations distinguish structural modes from coordinate artifacts.

prose_essence:
Find the directions a transformation preserves as directions, measure how strongly it stretches or damps each one, and use those modes to prioritize explanation, control, compression, and monitoring.

This archetype treats eigenvalue/eigenvector reasoning as a practical design pattern: identify the directions a transformation itself treats as stable directions, measure the scalar response of each direction, and use that modal view to focus explanation, monitoring, compression, and intervention.


Invasive Entrant Containment

batch: Batch 01

canonical_family: Adaptation Under Adversarial Pressure

aliases:
Novel Entrant Containment
Native Control Gap Closure
Invasion Front Containment
Invasive Species Management Pattern
Biological Invasion Control
Newcomer Establishment Control
Release-from-Control Containment
Incumbent Displacement Prevention

source_primes: invasive_species release_from_controlling_context containment boundary diffusion adaptation competition

slug: containment

slug: boundary

slug: diffusion

slug: adaptation

slug: competition

slug: coevolution

slug: internalization

slug: kairos

slug: resilience

slug: risk

slug: constraint

slug: threshold

slug: sequestration

slug: permeability

slug: homeostasis

slug: maintenance

slug: recovery

slug: instability

slug: antagonist

slug: flow

components: Collateral Impact and Legitimacy Guardrail

mechanisms: Intake Inspection and Quarantine Protocol

essence_one_line: Close the native-control gap around a fast-spreading newcomer before it establishes, propagates, and displaces the system that failed to recognize it.

compression_statement: An invasive entrant is not merely a bad thing crossing a boundary. It is a newcomer whose behavior was constrained in one context but is released in a recipient context that lacks matching predators, norms, filters, competitors, regulators, or response routines. The solution is therefore not only exclusion or generic spread containment. The system must identify the release pathway, detect establishment early, reduce introduction pressure, contain the advancing front, rebuild or substitute missing controls, protect incumbents while they adapt, and monitor for rebound or displacement.

core_intuition: The danger appears during the lag between arrival and adaptation. If the system waits until the newcomer is visibly dominant, its spread has already converted a local anomaly into a new regime. Invasive Entrant Containment treats the first sightings, pathways, and ecological opportunities as a narrow kairotic window: act while the entrant is still path-dependent and before incumbents lose the capacity to recover.

canonical_formula: invasion_risk ≈ introduction_pressure × establishment_fit × control_gap × propagation_connectivity × adaptation_lag ÷ (early_detection × containment_speed × incumbent_resilience × restored_controls)

structural_problem: A newcomer moves from a context where its growth, behavior, or advantage was constrained into a recipient system where those controlling relations are absent, weak, delayed, or misclassified. Because the recipient system treats the entrant as ordinary, tolerable, useful, or too small to matter, the entrant crosses an establishment threshold and begins displacing resident actors, practices, species, norms, competitors, or resources before controls can be rebuilt.

trigger_conditions: A boundary or pathway allows arrival from a source context into a recipient context.

trigger_conditions: The recipient context lacks one or more controls that kept the entrant bounded elsewhere.

trigger_conditions: The entrant can reproduce, copy, recruit, exploit resources, or propagate faster than the local response cycle.

trigger_conditions: Early observations are sparse, ambiguous, politically inconvenient, or discounted as harmless novelty.

trigger_conditions: Incumbents are adapted to the old control regime and cannot immediately compete, resist, or compensate.

trigger_conditions: By the time aggregate harm becomes obvious, removal costs, collateral damage, or regime lock-in will be much higher.

symptoms: A newcomer is initially treated as a local nuisance, exception, pilot, rumor, edge case, or harmless import, then becomes a systemic pressure.

symptoms: Native controls work against familiar entrants but fail against the new actor because its cues, timing, pathway, or resource use differ.

symptoms: The entrant exploits corridors, disturbed sites, neglected interfaces, unmoderated channels, or under-governed niches.

symptoms: Responses remain fragmented by jurisdiction, team, land parcel, platform surface, or product boundary while the entrant spreads across them.

symptoms: Incumbents decline before the system can prove causation cleanly enough to justify decisive action.

symptoms: Later interventions become blunt, expensive, unpopular, or damaging because early precise containment was missed.

root_tension: The system must act early when evidence is incomplete, but early action against a newcomer can look overreactive, protectionist, exclusionary, or hostile to legitimate novelty. Waiting for certainty preserves procedural caution while giving the entrant time to establish.

anti_signatures: The problem is only generic spread through a network with no special establishment threshold or native-control gap; Diffusion Containment may be closer.

anti_signatures: The problem is only deciding what crosses a boundary, without post-entry adaptation, displacement, or spread; Boundary Permeability Control may be closer.

anti_signatures: The problem is emergent harm from many local interactions with no identifiable newcomer or release pathway; Harmful Emergence Containment may be closer.

anti_signatures: The problem is propagation geometry at an advancing front regardless of entrant identity; Wavefront Propagation Management may be closer.

anti_signatures: The newcomer is beneficial and the goal is adoption rather than containment; Diffusion Acceleration or Absorptive Capacity Building may be closer.

anti_signatures: The system is already in a new regime and recovery is the primary task; Equilibrium Restoration, Adaptive Reconfiguration, or Recovery may be closer.

structural_intervention: Build a control stack around arrival, establishment, spread, displacement, and adaptation: map introduction pathways, detect first establishment, reduce arrival pressure, contain local populations or instances, rebuild missing controls, support incumbents, and monitor for rebound or migration into new niches.

action_logic: Define the protected system, the entrant, the incumbents at risk, and the controlling relations missing in the recipient context.

action_logic: Map source contexts, arrival pathways, carriers, corridors, disturbed sites, weak interfaces, and governance seams through which the entrant can move.

action_logic: Set early warning indicators for first establishment rather than waiting for large-scale harm.

action_logic: Reduce introduction pressure at the pathway level so containment does not fight an endless inflow.

action_logic: Create fast triage rules that distinguish watch, suppress, contain, eradicate, adapt-with-guardrails, and tolerate decisions.

action_logic: Act at the local establishment site and advancing front while the entrant remains spatially, socially, or operationally bounded.

action_logic: Install or restore substitute controls: predators, filters, competition, norms, access rules, monitoring, friction, or resource constraints.

action_logic: Protect incumbents during the adaptation lag so displacement does not become irreversible before controls mature.

action_logic: Coordinate across boundaries because the entrant will exploit seams between teams, jurisdictions, owners, channels, and habitats.

action_logic: Track collateral harm, adaptation of the entrant, displacement into neighboring contexts, and rebound after apparent success.

decision_rules: If arrival pressure remains high, prioritize pathway controls before repeated local removals.

decision_rules: If the entrant is not yet established, use exclusion, inspection, quarantine, or rollback rather than adaptation-first strategies.

decision_rules: If establishment is local and bounded, use rapid response containment before investing in broad equilibrium restoration.

decision_rules: If eradication would cause more harm than bounded coexistence, switch to suppression and incumbent support with explicit thresholds.

decision_rules: If native controls are missing because of a degraded recipient context, repair the context rather than only attacking the entrant.

decision_rules: If the entrant has already crossed a regime threshold, shift from containment to long-term control, restoration, and adaptive reconfiguration.

decision_rules: If controls generate selection pressure that makes the entrant harder to manage, diversify controls and monitor for coevolutionary escape.

decision_rules: If intervention burdens fall on legitimate newcomers or vulnerable incumbents, add due process, proportionality, and review safeguards.

target_invariants: The protected system and incumbents are explicitly named; otherwise containment becomes vague exclusion.

target_invariants: Controls target the release pathway and establishment mechanism, not only visible symptoms.

target_invariants: Early action remains proportional, reversible when possible, and evidence-updating rather than permanently hostile to novelty.

target_invariants: Boundary controls are paired with post-entry monitoring because some entrants will bypass or already be inside the boundary.

target_invariants: Containment does not merely displace the entrant into a less observed neighboring context.

target_invariants: Incumbent support does not freeze obsolete structures that should adapt, diversify, or transition.

target_invariants: The system distinguishes harmful invasion from ordinary exchange, migration, innovation, or competition.

expected_outcomes: Introduction pathways are narrowed or governed before inflow overwhelms response capacity.

expected_outcomes: Early establishment is detected while local intervention is still feasible.

expected_outcomes: Spread velocity declines because fronts, carriers, and corridors are interrupted.

expected_outcomes: Missing native controls are substituted, restored, or replaced by adaptive controls suited to the new context.

expected_outcomes: Incumbents have enough time, resources, and protected refuges to adapt or recover.

expected_outcomes: The system avoids both denial until takeover and indiscriminate closure against all newcomers.

prose_tradeoffs: Early action reduces establishment risk but increases the chance of false positives. Openness brings exchange and innovation but also more arrival pressure. Strong controls can prevent displacement but may create collateral damage or select for evasive entrants. Incumbent protection can preserve valued functions but can also become protectionism. Central response brings speed; local response brings context. The archetype works only when those tradeoffs are made explicit.

Ecological Invasion Management

short_definition: Manage non-native biological entrants that establish and displace resident ecological communities.

distinctive_feature: The incumbent system is ecological and controls may include predators, competitors, habitat condition, and restoration dynamics.

distinct_from_parent: It specializes the parent into biological population dynamics and environmental management.

still_same_parent_because: The core pattern remains release from native controls plus establishment, spread, and displacement.

use_when: The protected system is a habitat, landscape, water body, or ecological community.

use_when: Controls include pathway biosecurity, monitoring, eradication, suppression, restoration, or coexistence policy.

Biosecurity Pathway Control

short_definition: Reduce arrival pressure by governing the pathways through which organisms, pathogens, contaminants, or high-risk materials enter.

distinctive_feature: It concentrates on pre-entry and pathway-level controls rather than post-establishment management.

distinct_from_parent: It may not need incumbent recovery or adaptive control rebuild if arrival can be prevented.

still_same_parent_because: It serves the same invasive-entry risk model at an earlier phase.

use_when: Prevention is more feasible than post-entry removal.

use_when: Carriers, corridors, supply chains, transport, or imports are known control points.

Platform Abuse Invasion Control

short_definition: Prevent a new abuse pattern, account type, automation tactic, or manipulation format from establishing across a platform whose normal controls do not yet recognize it.

distinctive_feature: The missing native controls are classifiers, policies, frictions, trust signals, and moderation workflows.

distinct_from_parent: The substrate is digital and governance-heavy rather than ecological.

still_same_parent_because: The same arrival-establishment-spread-adaptation-lag structure applies.

source_primes: access_control network diffusion classification

use_when: A new abusive behavior is spreading through platform surfaces faster than policy, classifiers, or enforcement queues can adapt.

use_when: Controls must avoid harming legitimate users or exposing operational abuse details.

Market Displacement Invasion Guardrail

short_definition: Guard a market or institutional field against a newcomer whose ungoverned advantage can quickly displace incumbents before rules adapt.

distinctive_feature: Legitimacy and anti-protectionist guardrails are especially important because competition may be beneficial.

distinct_from_parent: It focuses on institutional and market governance rather than ecological or biological spread.

still_same_parent_because: The pattern is still missing controls plus fast establishment before adaptive regulation.

source_primes: competition risk winner_take_all_market

use_when: The entrant exploits a regulatory, data, labor, subsidy, network-effect, or externality gap.

use_when: The goal is fair adaptation rather than incumbent protectionism.

name: Organizational Practice Invasion Control

short_definition: Stop an imported practice, tool, norm, metric, or workflow from spreading across an organization before local controls and meaning have caught up.

distinctive_feature: The entrant is a practice or norm whose legitimacy may be socially internalized before harms are visible.

distinct_from_parent: It centers organizational norms, adoption incentives, and internalization dynamics.

still_same_parent_because: It preserves the release-from-control and displacement logic of the parent.

source_primes: internalization adaptation boundary

use_when: A practice imported from one context bypasses local accountability, safety, quality, or cultural controls.

use_when: The goal is selective adaptation, not blanket resistance to change.

near_names:
Novel Entrant Containment
Native Control Gap Closure
Invasion Front Containment
Biological Invasion Control
Invasive Species Management Pattern
Release-from-Control Containment


batch: Batch 15

canonical_family: Constrained Resource Recomposition and Improvisational Design

aliases:
Resourceful Recomposition
Fixed-Inventory Solution Assembly
Constraint-Bounded Bricolage
Available-Resource Recomposition
Disciplined Make-Do Design

source_primes: bricolage affordance exaptation composition constraint resource_management

slug: bricolage

slug: affordance

slug: exaptation

slug: composition

slug: substitutability

slug: modularity

slug: scarcity

slug: improvisation

slug: compatibility

slug: interoperability

slug: robustness

slug: irreversibility

slug: satisficing

slug: coupling

slug: emergence

components:
Mission and Sufficiency Criterion
Fixed-Inventory Boundary
Resource Affordance Map
Functional Decomposition Map
Resource-to-Function Assignment
Substitution Rule
Non-Substitutable Constraint
Interface Contract
Adapter and Conversion Plan
Irreversible Consumption Budget
Keystone Resource Reserve
Compatibility Check
Configuration Record
Preserved Invariant Set
Sufficiency Test
Rollback Path
Provenance and Maintenance Record
Learning Record
Redundancy and Spare Pool
External Procurement Trigger
Upgrade or Demobilization Path

mechanisms:
Affordance Inventory Walkthrough
Fixed-Inventory Configuration Sprint
Functional Decomposition Workshop
Substitution Matrix
Capability Catalog
Modular Inventory
Technical Bypass or Adapter Design
Salvage and Cannibalization Workflow
System Integration Workflow
Integration Test Plan
Rapid Configuration Prototype
Cross-Training and Role Reassignment
Configuration Change Log
Temporary-Solution Expiry Review
Controlled Pilot

essence_one_line: Build a workable solution from the heterogeneous resources already at hand by discovering latent affordances, making safe substitutions, bridging incompatibilities, and iterating within an explicit fixed inventory.

compression_statement: When ideal inputs cannot be obtained in time, the design problem changes from selecting the best parts to discovering what the present stock can legitimately do. The intervention freezes an inventory boundary; states the mission and non-negotiable invariants; inventories resource condition, provenance, ownership, and affordances; decomposes the desired outcome into functions; maps available resources and combinations to those functions; distinguishes safe substitutions from non-substitutable requirements; designs adapters and conversions; protects keystone and irreversibly consumable resources; assembles the smallest reversible configuration; tests the integrated whole; records dependencies and maintenance; and sets triggers for rollback, outside procurement, upgrade, formalization, or demobilization.

core_intuition: A shortage of ideal parts does not imply a shortage of possible functions. Heterogeneous resources often contain unused affordances, but useful recombination appears only when capability is separated from conventional labels and then disciplined by compatibility, safety, option-value, traceability, and lifecycle controls.

canonical_formula: Let R be the fixed resource inventory, A(r) the verified affordances of resource r, F the required function set, C the hard constraint and invariant set, K the compatibility relations, U the irreversible-use and option-value costs, and Gamma a candidate configuration built by assignments, substitutions, adaptations, and interfaces. Select a feasible Gamma from configurations constructible from R such that every critical f in F is covered, C and K are preserved, and mission sufficiency S(Gamma) exceeds its threshold while risk, irreversible depletion, adapter burden, latency, and maintenance cost remain bounded. If no such Gamma exists, trigger procurement, escalation, mission reduction, or safe cessation rather than inventing capacity.

structural_problem: A required outcome must be produced before ideal resources, infrastructure, specialists, or procurement can become available. The present stock is heterogeneous, partly purpose-specific, unevenly documented, and constrained by ownership, condition, compatibility, safety, and opportunity cost. Conventional labels hide alternative uses, while ungoverned improvisation risks unsafe substitution, destructive cannibalization, opaque dependencies, and permanent patchwork debt.

trigger_conditions: The decision window is shorter than ordinary procurement, hiring, redesign, or infrastructure deployment.

trigger_conditions: A materially fixed inventory of resources, capabilities, roles, information, authority, or facilities is available.

trigger_conditions: The desired outcome can be decomposed into functions that may be covered by alternative resources or combinations.

trigger_conditions: Available items have latent affordances, transferable capabilities, or repurposable features beyond their conventional labels.

trigger_conditions: Interfaces and adaptations can be made explicit and tested rather than relying only on tacit local knowledge.

trigger_conditions: There is authority to reassign, adapt, or consume resources within declared safety, rights, ownership, and professional limits.

trigger_conditions: A provisional solution can be monitored, maintained, replaced, or dismantled after the immediate constraint relaxes.

symptoms: Teams repeatedly say that the required named part or specialist is missing even though equivalent functions may be available in other forms.

symptoms: Useful materials, tools, skills, spaces, relationships, or data remain idle because inventory is organized by original purpose rather than current affordance.

symptoms: Local actors already create undocumented workarounds, but results are fragile, unsafe, or impossible to hand off.

symptoms: One scarce connector, credential, tool, expert, vehicle, or authority becomes the hidden keystone of many possible configurations.

symptoms: The ideal design is known but unattainable inside the response window, causing paralysis or repeated requests for unavailable inputs.

symptoms: A temporary patch works once but cannot be reproduced because substitutions, versions, conditions, and interfaces were not recorded.

symptoms: Resources are cannibalized in order of visibility rather than by option value, creating larger future failures.

root_tension: The fixed inventory rewards reinterpretation and combination, but every repurposing move can create new incompatibilities, consume future options, violate legitimate constraints, or transfer hidden risk. The intervention must be inventive enough to escape ideal-part dependence and disciplined enough to distinguish resourcefulness from unsafe improvisation.

anti_signatures: The ideal components can be sourced normally within the decision window and the main task is ordinary system integration; use Compositional Assembly.

anti_signatures: The task is only to compare which alternatives preserve value, not to assemble and govern a working configuration; use Acceptable Substitution Mapping.

anti_signatures: The main intervention is converting locked resources into transferable or fungible forms for future redeployment; use Resource Liquefaction.

anti_signatures: The only issue is deciding how much of a scarce pool to allocate among predefined uses; use Constrained Resource Allocation.

anti_signatures: The main objective is to minimize features or scope even though resources are not inventory-bound; use Minimum Sufficient Solution.

anti_signatures: The work combines concepts, metaphors, or ideas without an operational fixed resource inventory; use Conceptual Blending for Innovation.

anti_signatures: A single object is reused for its original function without recombination, adaptation, or interface design; this is ordinary reuse, not the full archetype.

anti_signatures: The proposed action is an undocumented ad hoc patch with no sufficiency criterion, invariant set, validation, owner, maintenance, or exit path.

structural_intervention: Treat the available stock as a bounded design language rather than a defective version of the ideal bill of materials. Define the mission and hard invariants; freeze and verify the inventory; map latent affordances; decompose the outcome into functions; assign resources and combinations to those functions; govern substitutions, adapters, compatibility, and irreversible use; protect keystone resources; build and test a reversible minimum configuration; document provenance and ownership; and explicitly decide whether to operate, iterate, rollback, procure externally, upgrade, formalize, or demobilize.

action_logic: State the required outcome, minimum sufficiency threshold, operating duration, load, environment, and non-negotiable safety, legal, ethical, and rights constraints.

action_logic: Declare the fixed-inventory boundary for the decision window and separate verified available stock from inaccessible, hypothetical, already committed, or prohibited resources.

action_logic: Inspect resource condition, provenance, ownership, maintenance state, competence requirements, and alternative affordances rather than relying on labels alone.

action_logic: Decompose the outcome into critical, supporting, optional, and sequence-dependent functions, with explicit interface and performance requirements.

action_logic: Generate resource-to-function assignments and combination candidates, including exaptations and substitutions, while exposing contentions and uncovered functions.

action_logic: Mark non-substitutable requirements and reject candidates that depend on unsafe equivalence, absent competence, unauthorized access, or unverified condition.

action_logic: Design adapters, conversions, translations, fixtures, training, or procedural bridges for mismatched interfaces and account for their cost and failure modes.

action_logic: Reserve keystone resources and set an irreversible-consumption budget so early experiments do not destroy higher-value future configurations.

action_logic: Prototype the smallest reversible configuration that can test the central function and the highest-risk interfaces.

action_logic: Run component and system-level compatibility, load, duration, containment, recovery, and misuse tests against the preserved invariant set.

action_logic: Iterate assignments and interfaces using evidence, but stop when mission sufficiency is reached or the safe local feasible region is exhausted.

action_logic: Record the final configuration, substitutions, versions, provenance, dependencies, owners, inspection needs, and operating limits.

action_logic: Gate use with monitoring, rollback, spare, escalation, and external-procurement triggers proportionate to uncertainty and consequence.

action_logic: At the expiry or condition-change point, upgrade, formalize, transfer, replace, or dismantle the provisional configuration instead of allowing it to persist by inertia.

decision_rules: Use the archetype only when the inventory boundary is real during the relevant decision window; do not manufacture scarcity to justify a preferred improvisation.

decision_rules: Treat a resource's verified affordances, condition, and constraints as evidence; do not infer safe capability from appearance or analogy alone.

decision_rules: Prefer reversible, inspectable, low-consumption probes before irreversible conversion or cannibalization unless delay creates greater harm.

decision_rules: Protect keystone resources when their option value across future configurations exceeds the immediate marginal benefit of consuming them.

decision_rules: No substitution may cross a non-substitutable safety, rights, competence, regulatory, or integrity boundary without legitimate authority and evidence.

decision_rules: A configuration is not acceptable until all critical functions and interfaces pass an integrated sufficiency test under representative conditions.

decision_rules: Adapter count, manual handoffs, tacit dependencies, and maintenance burden must remain below a declared complexity and reliability budget.

decision_rules: If no feasible safe configuration exists, trigger external sourcing, escalation, evacuation, mission reduction, or safe cessation rather than extending the metaphor of resourcefulness.

decision_rules: Every provisional configuration receives an owner, operating limit, review date, and upgrade or demobilization decision.

target_invariants: Critical mission function remains explicitly defined and testable.

target_invariants: Safety, rights, legality, professional scope, consent, privacy, accessibility, and containment requirements remain non-negotiable.

target_invariants: Resources are not double-allocated, falsely assumed available, or consumed without accounting for opportunity and option value.

target_invariants: Every repurposed resource remains traceable to condition, provenance, permission, owner, and maintenance requirement.

target_invariants: Interfaces preserve units, timing, capacity, identity, data integrity, and failure isolation as applicable.

target_invariants: The configuration has an observable failure boundary and a feasible rollback, isolation, or safe-stop path.

target_invariants: Temporary status, evidence limits, and expiry conditions remain visible to downstream users.

target_invariants: The solution does not transfer unacceptable risk or uncompensated burden to less visible actors.

expected_outcomes: A critical or valuable function becomes available despite short-term absence of ideal inputs.

expected_outcomes: Existing resources achieve higher functional coverage through verified alternative uses and combinations.

expected_outcomes: Time to workable capability falls without concealing safety, compatibility, maintenance, or ownership debt.

expected_outcomes: Scarce keystone resources and future options are preserved more deliberately.

expected_outcomes: Substitutions and adaptations become reproducible, auditable, and transferable rather than remaining tacit local tricks.

expected_outcomes: Unviable local search is recognized earlier, enabling timely procurement, escalation, or mission reduction.

expected_outcomes: Successful patterns expand the future response repertoire while failed combinations become documented negative knowledge.

prose_tradeoffs:
- Speed of configuration versus depth of condition, compatibility, and safety verification.
- Use of present resources versus preservation of keystone assets and future option value.
- Local fit and ingenuity versus standardization, interoperability, certification, and future staffing.
- Reversible low-performance probes versus efficient but irreversible adaptations.
- Broader heterogeneous inventory versus larger search, interface, documentation, and maintenance burden.
- Minimum sufficiency versus reliability margin, scalability, and long-duration headroom.
- Local autonomy versus the authority, rights, labor, privacy, and professional controls needed for legitimate repurposing.
- Temporary technical or organizational debt versus the delay and cost of waiting for ideal resources.

Emergency Salvage Bricolage

short_definition: Restore a critical function under disruption by salvaging, cannibalizing, adapting, and combining the safe resources still available.

distinctive_feature: Time pressure and damage make inventory condition uncertain and increase the value of salvage, containment, triage, and expiry controls.

distinct_from_parent: The parent also applies to deliberate local innovation and constrained design; this variant assumes disruption, urgency, degraded assets, and higher safety risk.

still_same_parent_because: The causal move remains fixed-inventory affordance discovery, safe repurposing, interface bridging, and iterative recomposition.

source_primes: bricolage improvisation resilience

use_when: Ordinary supply, infrastructure, or specialist support is unavailable within the response window.

use_when: A critical function must be restored before an ideal replacement can arrive.

use_when: Resources may need to be sacrificed, moved, or used outside their ordinary role under explicit authority.

use_when: The configuration can be isolated, tested, monitored, and replaced or demobilized later.

domain: disaster response

example: Restore a temporary water-distribution path from inspected pumps, tanks, hoses, filters, and fittings while protecting potable-water invariants.

domain: field maintenance

example: Recover a critical machine function by cannibalizing a noncritical unit, fabricating an adapter, testing load limits, and scheduling replacement.

failure_modes: Urgency is used to bypass non-substitutable safety or competence limits.

failure_modes: Salvage consumes the only resource needed for a more critical later failure.

failure_modes: A temporary patch remains in service after its evidence and maintenance window expire.

Capability and Role Bricolage

short_definition: Recombine available people, skills, relationships, routines, authority, and facilities into a temporary operating capability when the ideal organization is unavailable.

distinctive_feature: Human capability is repurposed without treating people as interchangeable parts; consent, competence, workload, and authority are first-class constraints.

distinct_from_parent: The parent covers physical, informational, technical, and institutional resources generally; this variant centers role and capability recombination.

still_same_parent_because: It still maps affordances in a fixed inventory, assigns them to functions, bridges interfaces, tests the configuration, and plans handoff or normalization.

use_when: The binding inventory consists primarily of people, roles, relationships, routines, and institutional permissions.

use_when: Formal job or unit labels obscure transferable capabilities and cross-role affordances.

use_when: A new operating capability must be created without immediate hiring, restructuring, or procurement.

use_when: Competence, workload, labor rights, accountability, and authority limits can be protected.

domain: community services

example: Combine local venues, volunteers, transport capacity, communication channels, and existing trust networks to deliver a time-bounded support service.

domain: organizational continuity

example: Reassign cross-trained staff and shared tools to maintain a critical workflow while preserving competence and workload limits.

failure_modes: Role flexibility becomes coercive overwork or uncompensated responsibility transfer.

failure_modes: Informal authority is mistaken for legitimate decision rights.

failure_modes: Key tacit knowledge is concentrated in one improvised coordinator.

Digital Service Bricolage

short_definition: Compose an operational digital service from existing APIs, scripts, databases, spreadsheets, queues, and communication tools by adding explicit adapters, contracts, and controls.

distinctive_feature: The inventory is digitally heterogeneous and integration risk concentrates in schemas, credentials, rate limits, data lineage, idempotence, observability, and vendor dependency.

distinct_from_parent: The parent spans all resource types; this variant specializes interface and lifecycle controls for software and data services.

still_same_parent_because: The solution is still created by mapping available affordances to required functions and recomposing them under a fixed inventory rather than building an ideal stack from scratch.

source_primes: bricolage interoperability modularity

use_when: A useful service must be assembled before a purpose-built platform is feasible.

use_when: Existing tools expose enough interfaces or export paths to be recombined.

use_when: Data lineage, access control, failure behavior, and manual handoffs can be made explicit.

use_when: The organization can accept bounded temporary technical debt and has an upgrade or retirement path.

domain: service operations

example: Combine a form, spreadsheet, messaging tool, and scheduled script into a temporary case-routing service with access controls and reconciliation checks.

domain: data operations

example: Bridge legacy exports and a modern analytics tool with a documented schema adapter and expiry plan while the durable integration is built.

failure_modes: Manual glue and hidden credentials create an unobservable single point of failure.

failure_modes: Temporary integration becomes permanent without ownership, tests, or migration budget.

failure_modes: Schema, rate-limit, or retry mismatches corrupt or duplicate work.

near_names:
Bricolage
Resourceful Recomposition
Fixed-Inventory Solution Assembly
Constraint-Bounded Improvisation
Make-Do Design
Frugal Innovation