0. Scaling Scope Note

This entry is conceptual and systems-oriented.

It does not treat limited resources, phased repair, triage, staged restoration, constrained budgets, prioritization, slow recovery, or imperfect redress as inherently failed.

Restoration often requires sequencing.

Systems may need to prioritize when:

• harm differs in severity
• repair resources are scarce
• evidence must be gathered
• affected nodes need protection
• repair authority must be clarified
• repair must avoid creating secondary harm
• redress must be staged
• capacity must be built
• restoration requires time validation
• systemic repair must proceed in layers

The failure begins when the system scales obligations faster than it scales restoration.

A valid scaling system ensures:

• restoration capacity grows with reach
• redress pathways remain reachable
• repair authority matches repair obligation
• hidden debt is paid down
• affected-state burden remains visible
• repair queues remain auditable
• growth pauses when repair starves
• symbolic repair does not replace throughput
• restoration is treated as infrastructure, not aftercare

Restoration Starvation occurs when repair is structurally underfed.

The problem is not limited capacity.

The problem is continued scale while repair capacity remains below the burden created by scale.

1. Definition

Restoration Starvation occurs when harm, load, complexity, debt, exposure, growth, coupling, user impact, institutional reach, or system scale increases faster than the pathways, resources, authority, staffing, timing, legitimacy, and repair capacity needed to restore affected states and reduce hidden debt.

The starved restoration layer may include:

• user redress
• appeals
• support
• repair teams
• justice pathways
• harmed-node restoration
• moderation appeals
• safety review
• audit remediation
• incident response
• technical debt paydown
• maintenance
• infrastructure repair
• accessibility repair
• data correction
• consent correction
• compensation
• reintegration
• trust repair
• community repair
• ecological repair
• institutional accountability
• restoration casework
• affected-state validation
• model correction
• security remediation
• boundary repair
• local coherence repair

The starvation may occur through lack of:

• funding
• staffing
• authority
• time
• attention
• legitimacy
• tools
• data access
• decision rights
• escalation power
• affected-state standing
• documentation
• review bandwidth
• operational ownership
• institutional priority
• legal pathway
• repair infrastructure
• feedback linkage
• resource flow

The core failure is:

system scales
→ harm / debt / burden scales
→ restoration capacity does not scale
→ repair demand exceeds repair throughput
→ hidden debt accumulates
→ repair becomes symbolic, delayed, selective, or inaccessible
→ H↑

Restoration Starvation is not merely underfunding.

It is the scaling of impact without the scaling of repair.

2. Core Pattern

The core pattern is:

1. A system grows in reach, coupling, speed, complexity, authority, or impact.
2. Harm, errors, edge cases, disputes, hidden debt, and affected-state burden grow with it.
3. Restoration pathways remain small, manual, symbolic, under-authorized, or under-resourced.
4. Repair demand exceeds throughput.
5. Delays increase.
6. Affected nodes carry unresolved burden.
7. The system continues scaling because growth metrics remain positive.
8. Repair becomes triage, deflection, apology, symbolic closure, or selective resolution.
9. Hidden debt grows faster than it can be paid down.
10. Legitimacy and coherence degrade beneath apparent growth.

A healthy scaling system says:

we can scale only as far as repair capacity can follow

A restoration-starved system says:

we can scale now and repair later

The failure becomes severe when repair is treated as downstream support rather than a hard constraint on scale.

3. Failure Signature

Typical signature:

system reach↑
repair demand↑
restoration capacity lag↑
redress access↓
repair delay↑
affected-state burden↑
hidden debt↑
H↑

Extended signature:

users scale faster than support
deployments scale faster than safety review
audit findings scale faster than remediation
harm reports scale faster than redress
technical debt scales faster than maintenance
contracts scale faster than dispute repair
moderation actions scale faster than appeal capacity
growth scales faster than local coherence repair

Common verbal signatures include:

we will improve support later
we are scaling quickly
repair is on the roadmap
we need to prioritize growth
we cannot fix every edge case
appeals are expensive
support volume is high
we are working through the backlog
we need automation to handle this
the system is still improving overall

Common system signatures include:

an AI platform launches broadly before redress capacity exists
a product scales users faster than support and appeals can function
a justice reform creates intake but not repair staff
a platform moderates at scale but cannot process wrongful removals
a security program finds vulnerabilities faster than it can remediate
a company grows revenue while maintenance debt accumulates
an institution gathers testimony but cannot repair harmed conditions
an economy expands while local burden and ecological repair are unfunded

