TASK: Produce MODEL_SPEC v1.0 (canonical, frozen). Output JSON only.

INPUT DATA (read from the uploaded markdown files):
- State vector and inputs:
  x(t) = [z(t), v_p(t), T_b(t), S(t), w(t)]
  u(t) = [L(t), C(t), N(t), Ψ(t), T_a(t)]
- Equations to include exactly:
  (A) Power mapping P_tot(t) = P_bg + P_scr(L) + P_cpu(C) + P_net(N,Ψ,w)
  (B) Terminal voltage V_term = V_oc(z) - v_p - I*R0(T_b,S)
  (C) SOC ODE: dz/dt = - I / (3600 * Q_eff(T_b,S))
  (D) Polarization ODE: dv_p/dt = I/C1 - v_p/(R1*C1)
  (E) Thermal ODE: dT_b/dt = ( I^2*R0 + I*v_p - hA*(T_b - T_a) ) / C_th
  (F) Tail ODE: dw/dt = (σ(N)-w)/τ(N) with τ_up, τ_down switching rule
  (G) CPL closure:
      R0*I^2 - (V_oc(z)-v_p)*I + P_tot = 0
      I = (V_oc(z)-v_p - sqrt(Δ)) / (2*R0)
      Δ = (V_oc(z)-v_p)^2 - 4*R0*P_tot
  (H) V_oc(z) (modified Shepherd): V_oc(z)=E0 - K(1/z - 1) + A*exp(-B(1-z))
  (I) R0(T_b,S) Arrhenius + SOH factor
  (J) Q_eff(T_b,S) temperature + aging factor with max-floor

METHODLOGY (must define explicitly in JSON):
1) Domain constraints and guards:
   - z ∈ [0,1], S ∈ (0,1], w ∈ [0,1]
   - define z_eff = max(z, z_min) for V_oc to avoid 1/z singularity
   - define Q_eff_floor to avoid negative capacity
2) Event functions and termination logic:
   Define three event functions:
   gV(t)=V_term(t)-V_cut
   gz(t)=z(t)   (threshold 0)
   gΔ(t)=Δ(t)   (threshold 0)
   Terminate at first crossing where any event function becomes ≤ 0.
   Record termination_reason ∈ {"V_CUTOFF","SOC_ZERO","DELTA_ZERO"}.
3) Define TTE precisely:
   TTE = t* - t0 where t* is the earliest event time.
   Use linear interpolation between the last two time samples for the event that triggers termination.

DELIVERABLE (JSON ONLY):
Return a JSON object with keys:
- "states" (list of {name, unit, bounds})
- "inputs" (list of {name, unit, bounds})
- "parameters" (list of {name, unit, description})
- "equations" (each equation as a string; use the exact variable names)
- "guards" (z_min, Q_eff_floor, clamp rules)
- "events" (definition of gV, gz, gΔ; termination logic)
- "tte_definition" (interpolation formula and tie-breaking rule if multiple cross in same step)
- "numerics" (method="RK4_nested_CPL", dt_symbol="dt", stage_recompute_current=true)

VALIDATION (must be encoded as JSON fields too):
- "dimension_check": list required units consistency checks
- "monotonicity_check": SOC must be non-increasing while I>=0
- "feasibility_check": Δ must be >=0 before sqrt; if Δ<0 at any evaluation, event triggers

OUTPUT FORMAT:
JSON only, no markdown, no prose.

TASK: Produce MODEL_SPEC v1.0 (canonical, frozen). Output JSON only.

INPUT DATA (read from the uploaded markdown files):
- State vector and inputs:
  x(t) = [z(t), v_p(t), T_b(t), S(t), w(t)]
  u(t) = [L(t), C(t), N(t), Ψ(t), T_a(t)]
- Equations to include exactly:
  (A) Power mapping P_tot(t) = P_bg + P_scr(L) + P_cpu(C) + P_net(N,Ψ,w)
  (B) Terminal voltage V_term = V_oc(z) - v_p - I*R0(T_b,S)
  (C) SOC ODE: dz/dt = - I / (3600 * Q_eff(T_b,S))
  (D) Polarization ODE: dv_p/dt = I/C1 - v_p/(R1*C1)
  (E) Thermal ODE: dT_b/dt = ( I^2*R0 + I*v_p - hA*(T_b - T_a) ) / C_th
  (F) Tail ODE: dw/dt = (σ(N)-w)/τ(N) with τ_up, τ_down switching rule
  (G) CPL closure:
      R0*I^2 - (V_oc(z)-v_p)*I + P_tot = 0
      I = (V_oc(z)-v_p - sqrt(Δ)) / (2*R0)
      Δ = (V_oc(z)-v_p)^2 - 4*R0*P_tot
  (H) V_oc(z) (modified Shepherd): V_oc(z)=E0 - K(1/z - 1) + A*exp(-B(1-z))
  (I) R0(T_b,S) Arrhenius + SOH factor
  (J) Q_eff(T_b,S) temperature + aging factor with max-floor

