Maturity-Aware Gating & Structural Refactoring

• Maturity-aware gating is a probabilistic update mechanism that adjusts skill updates based on reliability, balancing stability and plasticity.
• Canonical structural refactoring reorganizes the skill network to eliminate redundancy and promote compositional reuse through rollback validation.
• Combined in the PSN framework, these methods ensure efficient continual programmatic learning with improved performance and reduced catastrophic forgetting.

Maturity-aware gating and canonical structural refactoring with rollback validation constitute core mechanisms in continual programmatic skill learning, as formalized in the Programmatic Skill Network (PSN) framework. These methods address the central challenges of stability-plasticity balance, compactness, and robust compositional generalization in a continually evolving library of executable symbolic skills. PSN instantiates both mechanisms to enable effective expansion, reuse, and ongoing optimization of a compositional skill network, leveraging the reliability of mature skills while ensuring adaptability for emerging or uncertain subroutines (Shi et al., 7 Jan 2026).

1. Formalism of Maturity-Aware Update Gating

Maturity-aware gating is a soft, probabilistic optimization protocol governing the frequency and aggressiveness of updates for each skill in response to execution failures. The mechanism is defined as follows:

• Each skill $s$ tracks a smoothed empirical success rate,

$\hat{p}_s = \frac{N^+_s + 1}{N_s + 2},$

where $N_s$ is the execution count and $N^+_s$ the successes (Laplace smoothing).

• The uncertainty term $u_s \propto 1/\sqrt{N_s}$, decreasing as $s$ accumulates experience.
• The scalar maturity-score,

$V(s) = \hat{p}_s - u_s \in [0,1],$

quantifies confidence-adjusted reliability.

Given minimum update probability $\epsilon=0.1$, sharpness parameter $\gamma=5.0$, and a pivot $V_0=0.6$, the update probability on failure is

$\hat{p}_s = \frac{N^+_s + 1}{N_s + 2},$0

where $\hat{p}_s = \frac{N^+_s + 1}{N_s + 2},$1 is the sigmoid function.

Operatively, for each failed skill $\hat{p}_s = \frac{N^+_s + 1}{N_s + 2},$2:

• Draw $\hat{p}_s = \frac{N^+_s + 1}{N_s + 2},$3.
• If $\hat{p}_s = \frac{N^+_s + 1}{N_s + 2},$4, apply a two-stage optimization to $\hat{p}_s = \frac{N^+_s + 1}{N_s + 2},$5 (fault localization and repair); otherwise, skip updating $\hat{p}_s = \frac{N^+_s + 1}{N_s + 2},$6.

This gate admits a Bernoulli mask view:

$\hat{p}_s = \frac{N^+_s + 1}{N_s + 2},$7

The gating mechanism interpolates between full plasticity (immature, unreliable skills) and near-freezing (mature, reliable skills), dynamically preventing catastrophic forgetting without premature stasis. This is analogous to learning-rate annealing, layer freezing, or per-parameter importance weighting in neural paradigms, but applied to symbolic programs (Shi et al., 7 Jan 2026).

2. Canonical Structural Refactoring and Rollback Validation

Structural refactoring operates at the network level, periodically reorganizing the skill graph for compactness, redundancy elimination, and abstraction. PSN enforces correctness-preserving rewrites under a rollback-protected regime.

Canonicalization Rules

PSN recognizes five semantics-preserving cases for refactoring:

Case	Description	Transformation
Parametric coverage	$\hat{p}_s = \frac{N^+_s + 1}{N_s + 2},$8 is strict specialization of $\hat{p}_s = \frac{N^+_s + 1}{N_s + 2},$9	Rewrite $N_s$0 as wrapper of $N_s$1
Behavioral / subgraph coverage	Composite skill duplicates logic of existing skill	Replace inlined subgraph with call to existing skill
Sibling specializations	Multiple skills share structural pattern, no abstraction	Synthesize abstract skill, rewrite siblings as wrappers
Common subskill extraction	Identical sub-operation present in multiple skills	Factor subgraph into reusable skill, invoke from hosts
Duplication removal	Skills are functionally equivalent up to naming/syntax	Keep canonical, redirect, remove duplicate