The defining condition is not that repair is incomplete.

The defining condition is that repair capacity is structurally outscaled.

4. Primary U-Layer Origin

Common origin layers:

• U1 — Power / Budgets: growth, profit, deployment, authority, or legitimacy receives resources while repair is underfunded.
• U2 — Configuration / Boundaries: repair ownership, authority, and escalation paths are poorly configured.
• U3 — Execution / Runtime: runtime impact generates more repair need than operations can process.
• U4 — Information / Truth: repair availability is claimed through policy, not throughput.
• U5 — Coordination / Time: growth velocity outruns repair timing.
• U6 — Coherence Field: progress narrative masks repair starvation.
• U7 — Memory / Recurrence: backlog and unresolved cases become normalized.
• U8 — Environment / Field: market, institutional, political, legal, or platform pressure rewards growth over repair.

Common manifestation layers:

• U1 — Resources: repair does not receive enough resources.
• U3 — Execution: repair processes saturate.
• U4 — Truth: formal redress substitutes for actual redress.
• U5 — Time: delay turns repair demand into hidden debt.
• U6 — Field: growth aura masks unresolved burden.
• U7 — Memory: unresolved cases disappear into backlog.

Restoration Starvation is primarily an R restoration-capacity / Φ resource-flow failure.

The system names repair but does not feed it.

5. Typical Development Sequence

A common development sequence is:

1. System begins scaling.
2. Impact expands.
3. Harm, error, edge cases, and repair demand increase.
4. Restoration pathways remain fixed or symbolic.
5. Repair queues grow.
6. Affected nodes wait, disengage, or escalate.
7. Repair workers become overloaded.
8. The system narrows eligibility or automates deflection.
9. Repair quality declines.
10. Hidden debt grows.
11. Public or internal trust erodes.
12. A larger legitimacy or coherence crisis emerges.

The loop often looks like:

scale → repair demand → capacity lag → hidden debt → further repair burden

Another common loop is:

growth rewarded → repair deferred → harm accumulates → repair becomes harder → growth continues

Restoration Starvation becomes durable when repair demand is treated as operational noise instead of a hard scaling signal.

6. Diagnostic Markers

Diagnostic markers include:

• Repair queues grow as system reach grows.
• Support or redress becomes slower over time.
• Repair staff lack authority to fix root conditions.
• Appeals exist but rarely reverse harm.
• Repair work is manual while harm generation is automated.
• Affected nodes abandon repair pathways.
• Maintenance debt grows under expansion.
• Audit findings lack remediation resources.
• User harm reports are aggregated but not repaired.
• Growth decisions do not include restoration capacity checks.
• Repair teams are praised but under-resourced.
• Backlog becomes normal.
• Resolution metrics count closure, not repaired state.
• Symbolic acknowledgments replace actual restoration.
• The system cannot state repair demand relative to repair throughput.

Useful diagnostics:

• Restoration Capacity: Measures actual capacity to repair affected states.
• Repair Throughput: Measures completed restoration per unit time.
• Repair Capacity Lag: Compares repair capacity growth to system impact growth.
• Restoration Demand: Measures total current and latent repair need.
• Redress Queue Load: Tracks backlog, age, severity, and access friction.
• Hidden Debt Load: Measures unresolved burden produced by scaling.
• Resource Flow to Repair: Tests whether resources move toward restoration.
• Affected-State Burden: Measures unrepaired conditions carried by affected nodes.
• Repair Authority Sufficiency: Tests whether repair teams can fix causes.
• Local Coherence: Tests whether actual affected conditions improve.

7. Related Gates

Relevant gates include:

• Restoration Capacity Gate: Fails when repair capacity does not match impact.
• Repair Throughput Gate: Fails when repair output cannot clear demand.
• Resource Flow Gate: Fails when repair is not resourced.
• Affected-State Gate: Fails when affected burden cannot trigger repair.
• Redress Access Gate: Fails when repair pathways are unreachable.
• Hidden Debt Paydown Gate: Fails when unresolved burden is not reduced.
• Repair Authority Gate: Fails when repair teams lack authority.
• Growth / Repair Coupling Gate: Fails when growth proceeds without repair capacity.
• Queue Visibility Gate: Fails when backlog is hidden or softened.
• Local Coherence Gate: Fails when formal repair does not restore actual conditions.

The first common gate failure is usually the Growth / Repair Coupling Gate.