METHODLOGY (must define explicitly in JSON):
1) Domain constraints and guards:
   - z ∈ [0,1], S ∈ (0,1], w ∈ [0,1]
   - define z_eff = max(z, z_min) for V_oc to avoid 1/z singularity
   - define Q_eff_floor to avoid negative capacity
2) Event functions and termination logic:
   Define three event functions:
   gV(t)=V_term(t)-V_cut
   gz(t)=z(t)   (threshold 0)
   gΔ(t)=Δ(t)   (threshold 0)
   Terminate at first crossing where any event function becomes ≤ 0.
   Record termination_reason ∈ {"V_CUTOFF","SOC_ZERO","DELTA_ZERO"}.
3) Define TTE precisely:
   TTE = t* - t0 where t* is the earliest event time.
   Use linear interpolation between the last two time samples for the event that triggers termination.

DELIVERABLE (JSON ONLY):
Return a JSON object with keys:
- "states" (list of {name, unit, bounds})
- "inputs" (list of {name, unit, bounds})
- "parameters" (list of {name, unit, description})
- "equations" (each equation as a string; use the exact variable names)
- "guards" (z_min, Q_eff_floor, clamp rules)
- "events" (definition of gV, gz, gΔ; termination logic)
- "tte_definition" (interpolation formula and tie-breaking rule if multiple cross in same step)
- "numerics" (method="RK4_nested_CPL", dt_symbol="dt", stage_recompute_current=true)

VALIDATION (must be encoded as JSON fields too):
- "dimension_check": list required units consistency checks
- "monotonicity_check": SOC must be non-increasing while I>=0
- "feasibility_check": Δ must be >=0 before sqrt; if Δ<0 at any evaluation, event triggers

OUTPUT FORMAT:
JSON only, no markdown, no prose.

TASK: Write a deterministic, language-agnostic specification for TTE computation.

INPUT DATA:
- MODEL_SPEC.events and MODEL_SPEC.tte_definition from Prompt 1
- A simulated time grid t_k = t0 + k*dt, k=0..K
- Arrays sampled at each grid point:
  V_term[k], z[k], Δ[k]

METHODOLOGY:
1) Define event signals:
   gV[k] = V_term[k] - V_cut
   gz[k] = z[k] - 0
   gΔ[k] = Δ[k] - 0
2) Crossing rule:
   A crossing occurs for event e when g_e[k-1] > 0 and g_e[k] ≤ 0.
3) Interpolated crossing time for event e:
   t_e* = t[k-1] + (0 - g_e[k-1])*(t[k]-t[k-1])/(g_e[k]-g_e[k-1])
   (If denominator = 0, set t_e* = t[k].)
4) Multi-event tie-breaking:
   If multiple events cross in the same step, compute each t_e* and choose the smallest.
   If equal within 1e-9, prioritize in this order:
      DELTA_ZERO > V_CUTOFF > SOC_ZERO
5) Output:
   - TTE_seconds = t* - t0
   - termination_reason
   - termination_step_index k
   - termination_values at t* using linear interpolation for (V_term, z, Δ)

DELIVERABLES:
A) “TTE_SPEC” section: the above as precise pseudocode with no ambiguity.
B) A minimal test suite (exact numeric arrays) containing 3 tests:
   Test 1: voltage cutoff triggers
   Test 2: SOC hits zero first
   Test 3: Δ hits zero first (power infeasible)
For each test, provide expected outputs exactly (TTE_seconds, reason, t*).

VALIDATION:
- Must detect the correct earliest event (by construction of tests).
- Must reproduce expected t* to within absolute error ≤ 1e-9 in the tests.
- Must never take sqrt of negative Δ during event evaluation (use sampled Δ).

