1) Diagnostic Identity

Diagnostic Name: Affected Node Cost

Short Name / Symbol: affected_node_cost

Diagnostic Class: Impact / Burden / Restoration / Legitimacy / MS-Gate Support

Primary Function: Estimate the total cost carried by the node, person, group, subsystem, institution, field, or layer most affected by a decision, failure, harm, constraint, dependency, classification, repair, or policy.

Primary Use: Determine whether the system is accurately seeing where cost lands, who absorbs it, whether the cost is acknowledged, and whether repair reaches the affected node rather than only the authority, origin, metric, or narrative layer.

Core Risk if Ignored: The system may claim success, repair, fairness, compatibility, or legitimacy while the real cost is being carried by the affected node invisibly.

Core Risk if Overtrusted: Affected-node cost may be treated as the only relevant system variable, causing the system to ignore cause localization, broader coupling effects, feasibility, proportionality, repair sequencing, or multi-node tradeoffs.

2) Mechanical Definition

affected_node_cost measures the cost borne by the node most exposed to the consequences of a system action, failure, coupling, classification, constraint, or repair gap.

affected_node_cost answers:

Who actually pays the cost, and how much do they pay?

An affected node may be:

person
team
community
subsystem
service
interface
role
environment
field
memory layer
boundary holder
dependent node
low-visibility node
future node

Cost may be:

material
financial
time
energy
attention
repair burden
proof burden
trust loss
boundary strain
identity distortion
memory contamination
opportunity loss
health of function
operational disruption
loss of access
loss of voice
loss of fallback
exposure to recurrence

Affected Node Cost is not automatically the same as visible damage.

Often the most affected node is not the loudest, highest-rank, easiest to measure, or formally responsible node.

A simple distinction:

visible system cost ≠ affected-node cost

A second distinction:

repair at authority layer ≠ repair at affected-node layer

This diagnostic keeps the system from mistaking central recovery for actual restoration.

3) What the Diagnostic Measures

Direct Measurement Target

affected_node_cost measures:

• cost carried by impacted nodes
• burden of harm
• burden of delay
• burden of repair failure
• proof burden
• appeal burden
• memory correction burden
• boundary strain cost
• resource depletion
• lost access
• lost opportunity
• recurrence exposure
• trust degradation
• cost of misclassification
• cost of dependency
• cost of exit difficulty
• cost of false repair
• cost of being unseen in system metrics

Indirect / Proxy Signals

affected_node_cost can be estimated from:

• repeated affected-node reporting
• exhaustion or disengagement
• delayed recovery
• cost borne after central repair claims
• proof burden concentration
• increased exit attempts
• repeated boundary clarification
• reduced participation
• hidden labor reports
• loss of trust in process
• appeals or complaints from affected nodes
• local workarounds
• service degradation at exposed nodes
• repair burden shifting to affected nodes
• official metrics improving while affected nodes remain worse off
• recurrence landing on the same nodes
• dependency failures affecting one node more than another
• affected-node memory diverging from official memory

What It Does Not Measure

affected_node_cost does not directly measure:

• full causality
• intent
• blame
• total system cost
• whether the affected node is correct about every interpretation
• whether repair is feasible immediately
• whether the affected node should control the whole process
• whether other nodes have no cost
• whether cost alone determines policy
• whether every cost implies wrongdoing
• whether all costs can be eliminated

High affected_node_cost means a node is carrying significant consequence.

It does not automatically identify the responsible cause-bearing node.

Low affected_node_cost means exposed cost is low or well-repaired.

It does not guarantee the system is coherent if costs are hidden, delayed, or displaced elsewhere.

4) Canonical State Variables Involved

Canonical state vector:

S = {O, H, ε, ι, Au, µᵢ, BΣ, K, R, Φ}

Primary Variables

• H: affected-node cost often becomes hidden debt if unacknowledged or unrepaired
• R: restoration must reach the affected node, not only the central system
• BΣ: boundary integrity is often where affected-node cost first accumulates
• O: coherence requires that the actual cost field be seen and repaired
• Au: cost must be traceable enough to avoid erasure or misclassification
• µᵢ: agent/system integrity depends on recognizing consequence where it lands