Once growth is allowed to decouple from repair, starvation becomes structural.

8. Related Operators

Relevant operators include:

• R — Restoration Capacity: Primary operator; repair capacity must scale.
• H — Hidden Debt: Accumulates when repair cannot keep up.
• Φ — Flow / Resource Movement: Resources must reach repair pathways.
• K — Constraint / Load: Rises in affected nodes, repair queues, and staff.
• Au — Auditability: Makes repair demand and backlog visible.
• O — Coherence: Apparent coherence may persist while repair is starved.
• Τ — Trajectory / Time: Tracks repair delay, backlog aging, and debt compounding.
• Γ — Selection: Selects which cases are repaired and which are deferred.
• BΣ — Boundary Integrity: Protects affected-state standing and repair obligations.
• D — Damping: Slows growth when repair capacity lags.
• Ψ — Observation / Interface: Displays repair availability but may hide throughput.
• G — Gain: Rewards growth, speed, profit, or scale over repair.
• M — Meaning: Repair language may be used to sustain legitimacy.

Common operator pattern:

G rewards scale
impact expands
R does not scale
Φ resources bypass repair
K rises in affected nodes and queues
Ψ displays repair pathway
Au hides throughput gap
H accumulates

The core operator inversion is:

repair pathway exists → repair capacity exists

instead of:

repair pathway exists + resourced throughput + authority + affected-state validation + hidden-debt paydown → repair capacity exists

Restoration Starvation turns repair into a promise without calories.

9. Related Laws and Invariants

Related Laws

• Restoration Capacity Must Scale With Harm: more harm requires more repair capacity.
• Repair Must Scale Faster Than Hidden Debt: otherwise debt compounds.
• Growth Requires Restoration Throughput: growth without repair throughput is incoherent.
• Redress Must Scale With Reach: larger systems need larger redress pathways.
• Repair Starvation Creates Hidden Debt: underfed repair stores burden.
• Affected-State Burden Requires Resource Flow: harm must pull resources.
• Restoration Is a Scaling Constraint: repair capacity limits valid scale.
• No System May Scale Repair Obligations Without Repair Capacity: obligation and capacity must couple.
• Hidden Debt Accumulation: unrepaired burden compounds.
• Expansion Without Capacity: scale without capacity creates collapse.
• Capacity Collapse: overloaded systems lose control ability.
• Pseudo-Restoration: symbolic repair can hide starvation.

Related Invariants

• Restoration Must Remain Resourced: repair requires material support.
• Repair Capacity Must Track System Reach: reach and repair must scale together.
• Affected-State Repair Must Remain Available: affected nodes must be able to access repair.
• Hidden Debt Requires Active Paydown: debt cannot be left to accumulate.
• Redress Pathways Must Be Operational: named pathways must work.
• Repair Authority Must Match Repair Obligation: repair teams need power to correct.
• Restoration Queues Must Remain Auditable: backlog and delay must be visible.
• Growth Must Stop When Repair Starves: expansion must be constrained by repair capacity.

10. Common False Positives

Not every limited repair system is Restoration Starvation.

Common false positives include:

• Temporary backlog with funded recovery plan.
• Phased repair with transparent capacity building.
• Triage that preserves affected-state standing.
• Slow repair where growth is paused or constrained.
• Redress pathway that scales with demand over time.
• Limited repair capacity honestly disclosed and compensated.
• System launch with bounded reach until repair pathways are ready.
• Automated support paired with real escalation.
• Manual review under limited scope with sufficient staff.
• Maintenance backlog with active paydown budget.
• Justice process with under-capacity declared and resourced.
• Repair queue that is visible, shrinking, and authority-backed.

Clarifying rule:

This is not Restoration Starvation unless harm, load, complexity, debt, exposure, growth, coupling, user impact, institutional reach, or system scale increases faster than the system’s ability to restore affected states and reduce hidden debt.

Repair can be slow.

It fails when the system continues scaling beyond what repair can carry.

11. Common False Repairs

Common false repairs include:

• creating intake without repair throughput
• adding support chatbots without escalation power
• publishing redress policies without staffing
• adding apology language
• narrowing eligibility to reduce visible backlog
• closing cases for procedural reasons
• using dashboards that show resolved tickets, not repaired conditions
• hiring communications staff instead of repair staff
• adding committees without remediation authority
• requiring affected nodes to document harm repeatedly
• pushing repair onto users, workers, or communities
• promising future repair after current expansion
• automating denial
• treating low complaint rates as repair success
• calling under-resourced triage restoration