OUTPUT FORMAT (strict):
1) Header line: "TTE_SPEC_v1"
2) Pseudocode block
3) "TESTS_v1" as JSON with {tests:[...]} including expected outputs
No additional text.

TASK: Produce a deterministic function-level design for simulation with RK4 + nested CPL.

INPUT DATA:
- MODEL_SPEC from Prompt 1
- TTE_SPEC from Prompt 2
- Scenario definition: provides u(t) = [L(t),C(t),N(t),Ψ(t),T_a(t)] for any t
- Initial state x0 = [z0, v_p0, T_b0, S0, w0]
- Fixed constants: dt, t_max

METHODOLOGY:
Define these pure functions (no side effects):
1) params_to_constitutive(x, params):
   returns V_oc, R0, Q_eff at current state (with guards z_eff, floors)
2) power_mapping(u, x, params):
   returns P_tot
3) current_cpl(V_oc, v_p, R0, P_tot):
   returns Δ and I using the specified quadratic root
4) rhs(t, x, u, params):
   computes dx/dt using I(t) found by CPL closure

RK4 step (must be spelled out exactly):
Given (t_n, x_n):
- Compute u_n = scenario.u(t_n)
- Stage 1 uses rhs(t_n, x_n, u_n)
- Stage 2 uses rhs(t_n+dt/2, x_n + dt*k1/2, u(t_n+dt/2))
- Stage 3 uses rhs(t_n+dt/2, x_n + dt*k2/2, u(t_n+dt/2))
- Stage 4 uses rhs(t_n+dt, x_n + dt*k3, u(t_n+dt))
- x_{n+1} = x_n + dt*(k1 + 2k2 + 2k3 + k4)/6
After updating, clamp states to bounds (z,S,w) as per MODEL_SPEC.

Event evaluation:
At each grid point, store V_term, z, Δ.
After each step, check crossings using TTE_SPEC.

DELIVERABLES:
A) A complete “SIM_API_v1” specification listing:
   - Function signatures
   - Inputs/outputs (including units)
   - Exactly what arrays are stored each step
   - Termination output bundle
B) A single canonical output schema:
   "trajectory" table columns exactly:
   t, z, v_p, T_b, S, w, V_oc, R0, Q_eff, P_tot, Δ, I, V_term
   plus metadata: dt, t_max, termination_reason, t_star, TTE_seconds

VALIDATION:
- Must state the convergence requirement:
   step-halving: compare dt vs dt/2 with:
   max|z_dt - z_dt2| < 1e-4 and relative TTE error < 1% (exactly these thresholds)
- Must include feasibility guard: if Δ becomes negative at any rhs evaluation, trigger event DELTA_ZERO.

OUTPUT FORMAT:
Return YAML only with keys: SIM_API_v1, OutputSchema, ValidationPlan.
No prose.

TASK: Output BASELINE_CONFIG_v1 as JSON only (parameters + scenario schedule).

INPUT DATA:
- MODEL_SPEC parameter list (Prompt 1)
- Scenario concept: 6-hour alternating profile with smooth transitions using:
  win(t;a,b,δ)=1/(1+exp(-(t-a)/δ)) - 1/(1+exp(-(t-b)/δ))
  and L(t)=Σ L_j*win(t;a_j,b_j,δ), similarly for C(t), N(t)

METHODOLOGY:
1) Choose δ = 20 seconds exactly.
2) Define a 6-hour schedule with exactly 6 segments in seconds:
   Segment table fields:
   name, a_sec, b_sec, L_level, C_level, N_level, Ψ_level, T_a_C
3) Use the example normalized levels:
   standby:    L=0.10 C=0.10 N=0.20
   streaming:  L=0.70 C=0.40 N=0.60
   gaming:     L=0.90 C=0.90 N=0.50
   navigation: L=0.80 C=0.60 N=0.80
   Include exactly one “poor signal” hour where Ψ_level is lower than the rest.
4) Freeze initial conditions:
   z0 in {1.00,0.75,0.50,0.25}; v_p0=0; w0=0; S0=1; T_b0=T_a(0)
5) Freeze numerics:
   dt=1.0 second; t_max=24*3600 seconds; seed=20260201

DELIVERABLE:
JSON object with keys:
- params: {name:value} for every parameter in MODEL_SPEC
- scenario: {delta_sec, segments:[...], win_definition_string}
- initial_conditions: list of z0 values and fixed other inits
- numerics: {dt, t_max, seed}