Secondary Variables

• ε: visible error may underrepresent affected-node burden
• ι: pseudo-coherence rises when central metrics recover while affected nodes remain harmed
• K: compatibility depends on whether coupling reduces or exports affected-node cost
• Φ: proxy performance often hides affected-node cost if the node is low-visibility

Variables Commonly Confused With affected_node_cost

5) Localization Signature

Primary Legibility Layers

• U1 — Power / Budgets: material, time, labor, financial, compute, staffing, energy, and resource cost borne by affected nodes
• U2 — Configuration / Boundaries: permission, access, role, constraint, consent, and exit costs
• U3 — Execution: operational disruption, task burden, failure burden, practical workload
• U4 — Classification / Metrics / Narratives: how affected-node cost is named, minimized, misclassified, or erased
• U5 — Coordination / Time: delay cost, waiting burden, recurrence exposure, timing asymmetry
• U6 — Coherence Field: trust, legitimacy, shared reality, and compatibility effects
• U7 — Memory / Recurrence: whether affected-node cost enters memory or becomes hidden recurrence

Primary Leverage Layers

• U1: resource affected nodes directly
• U2: repair boundaries, access, permissions, and exit conditions
• U3: reduce practical burden and operational disruption
• U4: name affected-node cost accurately
• U5: reduce delay, proof burden, and recurrence exposure
• U7: preserve affected-node memory and repair history

Verification Layers

• U1: what resources did the affected node lose or need?
• U2: what boundaries, access, or permissions were affected?
• U3: what practical burden did the node carry?
• U4: was the cost named accurately?
• U5: how long did the node carry the cost?
• U6: did trust or coherence recover?
• U7: did memory preserve the cost and repair?

Common Mislocalizations

• Treating central recovery as affected-node recovery
• Treating aggregate success as local restoration
• Treating lack of complaint as low cost
• Treating proof burden as neutral
• Treating delayed repair as minor if central metrics recover
• Treating affected-node cost as anecdotal
• Treating low-rank cost as operational noise
• Treating repair process burden as not part of harm
• Treating exit as resolution
• Treating affected-node exhaustion as resistance
• Treating cost visibility as cost creation
• Treating affected-node signal as attribution by default

6) Input Requirements

Required Inputs

To estimate affected_node_cost, the system needs:

• affected node or node class
• event, action, failure, constraint, classification, or coupling being evaluated
• type of cost
• magnitude of cost
• duration of cost
• affected variables in S
• visibility of cost
• whether cost is acknowledged
• whether repair reaches the affected node
• proof burden
• appeal burden
• repair burden
• resource asymmetry
• dependency_load
• exit_cost
• recurrence exposure
• affected-node feedback

Optional Inputs

These improve precision:

• cost timeline
• resource loss records
• workload impact
• trust indicators
• affected-node testimony
• complaint/appeal records
• service disruption data
• boundary-strain records
• repair validation records
• recurrence records
• hidden labor reports
• public/private narrative comparison
• official memory review
• external audit
• burden distribution records
• downstream effects
• comparable node analysis
• long-term opportunity cost
• post-repair recovery data

Missing Input Behavior

If affected_node_cost inputs are missing:

• If affected node is unclear, map downstream burden before claiming repair
• If cost type is unknown, avoid treating the harm as resolved
• If duration is unknown, cost may be underestimated
• If proof burden is unknown, repair process cost may be hidden
• If affected-node feedback is missing, central metrics are insufficient
• If repair validation is missing, do not claim restoration
• If recurrence exposure is unknown, future cost may be hidden
• If exit cost is high, silence is weak evidence of low cost
• If resource asymmetry is high, equal burden may be practically unequal

Default missing-input posture:

identify affected node → map cost types and duration → include repair/proof burden → validate recovery with affected-node signal

7) Diagnostic States / Ranges