False repair often produces the loop:

repair starvation exposed
→ repair interface added
→ repair throughput unchanged
→ starvation deepens

Another common loop is:

backlog grows
→ eligibility narrows
→ visible backlog shrinks
→ hidden debt grows outside the queue

The repair fails because it reduces the visibility of repair demand without increasing restoration capacity.

12. Restoration Direction

Restoration requires measuring total repair demand, scaling repair capacity, reallocating resources, restoring repair authority, paying down hidden debt, coupling growth to restoration throughput, and validating affected-state repair.

Primary restoration direction:

measure repair demand,
scale repair capacity,
fund restoration,
and couple growth to repair throughput

A fuller restoration path includes:

1. Name the restoration domain. Identify what repair, redress, support, remediation, or affected-state restoration is starved.
2. Measure total repair demand. Include formal cases, informal reports, abandoned requests, and latent harm.
3. Measure repair throughput. Identify how much actual repair is completed.
4. Measure capacity lag. Compare system growth to restoration capacity growth.
5. Map hidden debt. Identify unrepaired burden accumulating outside formal queues.
6. Audit resource flow. Determine whether budget, staffing, tooling, and authority reach repair.
7. Audit repair authority. Test whether repair actors can change root conditions.
8. Expose queues. Make backlog, severity, delay, and abandonment visible.
9. Prioritize affected-state burden. Repair by real burden, not optics or convenience.
10. Scale restoration capacity. Add staff, funding, automation with escalation, tools, authority, and process simplification.
11. Pause or slow growth where needed. Prevent further scale when repair lags.
12. Pay down hidden debt. Address unresolved harm and old backlog.
13. Repair abandoned cases. Reopen pathways for nodes that left due to starvation.
14. Install growth / repair gates. Require repair capacity checks before expansion.
15. Validate local coherence. Confirm repair reduces actual affected-state burden.

A valid restoration path should reduce:

repair capacity lag
redress delay
hidden debt
affected-state burden
symbolic repair
support starvation
growth-repair decoupling
H

Restoration Starvation is not repaired by promising to care.

It is repaired by feeding the system that restores.

13. Cross-Module Links

• Scaling: Primary family; scaling creates more repair demand and hidden debt unless restoration scales with it.
• Core: Strong link to Hidden Debt Accumulation, Pseudo-Coherence, and Auditability Collapse.
• Cybernetics: Repair capacity is a control function; without it, correction becomes impossible.
• Obfuscated Meta Dynamics: Hidden debt accretion and restoration bottleneck collapse often follow restoration starvation.
• Restoration: Direct link to false repair, repair burden externalization, and pseudo-restoration.
• Justice: Under-resourced justice is a domain expression of restoration starvation.
• AI Governance: Appeals, redress, moderation correction, model repair, data correction, and safety review must scale with deployment.
• Economy: Expansion without capacity and forced profit often starve repair.
• Organizations: Support, safety, compliance, HR, and maintenance teams often reveal restoration starvation.
• Coherence: Coherence requires restoration capacity to scale with harm, reach, complexity, and debt.

14. Relationship to Parent / Child Modes

Production treatment: Standalone Entry / Canon-Aligned

This mode maps upward to:

• FM-CORE-002 — Hidden Debt Accumulation
• FM-S-010 — Hidden Debt Explosion
• FM-C-013 — Capacity Collapse / Control Impossibility
• FM-OMD-009 — Restoration Bottleneck Collapse
• FM-JC-004 — Under-Resourced Justice

Sibling or related Scaling modes include:

• FM-S-010 — Hidden Debt Explosion
• FM-S-015 — Bandwidth Saturation
• FM-S-016 — Ring-Down Failure
• FM-S-017 — Terminal Scaling Failure
• FM-S-002 — Overcoupling Meltdown
• FM-S-009 — Meta Migration Shock
• FM-S-014 — Fractal Failure Replication

Related cross-family modes include:

• FM-CORE-002 — Hidden Debt Accumulation
• FM-CORE-001 — Pseudo-Coherence
• FM-C-011 — Zero-Slack Collapse
• FM-C-013 — Capacity Collapse / Control Impossibility
• FM-OMD-001 — Hidden Debt Accretion Loop
• FM-OMD-009 — Restoration Bottleneck Collapse
• FM-R-004 — Repair Burden Externalization
• FM-R-007 — Repair Suppression via Efficiency
• FM-JC-004 — Under-Resourced Justice
• FM-ECO-010 — Expansion Without Capacity
• FM-AIX-001 — Responsibility Diffusion
• FM-AIX-018 — Civilizational Deskilling