VALIDATION:
- segments must cover [0,21600] seconds without gaps (allow overlaps only via smooth win)
- all input levels must lie within required bounds (L,C,N,w in [0,1], Ψ in (0,1])

OUTPUT FORMAT:
JSON only. No markdown.

TASK: Execute BASELINE_CONFIG_v1 through SIM_API_v1 and return deliverables.

INPUT DATA:
- BASELINE_CONFIG_v1 (Prompt 4)
- SIM_API_v1 (Prompt 3)
- TTE_SPEC_v1 (Prompt 2)

METHODOLOGY:
For each z0 in {1.00,0.75,0.50,0.25}:
1) Simulate trajectory until termination.
2) Compute TTE via event interpolation.
3) Compute summary metrics:
   - avg(P_tot) over [0,t*]
   - max(I), max(T_b), min(Δ) over [0,t*]
   - energy_check = ∫ P_tot dt (Wh) and compare to nominal energy 14.8 Wh baseline

DELIVERABLES (must be returned in this order):
A) “TTE_TABLE_v1” as CSV text with rows for each z0:
   z0, TTE_hours, termination_reason, t_star_sec, avg_P_W, max_I_A, max_Tb_C
B) “FIGURE_SPEC_v1” as JSON listing exactly 4 plots to generate:
   1) SOC z(t)
   2) Current I(t) and power P_tot(t) (dual axis)
   3) Battery temperature T_b(t)
   4) Discriminant Δ(t)
Each plot must specify:
   title, x_label, y_label(s), filename (png), and which trajectory columns to use.
C) “VALIDATION_REPORT_v1” as JSON with:
   - monotonicity_pass (true/false)
   - any_negative_delta_before_event (true/false)
   - energy_check_values (per z0)

VALIDATION CRITERIA (hard):
- SOC must be non-increasing for all runs.
- V_term must never be NaN/inf.
- Energy check must be within [5 Wh, 20 Wh] for z0=1.00 (otherwise FAIL).
If any check fails: output only FAIL + the validation JSON.

OUTPUT FORMAT:
A) CSV block
B) JSON block
C) JSON block
No prose.

TASK: Run convergence/robustness checks for baseline scenario.

INPUT DATA:
- Same configuration as Prompt 5, but run two numerics:
  A) dt = 1.0 s
  B) dt = 0.5 s
- Use identical params and scenario.

METHODOLOGY:
For each z0:
1) Simulate with dt and dt/2 until termination.
2) Compare z(t) by resampling dt/2 solution at dt grid (take every 2nd sample).
3) Compute:
   z_diff_inf = max_k |z_dt[k] - z_dt2[2k]|
   tte_rel_err = |TTE_dt - TTE_dt2| / TTE_dt2
4) Event-location robustness:
   For each run, report the last two bracketing samples for the triggering event and the interpolated t*.

DELIVERABLES:
A) “STEP_HALVING_TABLE_v1” CSV:
   z0, z_diff_inf, tte_rel_err, pass_bool
B) “EVENT_BRACKET_REPORT_v1” JSON:
   for each z0: {reason, (t_k-1, g_k-1), (t_k, g_k), t_star}
C) Single line verdict:
   "ROBUSTNESS_PASS" or "ROBUSTNESS_FAIL"

VALIDATION (hard thresholds):
- z_diff_inf < 1e-4
- tte_rel_err < 0.01
All z0 must pass or verdict is FAIL.

OUTPUT FORMAT:
CSV, then JSON, then verdict line. No prose.

TASK: Produce a scenario matrix and attribute TTE reductions to drivers.

INPUT DATA:
- BASELINE_CONFIG_v1
- Choose z0 = 1.00 only
- Define 8 scenarios total:
  S0 baseline
  S1 brightness reduced: L(t) scaled by 0.5
  S2 CPU reduced: C(t) scaled by 0.5
  S3 network reduced: N(t) scaled by 0.5
  S4 signal worsened: Ψ(t) replaced by min(Ψ, Ψ_poor) for entire run
  S5 cold ambient: T_a = 0°C constant
  S6 hot ambient:  T_a = 40°C constant
  S7 background cut: P_bg reduced by 50%

METHODOLOGY:
1) For each scenario, run simulation and compute TTE_hours.
2) Compute ΔTTE_hours = TTE(Si) - TTE(S0).
3) Rank scenarios by most negative ΔTTE (largest reduction).
4) For top 3 reductions, compute “mechanistic signatures”:
   avg(P_tot), max(I), min(Δ), avg(R0), avg(Q_eff)