These ranges are qualitative and should be domain-calibrated.

Healthy / Coherence-Supporting Range

Affected-node cost is visible, proportionate, acknowledged, and repaired at the node that carried it.

Signals:

• affected node is identified
• cost is named accurately
• proof burden is reasonable
• repair reaches affected node
• recovery is validated
• recurrence exposure declines
• memory preserves cost and repair
• burden is not minimized by aggregate metrics
• affected node is not forced to carry repair alone
• BΣ and trust recover over time

Recommended posture:

continue repair
validate affected-node recovery
update U7 memory
monitor recurrence and cost redistribution

Watch Range

Affected-node cost is partially recognized but may be underestimated, delayed, or not fully repaired.

Signals:

• cost is visible but not fully measured
• affected-node feedback is partial
• central system claims repair before local recovery
• proof burden is rising
• repair process creates additional burden
• recurrence risk remains
• affected node is cooperating but cautious
• memory records cost incompletely
• official narrative softens the burden

Recommended posture:

increase affected-node validation
reduce proof and repair burden
resource local recovery
delay repair-complete claims

Degraded Range

Affected-node cost is significant, under-acknowledged, or displaced onto the node most exposed to harm.

Signals:

• affected node carries proof burden
• repair burden falls on harmed node
• central metrics recover while affected node does not
• cost is minimized as inconvenience
• affected node disengages or loses trust
• recurrence lands on same node
• official memory omits cost
• appeal path adds cost
• cost persists after repair claim
• boundary strain remains unrepaired

Recommended posture:

pause closure
activate MS review
map affected-node burden
resource repair at affected layer
correct narrative and memory
validate recovery before recoupling

Contraindicated:

repair-complete claims
demanding trust
punitive response to repeated signal
scaling from central metrics
deep coupling before affected-node recovery

Critical / Collapse-Prone Range

Affected-node cost is severe, chronic, denied, or structurally exported.

Signals:

• affected node exits, collapses, or is forced into rupture
• cost exceeds recovery capacity
• harm and repair burden both fall on affected node
• official memory denies or erases the burden
• legitimacy shock risk is high
• external support is needed
• recurrence continues despite claims of repair
• cost is normalized as role expectation
• affected-node voice is suppressed
• restoration cannot proceed without major burden redistribution

Recommended posture:

stop cost-exporting action
protect affected-node signal
restore resources and boundaries
redistribute repair burden
correct official memory
repair origin layer
validate recovery over time

False Positive Risk

affected_node_cost may appear high when:

• temporary cost is known, chosen, compensated, and repair-linked
• affected node is in a legitimate role that carries scoped cost
• transition cost is real but proportionate
• cost increases because hidden harm is now visible
• repair process temporarily surfaces burden
• affected node participates voluntarily with adequate support
• local cost prevents larger system damage
• short-term burden creates long-term restoration

False Negative Risk

affected_node_cost may appear low when:

• affected nodes stop reporting
• exit cost suppresses complaint
• cost is normalized
• cost is delayed
• cost is symbolic, memory-based, or trust-based
• central metrics recover
• proof burden is uncounted
• repair labor is uncounted
• affected nodes lack language or access to report cost
• high-rank narratives minimize low-visibility burden

8) Leading Indicators

affected_node_cost degradation appears early as:

• affected nodes repeat the same signal
• proof burden increases
• affected nodes become quieter
• repair process feels costly
• trust declines despite central repair
• cost is described as “minor” from outside
• local workarounds appear
• affected nodes stop using formal channels
• recurrence hits the same node
• appeal becomes exhausting
• repair meetings increase but local recovery does not
• boundary strain remains
• affected-node memory differs from official memory
• central metrics improve while local experience worsens
• patience windows shorten

9) Lagging Indicators

affected_node_cost failure has already accumulated debt when:

• affected nodes exit or disengage
• legitimacy shock occurs
• external audit validates affected-node record
• official memory must be corrected
• repair claims are rejected
• affected-node cost becomes public rupture
• recurrence becomes tied to specific burdened nodes
• trust in process collapses
• hidden labor is exposed
• repair requires major resource transfer
• boundary damage persists
• affected nodes cannot recover without outside support
• system must admit central success was local failure

10) Interpretation Rules

How to Read affected_node_cost

affected_node_cost should be read as:

context-specific consequence burden carried by the node most exposed to the system’s action or failure

It is not causality, blame, or full system evaluation by itself.

A system may have:

• high affected-node cost and low central cost
• low visible cost and high memory/trust cost
• high temporary cost and high legitimate repair value
• high cost from exposure of old hidden debt
• high cost but unclear cause
• low current cost but high recurrence exposure
• high affected-node cost with insufficient repair burden assigned to the cause-bearing layer

What Changes Its Meaning

affected_node_cost changes meaning under:

• high resource_asymmetry
• high repair_burden_distribution asymmetry
• high dependency_load
• high exit_cost
• high AckDebt
• low EB
• weak FI_integrity
• low Au_eff
• low R_eff
• high pseudo_damping_risk
• high narrative_metric_gap
• low MS_symmetry_index
• high immunity_index
• high recovery_asymmetry
• high recurrence

Context Modifiers

High resource_asymmetry: same cost may be more damaging to lower-resource nodes.

Repair burden asymmetry: affected nodes may carry both harm and repair.

High dependency_load: affected nodes may be unable to refuse or reduce exposure.

High exit_cost: continued participation is weak evidence of low cost.

High AckDebt: unrecognized cost remains active.

Low EB: cost may not be expressible.

Weak FI: cost signal may not change the system.

Low R_eff: affected-node recovery may be impossible without new support.

High immunity: cost may be exported away from cause-bearing nodes.

Domain Calibration Notes

affected_node_cost should be calibrated by domain:

• in engineering: user impact, downstream team load, on-call burden, support burden, technical debt exposure
• in AI: user correction burden, misclassification cost, memory error cost, tool failure cost, safety overblock cost
• in institutions: complaint burden, service delay, proof burden, procedural harm, repair access cost
• in governance: affected public cost, appeal burden, remedy delay, enforcement burden, policy failure cost
• in relationships: boundary strain, trust loss, repair burden, time/energy cost, recurrence exposure
• in archives: reader confusion, source erasure, glossary drift burden, downstream module correction cost

11) Operator Sequencing Implications

If affected_node_cost Is Low / Repaired

Allowed with ordinary gate checks:

• ℛ can proceed toward closure
• Γ can select next phase
• Π can relax temporary containment
• U7 can store repair memory
• Λ / ⊗ can consider re-coupling if other diagnostics pass
• public or archive claims can include repair evidence

Recommended:

verify affected-node recovery → update U7 memory → monitor recurrence → proceed cautiously

If affected_node_cost Is High

Recommended:

pause closure → map affected-node burden → resource local repair → reduce proof/repair burden → validate recovery

Or:

attenuate exposure → repair origin layer → correct official memory → restore affected-node trust

Avoid or delay:

• repair-complete claims
• demanding trust
• punitive response to repeated signal
• scaling from central metrics
• deep re-coupling
• irreversible constraints
• public legitimacy claims
• treating silence as recovery

Operators Recommended Under High affected_node_cost

• Ψ: attend to affected-node reality
• Au: trace actual burden and cost duration
• ℛ: repair at affected and origin layers
• MS-Gate: check burden symmetry
• Π: protect affected node from continued exposure
• Γ: select repair priority based on cost severity
• Θ: damp defensive minimization
• Ξ: detect pseudo-repair and cost erasure

Operators Contraindicated Under High affected_node_cost

• Γ closure selection: may close before recovery
• Π equal formal rule: may worsen practical burden
• ⊗ deep coupling: may increase exposure
• ⊕ composition: embeds unrepaired cost into shared identity
• Τ acceleration: outruns restoration
• Σ escalation: may moralize cost-bearing
• ✕ force: adds cost and often suppresses signal