Rollback Validation Protocol

Upon any successful execution of a high-level skill $N_s$2, PSN examines the local neighborhood—parents, children, and top-5 semantically similar skills via embeddings—for refactor opportunities. For each potential pattern and the corresponding rewrite proposal $N_s$3, safety is validated as follows:

• Identify last three tasks $N_s$4 involving affected skills.
• Measure new and original network success rates: $N_s$5 and $N_s$6.
• Accept the refactor only if

$N_s$7

i.e., no more than a $N_s$8 drop in validation performance; otherwise, revert.

This thresholded rollback constitutes a symbolic trust region, tightly bounding degradations introduced by structural changes.

3. Optimization Algorithms and Implementation

The skill-level maturity gating and network-level refactoring operate on distinct timescales and through explicit, reproducible algorithms.

• Skill Optimization Loop (on failure):

$N^+_s$4

• Refactoring Pipeline (after success):

$N^+_s$5

The interaction between the two mechanisms stabilizes the primitives before network-wide reorganization, thereby maintaining both robustness and adaptability during open-ended continual learning (Shi et al., 7 Jan 2026).

4. Empirical Analyses of Gating and Refactoring

A series of ablation and diagnostic studies on open-ended task benchmarks elucidates the isolated effects of both mechanisms (Shi et al., 7 Jan 2026).

• Gating Ablation: Without maturity-aware gating, cumulative success on Minecraft exhibits persistent oscillations, attributed to downstream failures triggering continual re-editing of converged skills. With gating, the curve is monotonic and ends $N_s$9 higher, demonstrating stability.
• Refactor Ablation: The PSN's full structural module causes library size to plateau or shrink (via merges and extractions), while naive skill creation yields linear growth. In a fixed compositional sequence, online refactor with rollback achieves $N^+_s$0 success versus offline-baseline's $N^+_s$1, indicating improved reuse and robustness.
• Retention and Forgetting: Skill retention (fraction of validated skills remaining usable) remains above $N^+_s$2 in PSN with gating, compared to $N^+_s$3 for a baseline, reflecting strong protection against catastrophic forgetting.

These results isolate the stabilizing and compactifying effects of maturity-aware gating and canonical refactor, respectively.

5. Theoretical Context and Interactions

Maturity-aware gating addresses the classical stability-plasticity dilemma central to continual learning. By dynamically modulating update plasticity as a function of reliability, PSN avoids both catastrophic interference (overwriting working subroutines) and premature stasis (blocking repair). This expands on principles established in neural continual learning (e.g., Elastic Weight Consolidation) but applies them in a symbolic, programmatic domain.

Canonical structural refactoring, by contrast, ensures that the evolving network graph remains both semantically minimal and conducive to compositional planning. The refactor module's rollback-based validation introduces explicit symbolic trust regions—a paradigm distinct from continuous regularization—guaranteeing that aggressive abstraction or deduplication cannot significantly erode performance.

The mechanisms operate at complementary timescales: rapid gating calibrates per-skill updates, while slower refactoring executes structural reorganizations after success. This synergy produces a compact, stable, and compositionally rich library, accelerating planning and generalization over long task horizons (Shi et al., 7 Jan 2026).

6. Practical Implications and Limitations

The combined protocol of maturity-aware gating and rollback-validated canonical refactoring enables PSN to exhibit:

• Network compactness via aggressive but safe graph reorganizations.
• High skill reuse and compositionality, leveraging stable mature primitives for abstraction.
• Robust end-to-end performance, witnessed by reduced planning horizons and minimized search complexity as the library evolves.

A plausible implication is that this architecture is particularly well-suited for lifelong open-ended learning in symbolic or hybrid domains, where continual program repair and abstraction are required at large scale.

Limiting factors include the reliance on local (short-horizon) rollback for refactor validation, which permits some risk of undetected long-range performance regressions, and the inherent complexity of maintaining precise maturity statistics for large libraries. These aspects define promising directions for further empirical and theoretical investigation.