DELIVERABLES:
A) SCENARIO_TTE_TABLE_v1 (CSV):
   scenario_id, description, TTE_hours, ΔTTE_hours, termination_reason
B) DRIVER_RANKING_v1 (JSON):
   ordered list of scenario_id with ΔTTE_hours
C) MECH_SIGNATURES_v1 (CSV) for top 3 reductions:
   scenario_id, avg_P, max_I, min_Δ, avg_R0, avg_Qeff

VALIDATION:
- All scenarios must terminate with a valid event reason.
- No scenario may produce NaN/inf in stored columns.

OUTPUT FORMAT:
CSV, JSON, CSV. No prose.

TASK: Global sensitivity on TTE using Sobol (Saltelli sampling), deterministic.

INPUT DATA:
- z0 = 1.00
- Baseline params from BASELINE_CONFIG_v1
- Select exactly 6 uncertain scalar parameters (must exist in params):
  k_L, k_C, k_N, κ (signal exponent), R_ref, α_Q
- Define ±20% uniform ranges around baseline for each.
- Sampling:
  N_base = 512
  Saltelli scheme with seed = 20260201

METHODOLOGY:
1) Generate Saltelli samples (A, B, A_Bi matrices).
2) For each sample, run simulation to get TTE_hours.
3) Compute Sobol first-order S_i and total-order ST_i.

DELIVERABLES:
A) SOBOL_TABLE_v1 (CSV):
   param, S_i, ST_i
B) SOBOL_RANKING_v1 (JSON): params ordered by ST_i descending
C) COMPUTE_LOG_v1 (JSON): N_evals_total, failures_count (must be 0)

VALIDATION:
- failures_count must be 0.
- All S_i and ST_i must lie in [-0.05, 1.05] else FAIL (numerical sanity).

OUTPUT FORMAT:
CSV, JSON, JSON. No prose.

TASK: UQ for TTE by stochastic usage paths; output CI + survival curve.

INPUT DATA:
- z0 = 1.00
- Baseline params
- Base deterministic inputs L0(t), C0(t), N0(t) from scenario
- Stochastic perturbations: OU processes added to each of L,C,N:
  dX = -θ(X-0)dt + σ dW
  Use θ=1/600 1/s (10-minute reversion), σ=0.02
- Enforce bounds by clipping final L,C,N to [0,1]
- Runs:
  M = 300 Monte Carlo paths
  seed = 20260201

METHODOLOGY:
1) For m=1..M, generate OU noise paths on the same dt grid.
2) Build L_m(t)=clip(L0(t)+X_L(t)), etc.
3) Simulate → TTE_m.
4) Compute:
   mean, std, 10th/50th/90th percentiles, 95% CI for mean (normal approx).
5) Survival curve:
   For t_grid_hours = 0..max(TTE) in 0.25h increments,
   estimate S(t)=P(TTE > t) empirically.

DELIVERABLES:
A) UQ_SUMMARY_v1 (JSON): mean, std, p10, p50, p90, CI95_low, CI95_high
B) SURVIVAL_CURVE_v1 (CSV): t_hours, S(t)
C) REPRODUCIBILITY_v1 (JSON): seed, M, θ, σ, dt

VALIDATION:
- Must have exactly M successful runs.
- Survival curve must be non-increasing in t (else FAIL).

OUTPUT FORMAT:
JSON, CSV, JSON. No prose.

TASK: Generate the FINAL_SUMMARY_v1 for the MCM/ICM technical report.

INPUT DATA:
- All results from Prompt 1 to Prompt 8 (Model specs, TTE Table, Sensitivity, Robustness, UQ Summary).

DELIVERABLES:
A) “TECHNICAL_HIGHLIGHTS_v1” List:
   - Identify the 3 most critical physical trade-offs discovered (e.g., Signal Quality vs. Power, Low Temp vs. Internal Resistance).
   - Quantify the TTE impact of the worst-case scenario vs. baseline.
B) “MODEL_STRENGTHS_v1”:
   - List 3 technical strengths of our methodology (e.g., CPL algebraic-differential nesting, RK4 stability, Sobol-based sensitivity).