12) Gate Implications

Gates Strengthened By Reliable affected_node_cost

• MS-Gate: checks burden and repair symmetry
• FI-Gate: ensures affected-node signal can correct the system
• Au-Actuation: cost is traceable before action
• High Risk Gate: prevents high-risk binding while affected-node cost is unresolved
• ☷ᵢ: ensures principles account for real consequence, not abstract claim

Gates Weakened If affected_node_cost Is Poorly Known

If affected-node cost is unknown:

• MS may miss hidden burden
• FI may falsely pass due to missing signal
• Au may trace central recovery but not local cost
• High Risk Gate may bind closure prematurely
• ☷ᵢ may apply principle language without consequence awareness
• Π may constrain affected nodes further
• Γ may select from central metrics
• ℛ may fail to reach the exposed layer

Gate Outcomes Affected

High affected_node_cost should push gates toward:

• Pause closure
• Require affected-node validation
• Require burden map
• Require resource repair
• Require proof-burden review
• Require memory correction
• Deny repair-complete claims
• Deny re-coupling under unrepaired cost
• ∅ for high-impact action that increases affected-node cost without repair capacity

13) Scaling Behavior

affected_node_cost becomes harder to detect under scale because costs concentrate locally while metrics aggregate globally.

As systems scale:

• affected-node cost becomes statistically diluted
• central metrics recover before local nodes do
• low-visibility nodes carry hidden cost
• proof burden increases
• repair pathways become procedural
• affected-node memory diverges from official memory
• recurrence concentrates in exposed nodes
• resource asymmetry magnifies cost
• appeals become expensive
• low-rank or edge nodes absorb burden
• official narratives generalize away local harm
• legitimacy shock risk rises if affected-node cost is exposed

Scaling Risks

• hidden burden concentration
• affected-node invisibility
• repair theater
• proof-burden overload
• local harm under aggregate success
• appeal exhaustion
• trust depletion
• official-memory rejection
• legitimacy shock
• extraction regime
• boundary erosion
• recurrence concentration
• cost export
• pseudo-coherence through burden displacement

Scaling Requirements

To scale affected-node cost safely, systems need:

• affected-node identification
• local cost measurement
• proof-burden tracking
• repair burden tracking
• affected-node validation
• local recovery indicators
• recurrence by node class
• resource asymmetry review
• appeal burden review
• memory correction pathways
• hidden labor detection
• public/private narrative comparison
• MS-Gate review
• external audit triggers
• cost-to-repair linkage
• central metric/local cost comparison

Scaling Rule

System success may scale only if affected-node cost is visible, acknowledged, repaired, and not merely averaged away.

Sanity constraint:

central Φ↑ + affected_node_cost↑ ⇒ pseudo-coherence risk ↑

If central metrics improve while affected-node burden rises, pseudo-coherence risk increases.

Second constraint:

affected_node_cost↑ + repair_burden_on_affected_node↑ ⇒ extraction risk ↑

If affected nodes carry both harm and repair, extraction risk rises.

Third constraint:

affected_node_cost↑ + AckDebt↑ ⇒ legitimacy shock risk ↑

If affected cost remains unacknowledged, exposure becomes destabilizing.

14) Interaction / Coupling Behavior

affected_node_cost reveals whether a coupling is exporting burden to the node least able or least authorized to repair it.

What It Reveals About Coupling

• who carries the cost of interaction
• whether compatibility is one-sided
• whether dependency hides cost
• whether repair reaches the exposed node
• whether truth about cost can be named
• whether one node’s success depends on another’s burden
• whether exit or refusal is available
• whether affected-node memory matches official memory

What It Reveals About Boundary Integrity

Affected-node cost often appears first as boundary strain.

When affected_node_cost is high:

• BΣ may be degraded
• refusal may become more costly
• consent may become ambiguous
• repair may require boundary restoration
• affected node may stop expressing strain
• official narrative may misread silence as recovery
• exit may become the only remaining boundary act

What It Reveals About Compatibility