Aliases preserved from source material:

• Restoration Starvation
• Repair Starvation
• Restoration Capacity Starvation
• Under-Resourced Restoration
• Repair Underfunding
• Redress Starvation
• Restoration Resource Failure
• Repair Capacity Lag
• Restoration Throughput Deficit
• Scaling Without Repair

15. Minimal Entry Version

Definition: Restoration Starvation occurs when harm, load, complexity, debt, exposure, growth, coupling, user impact, institutional reach, or system scale increases faster than the pathways, resources, authority, staffing, timing, legitimacy, and repair capacity needed to restore affected states and reduce hidden debt.

Signature:

system reach↑
repair demand↑
restoration capacity lag↑
redress access↓
repair delay↑
affected-state burden↑
hidden debt↑
H↑

Restoration direction:

• name the restoration domain
• measure total repair demand
• measure repair throughput
• measure capacity lag
• map hidden debt
• audit resource flow
• audit repair authority
• expose queues
• prioritize affected-state burden
• scale restoration capacity
• pause or slow growth where needed
• pay down hidden debt
• repair abandoned cases
• install growth / repair gates
• validate local coherence

16. Machine-Readable Summary

failure_mode:
  id: "FM-S-006"
  name: "Restoration Starvation"
  family: "Scaling"
  production_treatment: "Standalone Entry / Canon-Aligned"
  parent_modes:
    - "FM-CORE-002 — Hidden Debt Accumulation"
    - "FM-S-010 — Hidden Debt Explosion"
    - "FM-C-013 — Capacity Collapse / Control Impossibility"
    - "FM-OMD-009 — Restoration Bottleneck Collapse"
    - "FM-JC-004 — Under-Resourced Justice"
  primary_failure: "Harm, load, complexity, debt, exposure, growth, coupling, user impact, institutional reach, or system scale increases faster than pathways, resources, authority, staffing, timing, legitimacy, and repair capacity needed to restore affected states and reduce hidden debt."
  source: "UTS — Failure Modes Registry"
  source_id: "FM-S-006"
  scope_note: "Conceptual and systems-oriented; does not treat limited resources, phased repair, triage, staged restoration, constrained budgets, prioritization, slow recovery, or imperfect redress as inherently failed."
  aliases:
    - "Restoration Starvation"
    - "Repair Starvation"
    - "Restoration Capacity Starvation"
    - "Under-Resourced Restoration"
    - "Repair Underfunding"
    - "Redress Starvation"
    - "Restoration Resource Failure"
    - "Repair Capacity Lag"
    - "Restoration Throughput Deficit"
    - "Scaling Without Repair"
  signature:
    - "system reach↑"
    - "repair demand↑"
    - "restoration capacity lag↑"
    - "redress access↓"
    - "repair delay↑"
    - "affected-state burden↑"
    - "hidden debt↑"
    - "H↑"
  primary_layers:
    origin:
      - "U1 — Power / Budgets"
      - "U2 — Configuration / Boundaries"
      - "U3 — Execution / Runtime"
      - "U4 — Information / Truth"
      - "U5 — Coordination / Time"
      - "U6 — Coherence Field"
      - "U7 — Memory / Recurrence"
      - "U8 — Environment / Field"
    manifestation:
      - "U1 — Resources"
      - "U3 — Execution"
      - "U4 — Truth"
      - "U5 — Time"
      - "U6 — Field"
      - "U7 — Memory"
  state_variables:
    - "R"
    - "H"
    - "Φ"
    - "K"
    - "Au"
    - "O"
    - "Τ"
    - "Γ"
    - "BΣ"
    - "D"
    - "Ψ"
    - "G"
    - "M"
  first_gate_failure: "Growth / Repair Coupling Gate"
  restoration:
    - "Restoration Capacity Audit"
    - "Repair Demand Mapping"
    - "Repair Throughput Scaling"
    - "Resource Flow Reallocation"
    - "Hidden Debt Paydown"
    - "Redress Pathway Expansion"
    - "Affected-State Prioritization"
    - "Repair Authority Restoration"
    - "Growth / Repair Coupling Repair"
    - "Local Coherence Revalidation"