C) “EXECUTIVE_DATA_SNIPPET”:
   - A concise paragraph summarizing: "Our model predicts a baseline TTE of [X]h, with a [Y]% reduction in extreme cold. UQ analysis confirms a 90% survival rate up to [Z]h..."
D) “FUTURE_WORK_v1”:
   - 2 specific ways to improve the model (e.g., dynamic SOH aging laws, 2D thermal distribution modeling).

VALIDATION:
- All numbers must match the previous outputs exactly (4.60h baseline, 2.78h poor signal, 3.15h cold).

OUTPUT FORMAT:
Markdown with clear headings. Use LaTeX for equations if needed. No additional prose.

TASK: Perform a *surgical*, additive refinement of an existing academic paper on battery simulation to close three specific gaps:
(1) Missing GPS power
(2) Missing uncertainty quantification (Monte Carlo)
(3) Static aging TTE that fails to reflect dynamic degradation

CRITICAL REQUIREMENT (NON-NEGOTIABLE): PRESERVE EXISTING CONTENT INTEGRITY
- You MUST NOT do broad edits, major rewrites, rephrasings, or restructuring of any previously generated sections.
- You MUST NOT renumber existing sections or reorder headings.
- You MUST NOT change the existing narrative flow; only add narrowly targeted content and minimal equation patches.
- You MUST output only (a) minimal patches and (b) insert-ready new text blocks.
- If you cannot anchor an insertion to an exact existing heading string from the provided paper, output ERROR with the missing heading(s) and STOP.

INPUT DATA (use only the uploaded files):
1) The official MCM Problem A PDF (for requirements language: GPS, uncertainty, aging).
2) The current paper markdown (contains the existing model and structure).
3) The flowchart markdown (contains intended technical pipeline elements, e.g., UQ).

MODEL CONTEXT YOU MUST RESPECT (do NOT rewrite these; only refer to them):
- Existing input vector u(t) = [L(t), C(t), N(t), Ψ(t), T_a(t)] and state x(t) = [z, v_p, T_b, S, w].
- Existing power mapping: P_tot = P_bg + P_scr(L) + P_cpu(C) + P_net(N,Ψ,w).
- Existing CPL closure and event-based TTE logic.
- Existing SOH concept S(t) and its coupling to R0 and Q_eff (if present).
- Existing section numbering and headings.

YOUR OBJECTIVES:
A) CLASSIFY each gap by whether it requires changes to the base Model Construction:
   - “Base Model Construction” includes: core equations, constitutive relations, or simulation logic required to run the model.
B) For gaps NOT requiring base model changes, generate insert-ready academic text immediately (no rewrites).
C) For gaps requiring base model changes, produce:
   - A minimal patch (equations/logic) expressed as a precise replace/insert instruction.
   - A small, insert-ready text addendum describing the change (ONLY the new material; do not rewrite existing paragraphs).

METHODOLOGY (must be followed in order, no deviations):

STEP 1 — Locate anchors in the existing paper
1. Read the current paper markdown.
2. Extract the exact heading strings (verbatim) for:
   - The power mapping section (where P_tot is defined).
   - The numerical solution / simulation section (where MC/UQ would be placed).
   - The aging/SOH discussion section (or closest related section).
3. Store these verbatim headings as ANCHORS. You will reference them in patch instructions.

STEP 2 — Gap classification (deterministic)
For each gap in {GPS, UQ, Aging-TTE} output:
- requires_equation_change: true/false
- requires_simulation_logic_change: true/false
- text_only_addition: true/false
Rules:
- If adding a new term inside P_tot changes an equation, requires_equation_change=true.
- If adding an outer-loop procedure for multi-cycle degradation is needed, requires_simulation_logic_change=true.
- If content is purely reporting/analysis based on existing outputs (e.g., Monte Carlo over parameters/inputs using the same ODEs), then text_only_addition=true and both “requires_*” flags must be false.

STEP 3 — Minimal patch design (ONLY if required)
You must keep changes minimal and local:
3.1 GPS Power gap:
- Add exactly ONE GPS term into the existing P_tot equation.
- Preferred minimal strategy: do NOT change the declared input vector; define a derived duty variable G(t) inside the new GPS subsection:
  G(t) ∈ [0,1] derived from existing usage signals (e.g., navigation segment proxy) without redefining u(t).
- Define:
  P_gps(G) = P_gps,0 + k_gps * G(t)
  and update:
  P_tot ← P_tot + P_gps(G)