Compatibility requires that cost does not concentrate invisibly.

A coupling may be unsafe if:

one node’s coherence depends on another node carrying unrepaired cost

or:

the affected node must pay the cost of proving, repairing, and surviving the system’s failure

Healthy compatibility includes cost visibility, repair access, and burden redistribution.

Relevant Interface Acts

• ↺ Reflection: identify who is carrying cost
• ⇩ Relaxation: lower pressure on affected node
• ⊘ Attenuation: reduce exposure while repair occurs
• ⊙ Alignment: own the cost one’s actions create
• →? Invitation: invite affected-node validation without proof-burden overload
• ⚕︎ Restorative Override: requires post-action affected-node repair
• ✕ Force: usually increases affected-node cost and suppresses signal

15) Failure Modes Detected

Primary Failure Modes

affected_node_cost detects or predicts:

• affected-node invisibility
• proof-burden overload
• hidden burden concentration
• repair burden export
• local harm under central success
• boundary strain
• trust depletion
• recurrence concentration
• appeal exhaustion
• official-memory distortion
• pseudo-repair
• extraction regime
• legitimacy shock
• pseudo-damping
• affected-node exit
• cost erasure
• repair rejection

Composite Regimes Where affected_node_cost Matters

• Extraction Regime: affected nodes carry cost while others benefit
• Repair Theater: repair claims do not reach affected nodes
• Goodhart Collapse: central Φ hides local cost
• Pseudo-Coherent Basin: stability is funded by affected-node burden
• Coercive Fusion: affected node cannot exit despite cost
• Crisis Loop: same nodes keep absorbing recurrence
• LOS: latent operations place cost where formal systems do not see it
• Mission Lock: affected-node cost is subordinated to trajectory
• Taboo Lock: cost cannot be named

16) Accountability & Reintegration Implications

If affected_node_cost Was Ignored

Likely consequences:

• central recovery was mistaken for real recovery
• affected nodes carried hidden burden
• proof burden increased
• repair burden was exported
• trust declined
• official memory became contested
• recurrence concentrated locally
• legitimacy shock occurred after cost exposure
• system claimed coherence while cost persisted
• affected nodes exited or disengaged

Accountability questions:

• Who carried the cost?
• What kind of cost?
• For how long?
• Was it acknowledged?
• Was it repaired?
• Did repair reach the affected node?
• Did proof burden add cost?
• Did appeal add cost?
• Did central metrics hide the burden?
• Did affected-node memory enter U7?
• Did recurrence continue at the affected node?
• Who benefited while the affected node carried cost?

If affected_node_cost Was Misread

Possible misread forms:

• cost visibility mistaken for cost creation
• affected-node signal mistaken for blame
• temporary supported burden mistaken for extraction
• affected-node participation mistaken for consent
• central recovery mistaken for local repair
• silence mistaken for recovery
• high cost mistaken for clear causality
• proof process mistaken for neutral when costly
• local cost overgeneralized without system comparison
• affected-node validation mistaken for total process control

Required Restoration

When affected_node_cost failure is found:

identify affected node
→ map cost type, magnitude, and duration
→ reduce proof and repair burden
→ resource affected-node recovery
→ repair origin-layer cause
→ correct official memory
→ validate recovery and recurrence reduction

If affected-node cost is unevenly distributed, MS-Gate should review burden, repair, proof, appeal, and recognition symmetry.

17) Cross-Domain Examples

Technical / Engineering

A central platform team reports stability improvements, but a downstream support team handles increased user complaints and manual workarounds.

Diagnostic implication: central Φ improved while affected-node cost rose downstream.

Operator sequence: downstream burden audit → root-cause repair → support load reduction → U7 incident memory correction.

Institutional / Governance

A complaint process is “available,” but the affected person must gather evidence, navigate forms, repeat the harm, and wait months.

Diagnostic implication: appeal/proof burden is part of affected-node cost.

Operator sequence: proof-burden reduction → process support → affected-node validation → repair timeline correction.

AI / Algorithmic