- Do not edit any other power terms.
3.2 Dynamic aging TTE gap:
- Do NOT rewrite the base ODEs unless absolutely necessary.
- Add an outer-loop “multi-cycle / multi-day” procedure that updates S(t) (or the aging proxy) across cycles and recomputes TTE each cycle:
  Example logic: for cycle j, run discharge simulation → accumulate throughput/aging integral → update S_{j+1} → update R0 and Q_eff via existing formulas → recompute TTE_{j+1}.
- Keep the inner single-discharge model unchanged; only add the outer-loop logic and clearly state time-scale separation.

STEP 4 — Insert-ready academic text blocks (additive only)
Generate concise academic prose that matches the paper’s existing style (math-forward, mechanistic rationale).
Rules:
- Each text block MUST be insertable without editing other sections.
- Each text block MUST define any new symbol it uses (e.g., G(t), P_gps,0, k_gps).
- Each text block MUST explicitly reference existing variables (L,C,N,Ψ,T_a,z,v_p,T_b,S,w,P_tot) without renaming.
- Citations: use placeholder citations like [REF-GPS-POWER], [REF-MONTE-CARLO], [REF-LIION-AGING] (do not browse the web).

You must produce 3 blocks:
BLOCK A (GPS): a new subsection placed immediately after the existing network power subsection (anchor it precisely).
BLOCK B (UQ): a new subsection placed in the numerical methods/results pipeline area describing Monte Carlo uncertainty quantification:
  - Define what is random (choose ONE: stochastic parameter draws OR stochastic usage paths OR both).
  - Specify sample size M (fixed integer), fixed seed, and outputs: mean TTE, quantiles, survival curve P(TTE>t).
  - Emphasize: model equations unchanged; uncertainty comes from inputs/parameters.
BLOCK C (Dynamic aging TTE): a new subsection explaining aging-aware TTE as a function of cycle index/time:
  - Define TTE_j sequence across cycles.
  - Define which parameters drift with S (e.g., Q_eff decreases, R0 increases).
  - Provide a short algorithm listing (numbered) but no code.

STEP 5 — Output packaging in strict schemas (no extra commentary)

DELIVERABLES (must be EXACTLY in this order):

1) GAP_CLASSIFICATION_v1 (JSON only)
Schema:
{
  "GPS_power": {
    "requires_equation_change": <bool>,
    "requires_simulation_logic_change": <bool>,
    "text_only_addition": <bool>,
    "one_sentence_rationale": "<...>"
  },
  "UQ_monte_carlo": { ...same keys... },
  "Aging_dynamic_TTE": { ...same keys... }
}

2) PATCH_SET_v1 (YAML only)
- Provide a list of patches. Each patch must be one of:
  - INSERT_AFTER_HEADING
  - REPLACE_EQUATION_LINE
Each patch item schema:
- patch_id: "P10-..."
- patch_type: "INSERT_AFTER_HEADING" or "REPLACE_EQUATION_LINE"
- anchor_heading_verbatim: "<exact heading text from the paper>"
- target_snippet_verbatim: "<exact single line to replace>"   (only for REPLACE_EQUATION_LINE)
- replacement_snippet: "<new single line>"                    (only for REPLACE_EQUATION_LINE)
- insertion_block_id: "BLOCK_A" / "BLOCK_B" / "BLOCK_C"        (only for INSERT_AFTER_HEADING)

3) INSERT_TEXT_BLOCKS_v1 (Markdown only)
Provide exactly three blocks, each wrapped exactly as:
-----BEGIN BLOCK_A-----
<markdown text to insert>
-----END BLOCK_A-----
(and similarly BLOCK_B, BLOCK_C)

4) MODIFICATION_AUDIT_v1 (JSON only)
Schema:
{
  "edited_existing_text": false,
  "changed_headings_or_numbering": false,
  "patch_ids_emitted": ["..."],
  "notes": "Only additive blocks + minimal equation line replace (if any)."
}

VALIDATION (hard fail rules):
- If you modify any existing paragraph (beyond the exact single-line equation replacement explicitly listed), output FAIL.
- If you renumber headings or propose reorganization, output FAIL.
- If any new symbol is introduced without definition inside its block, output FAIL.
- If any anchor_heading_verbatim does not exactly match a heading in the paper, output ERROR and STOP.

OUTPUT FORMAT:
Return exactly the 4 deliverables above (JSON, YAML, Markdown, JSON) and nothing else.