An AI memory error is easy for the system to produce but costly for the user to detect, explain, correct, and monitor.

Diagnostic implication: user correction burden is affected-node cost.

Operator sequence: memory audit access → correction propagation → recurrence test → user validation.

Interaction / Relational

One person experiences boundary strain and must repeatedly explain, remind, track, and repair the same issue.

Diagnostic implication: affected-node cost includes repeated explanation and repair tracking.

Operator sequence: reduce exposure → redistribute repair burden → repair boundary behavior → validate through recurrence.

Archive / Framework Design

Readers encounter terminology drift and must mentally reconcile inconsistencies because glossary/cross-link repair is incomplete.

Diagnostic implication: archive cost has shifted to the reader as affected node.

Operator sequence: glossary correction → cross-link repair → reader stress-test → U7 version update.

18) Test Protocols

1. Affected Node Identification Test

Who is most exposed to the consequence?

Failure signal: affected node is not clearly named.

2. Cost Type Test

What kind of cost is being carried?

Failure signal: only visible material cost is measured.

3. Duration Test

How long does the cost persist?

Failure signal: temporary event creates long-tail burden.

4. Proof Burden Test

Who must prove the cost exists?

Failure signal: affected node carries repeated proof burden.

5. Repair Reach Test

Does repair reach the affected node?

Failure signal: central system repairs itself while local burden remains.

6. Recurrence Exposure Test

Does the same node keep absorbing recurrence?

Failure signal: recurrence concentrates on exposed nodes.

7. Memory Test

Does U7 preserve affected-node cost?

Failure signal: official memory omits local burden.

8. Exit/Refusal Test

Can the affected node reduce exposure?

Failure signal: affected node must continue absorbing cost.

9. Central/Local Metric Test

Do central metrics match affected-node state?

Failure signal: central success hides local cost.

10. Symmetry Test

Do comparable affected nodes receive comparable recognition and repair?

Failure signal: affected-node cost is acknowledged selectively.

19) Anti-Patterns

• Aggregate success as local repair
• Central recovery as affected-node recovery
• Silence as low cost
• Compliance as recovery
• Proof burden as neutral
• Appeal burden as access
• Repair process as repair
• Affected-node signal as blame
• Cost visibility as cost creation
• Low-rank burden as operational noise
• Hidden labor as normal
• Exit as resolution
• Local workaround as resilience
• Repeated explanation as cooperation
• Affected-node patience as restoration
• Official memory as affected-node memory
• Metric recovery as trust recovery
• Repair claim before local validation
• Burdened node as difficult node
• Cost averaged away

20) Spec Validation Check

• Is this truly a diagnostic, not an operator? Yes.
• Does it measure state, capacity, risk, or response rather than act directly? Yes.
• Does it map to S? Yes.
• Are U-layers specified? Yes.
• Are leading and lagging indicators separated? Yes.
• Are interpretation risks defined? Yes.
• Are operator sequencing implications clear? Yes.
• Are gate implications clear? Yes.
• Are scaling risks included? Yes.
• Are interaction implications included? Yes.
• Does it avoid new primitives? Yes.

Condensed Archive Summary

affected_node_cost is the diagnostic estimate of the burden carried by the node most exposed to the consequences of a system action, failure, constraint, classification, dependency, coupling, or repair gap. It includes material, time, energy, proof, appeal, repair, boundary, trust, memory, access, opportunity, and recurrence costs. It does not identify causality by itself; it identifies where consequence lands. High affected_node_cost indicates risk of affected-node invisibility, proof-burden overload, hidden burden concentration, repair burden export, local harm under central success, boundary strain, trust depletion, pseudo-repair, official-memory distortion, extraction dynamics, and legitimacy shock. Under high affected_node_cost, the system should pause closure, map cost type/magnitude/duration, reduce proof and repair burden, resource affected-node recovery, repair the origin layer, correct U7 memory, and validate affected-node recovery before repair-complete claims, deep re-coupling, scaling, or legitimacy narratives.