x402agent/SolanaOS / skills/qedgen
qedgen
FlaggedFormally verify programs by writing Lean 4 proofs. Trigger this skill whenever the user wants to formally verify code, generate Lean 4 proofs, prove properties about algorithms or smart contracts, verify invariants, convert program logic into formal specifications, or anything involving Lean 4 and formal verification. Also trigger when the user mentions "qedgen", "lean proof", "formal proof", "verify my code", "prove correctness", "formal verification", or wants mathematical guarantees about their implementation.
examples/rust/percolator/tests/proofs_invariants.rs
View on GitHub//! Sections 1-2 — Global inductive invariants
//!
//! Conservation, PnL tracking, side counts, haircut ratio.
#![cfg(kani)]
mod common;
use common::*;
// ============================================================================
// T0.3: set_pnl_aggregate_update_is_exact
// ============================================================================
#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn t0_3_set_pnl_aggregate_exact() {
let mut engine = RiskEngine::new(zero_fee_params());
let idx = engine.add_user(0).unwrap();
let old_pnl: i16 = kani::any();
kani::assume(old_pnl > i16::MIN);
engine.set_pnl(idx as usize, old_pnl as i128);
let new_pnl: i16 = kani::any();
kani::assume(new_pnl > i16::MIN);
engine.set_pnl(idx as usize, new_pnl as i128);
let expected = if new_pnl > 0 { new_pnl as u128 } else { 0u128 };
let actual = engine.pnl_pos_tot;
assert!(actual == expected);
}
#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn t0_3_sat_all_sign_transitions() {
let mut engine = RiskEngine::new(zero_fee_params());
let idx = engine.add_user(0).unwrap();
let old: i16 = kani::any();
let new: i16 = kani::any();
kani::assume(old > i16::MIN && new > i16::MIN);
let transition: u8 = kani::any();
kani::assume(transition < 4);
match transition {
0 => kani::assume(old <= 0 && new <= 0),
1 => kani::assume(old <= 0 && new > 0),
2 => kani::assume(old > 0 && new <= 0),
3 => kani::assume(old > 0 && new > 0),
_ => unreachable!(),
}
engine.set_pnl(idx as usize, old as i128);
engine.set_pnl(idx as usize, new as i128);
let expected = if new > 0 { new as u128 } else { 0u128 };
let actual = engine.pnl_pos_tot;
assert!(actual == expected, "pnl_pos_tot mismatch after transition");
}
// ============================================================================
// T0.4: conservation_check_handles_overflow
// ============================================================================
#[kani::proof]
#[kani::unwind(1)]
#[kani::solver(cadical)]
fn t0_4_conservation_check_handles_overflow() {
// Use u128 inputs directly to cover the full value range,
// including cases where c_tot + insurance may overflow u128.
let c_tot: u128 = kani::any();
let insurance: u128 = kani::any();
let vault: u128 = kani::any();
let deposit: u64 = kani::any();
let deposit_128 = deposit as u128;
// The conservation check uses checked_add, which may return None
let sum = c_tot.checked_add(insurance);
match sum {
Some(s) => {
// Non-overflow case: verify deposit preserves the invariant
if vault >= s {
// After deposit: vault + deposit and c_tot + deposit
let vault_new = vault.checked_add(deposit_128);
let c_tot_new = c_tot.checked_add(deposit_128);
if let (Some(vn), Some(cn)) = (vault_new, c_tot_new) {
// Conservation: vault_new >= c_tot_new + insurance
let sum_new = cn.checked_add(insurance);
if let Some(sn) = sum_new {
assert!(vn >= sn,
"deposit preserves conservation when no overflow");
}
}
}
}
None => {
// c_tot + insurance overflows u128 → conservation check
// must detect this as a deficit / corrupt state.
kani::cover!(true, "overflow branch reachable");
}
}
}
// ============================================================================
// Inductive proofs from kani.rs
// ============================================================================
#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn inductive_top_up_insurance_preserves_accounting() {
let mut engine = RiskEngine::new(zero_fee_params());
let idx = engine.add_user(0).unwrap();
let dep: u32 = kani::any();
kani::assume(dep > 0 && dep <= 1_000_000);
engine.deposit(idx, dep as u128, DEFAULT_ORACLE, DEFAULT_SLOT).unwrap();
assert!(engine.check_conservation());
let ins_amt: u32 = kani::any();
kani::assume(ins_amt <= 1_000_000);
engine.top_up_insurance_fund(ins_amt as u128, DEFAULT_SLOT).unwrap();
assert!(engine.check_conservation());
}
#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn inductive_set_capital_decrease_preserves_accounting() {
let mut engine = RiskEngine::new(zero_fee_params());
let idx = engine.add_user(0).unwrap();
let dep: u32 = kani::any();
kani::assume(dep >= 1000 && dep <= 1_000_000);
engine.deposit(idx, dep as u128, DEFAULT_ORACLE, DEFAULT_SLOT).unwrap();
assert!(engine.check_conservation());
let new_cap: u32 = kani::any();
kani::assume(new_cap <= dep);
engine.set_capital(idx as usize, new_cap as u128);
assert!(engine.check_conservation());
}
#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn inductive_set_pnl_preserves_pnl_pos_tot_delta() {
let mut engine = RiskEngine::new(zero_fee_params());
let a = engine.add_user(0).unwrap();
let b = engine.add_user(0).unwrap();
let pnl_a: i32 = kani::any();
kani::assume(pnl_a > i32::MIN);
engine.set_pnl(a as usize, pnl_a as i128);
let pnl_b: i32 = kani::any();
kani::assume(pnl_b > i32::MIN);
engine.set_pnl(b as usize, pnl_b as i128);
let pos_a: u128 = if pnl_a > 0 { pnl_a as u128 } else { 0 };
let pos_b: u128 = if pnl_b > 0 { pnl_b as u128 } else { 0 };
assert!(engine.pnl_pos_tot == pos_a + pos_b);
}
#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn inductive_deposit_preserves_accounting() {
let mut engine = RiskEngine::new(zero_fee_params());
let idx = engine.add_user(0).unwrap();
let dep: u32 = kani::any();
kani::assume(dep >= 1 && dep <= 1_000_000);
engine.deposit(idx, dep as u128, DEFAULT_ORACLE, DEFAULT_SLOT).unwrap();
assert!(engine.check_conservation());
}
#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn inductive_withdraw_preserves_accounting() {
let mut engine = RiskEngine::new(zero_fee_params());
let idx = engine.add_user(0).unwrap();
let dep: u32 = kani::any();
kani::assume(dep >= 1000 && dep <= 1_000_000);
engine.deposit(idx, dep as u128, DEFAULT_ORACLE, DEFAULT_SLOT).unwrap();
// Run keeper_crank to satisfy fresh-crank requirement for withdraw
let _ = engine.keeper_crank(DEFAULT_SLOT, DEFAULT_ORACLE, &[], 0);
let w: u32 = kani::any();
kani::assume(w >= 1 && w <= dep);
let result = engine.withdraw(idx, w as u128, DEFAULT_ORACLE, DEFAULT_SLOT);
if result.is_ok() {
assert!(engine.check_conservation());
}
}
#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn inductive_settle_loss_preserves_accounting() {
let mut engine = RiskEngine::new(zero_fee_params());
let idx = engine.add_user(0).unwrap();
let dep: u32 = kani::any();
kani::assume(dep >= 1000 && dep <= 1_000_000);
engine.deposit(idx, dep as u128, DEFAULT_ORACLE, DEFAULT_SLOT).unwrap();
assert!(engine.check_conservation());
let loss: i32 = kani::any();
kani::assume(loss < 0 && loss > i32::MIN);
kani::assume((-loss as u32) <= dep);
engine.set_pnl(idx as usize, loss as i128);
// touch_account_full settles losses from principal (step 9)
let _ = engine.touch_account_full(idx as usize, DEFAULT_ORACLE, DEFAULT_SLOT);
assert!(engine.check_conservation());
}
// ============================================================================
// Property proofs from kani.rs
// ============================================================================
#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn prop_pnl_pos_tot_agrees_with_recompute() {
let mut engine = RiskEngine::new(zero_fee_params());
let a = engine.add_user(0).unwrap();
let b = engine.add_user(0).unwrap();
let pnl_a: i32 = kani::any();
kani::assume(pnl_a > i32::MIN);
engine.set_pnl(a as usize, pnl_a as i128);
let pnl_b: i32 = kani::any();
kani::assume(pnl_b > i32::MIN);
engine.set_pnl(b as usize, pnl_b as i128);
let pos_a: u128 = if pnl_a > 0 { pnl_a as u128 } else { 0 };
let pos_b: u128 = if pnl_b > 0 { pnl_b as u128 } else { 0 };
let expected = pos_a + pos_b;
assert!(engine.pnl_pos_tot == expected);
}
#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn prop_conservation_holds_after_all_ops() {
let mut engine = RiskEngine::new(zero_fee_params());
let idx = engine.add_user(0).unwrap();
let dep: u32 = kani::any();
kani::assume(dep > 0 && dep <= 5_000_000);
engine.deposit(idx, dep as u128, DEFAULT_ORACLE, DEFAULT_SLOT).unwrap();
assert!(engine.check_conservation());
let ins_amt: u32 = kani::any();
kani::assume(ins_amt <= 1_000_000);
engine.top_up_insurance_fund(ins_amt as u128, DEFAULT_SLOT).unwrap();
assert!(engine.check_conservation());
let loss: u32 = kani::any();
kani::assume(loss <= dep);
engine.set_pnl(idx as usize, -(loss as i128));
assert!(engine.check_conservation());
let cap_before = engine.accounts[idx as usize].capital.get();
let pnl_abs = if loss > 0 { loss as u128 } else { 0 };
let pay = core::cmp::min(pnl_abs, cap_before);
if pay > 0 {
engine.set_capital(idx as usize, cap_before - pay);
let new_pnl_val = -(loss as i128) + (pay as i128);
engine.set_pnl(idx as usize, new_pnl_val);
}
assert!(engine.check_conservation());
}
// ============================================================================
// set_pnl proofs from kani.rs
// ============================================================================
#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
#[kani::should_panic]
fn proof_set_pnl_rejects_i128_min() {
let mut engine = RiskEngine::new(zero_fee_params());
let idx = engine.add_user(0).unwrap();
engine.set_pnl(idx as usize, i128::MIN);
}
#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn proof_set_pnl_maintains_pnl_pos_tot() {
let mut engine = RiskEngine::new(zero_fee_params());
let idx = engine.add_user(0).unwrap();
let pnl1: i32 = kani::any();
kani::assume(pnl1 > i32::MIN);
engine.set_pnl(idx as usize, pnl1 as i128);
let expected1 = if pnl1 > 0 { pnl1 as u128 } else { 0u128 };
assert!(engine.pnl_pos_tot == expected1);
let pnl2: i32 = kani::any();
kani::assume(pnl2 > i32::MIN);
engine.set_pnl(idx as usize, pnl2 as i128);
let expected2 = if pnl2 > 0 { pnl2 as u128 } else { 0u128 };
assert!(engine.pnl_pos_tot == expected2);
}
#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn proof_set_pnl_underflow_safety() {
let mut engine = RiskEngine::new(zero_fee_params());
let idx = engine.add_user(0).unwrap();
engine.set_pnl(idx as usize, 1000i128);
assert!(engine.pnl_pos_tot == 1000u128);
engine.set_pnl(idx as usize, -500i128);
assert!(engine.pnl_pos_tot == 0u128);
engine.set_pnl(idx as usize, 0i128);
assert!(engine.pnl_pos_tot == 0u128);
}
#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn proof_set_pnl_clamps_reserved_pnl() {
let mut engine = RiskEngine::new(zero_fee_params());
let idx = engine.add_user(0).unwrap();
// Set PNL to 5000 first → reserved_pnl = 5000 (reserve-first increase)
engine.set_pnl(idx as usize, 5000i128);
assert!(engine.accounts[idx as usize].reserved_pnl == 5000u128);
// Decrease PNL to 3000 → reserve clamped via saturating_sub
engine.set_pnl(idx as usize, 3000i128);
assert!(engine.accounts[idx as usize].reserved_pnl == 3000u128);
// Decrease PNL to -100 → reserve clamped to 0
engine.set_pnl(idx as usize, -100i128);
assert!(engine.accounts[idx as usize].reserved_pnl == 0u128);
}
#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn proof_set_capital_maintains_c_tot() {
let mut engine = RiskEngine::new(zero_fee_params());
let idx = engine.add_user(0).unwrap();
let initial: u32 = kani::any();
kani::assume(initial > 0 && initial <= 1_000_000);
engine.deposit(idx, initial as u128, DEFAULT_ORACLE, DEFAULT_SLOT).unwrap();
assert!(engine.c_tot.get() == engine.accounts[idx as usize].capital.get());
let new_cap: u32 = kani::any();
kani::assume((new_cap as u64) <= (initial as u64) * 2);
engine.set_capital(idx as usize, new_cap as u128);
assert!(engine.c_tot.get() == new_cap as u128);
}
// ============================================================================
// check_conservation / haircut from kani.rs
// ============================================================================
#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn proof_check_conservation_basic() {
let mut engine = RiskEngine::new(zero_fee_params());
engine.vault = U128::new(100);
engine.c_tot = U128::new(60);
engine.insurance_fund.balance = U128::new(30);
assert!(engine.check_conservation());
engine.insurance_fund.balance = U128::new(50);
assert!(!engine.check_conservation());
}
#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn proof_haircut_ratio_no_division_by_zero() {
let mut engine = RiskEngine::new(zero_fee_params());
// Empty engine → (1, 1) since pnl_matured_pos_tot == 0
let (num, den) = engine.haircut_ratio();
assert!(num == 1u128);
assert!(den == 1u128);
// Set pnl_matured_pos_tot (v11.21 uses this as denominator, not pnl_pos_tot)
engine.pnl_pos_tot = 1000u128;
engine.pnl_matured_pos_tot = 1000u128;
engine.vault = U128::new(2000);
engine.c_tot = U128::new(500);
engine.insurance_fund.balance = U128::new(300);
let (num2, den2) = engine.haircut_ratio();
assert!(den2 == 1000u128, "denominator must be pnl_matured_pos_tot");
// residual = 2000 - 500 - 300 = 1200 > 1000, so h_num = min(1200, 1000) = 1000
assert!(num2 == 1000u128);
assert!(num2 <= den2);
}
#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn proof_absorb_protocol_loss_respects_floor() {
let mut engine = RiskEngine::new(zero_fee_params());
let floor: u32 = kani::any();
kani::assume(floor <= 10_000);
engine.insurance_floor = floor as u128;
let balance: u32 = kani::any();
kani::assume(balance >= floor && balance <= 100_000);
engine.insurance_fund.balance = U128::new(balance as u128);
let loss: u32 = kani::any();
kani::assume(loss > 0 && loss <= 100_000);
engine.absorb_protocol_loss(loss as u128);
assert!(engine.insurance_fund.balance.get() >= floor as u128);
}
// ============================================================================
// Position / side tracking from kani.rs
// ============================================================================
#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn proof_set_position_basis_q_count_tracking() {
let mut engine = RiskEngine::new(zero_fee_params());
let idx = engine.add_user(0).unwrap();
assert!(engine.stored_pos_count_long == 0);
engine.set_position_basis_q(idx as usize, POS_SCALE as i128);
assert!(engine.stored_pos_count_long == 1);
let neg = -(POS_SCALE as i128);
engine.set_position_basis_q(idx as usize, neg);
assert!(engine.stored_pos_count_long == 0);
assert!(engine.stored_pos_count_short == 1);
engine.set_position_basis_q(idx as usize, 0i128);
assert!(engine.stored_pos_count_short == 0);
assert!(engine.stored_pos_count_long == 0);
}
#[kani::proof]
#[kani::unwind(70)]
#[kani::solver(cadical)]
fn proof_side_mode_gating() {
let mut engine = RiskEngine::new(zero_fee_params());
engine.last_crank_slot = DEFAULT_SLOT;
let a = engine.add_user(0).unwrap();
let b = engine.add_user(0).unwrap();
engine.deposit(a, 5_000_000, DEFAULT_ORACLE, DEFAULT_SLOT).unwrap();
engine.deposit(b, 5_000_000, DEFAULT_ORACLE, DEFAULT_SLOT).unwrap();
engine.side_mode_long = SideMode::DrainOnly;
let size_q = POS_SCALE as i128;
let result = engine.execute_trade(a, b, DEFAULT_ORACLE, DEFAULT_SLOT, size_q, DEFAULT_ORACLE);
assert!(result == Err(RiskError::SideBlocked));
engine.side_mode_long = SideMode::Normal;
engine.side_mode_short = SideMode::ResetPending;
engine.stale_account_count_short = 1;
let neg_size = -(POS_SCALE as i128);
let result2 = engine.execute_trade(a, b, DEFAULT_ORACLE, DEFAULT_SLOT, neg_size, DEFAULT_ORACLE);
assert!(result2 == Err(RiskError::SideBlocked));
}
#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn proof_account_equity_net_nonnegative() {
let mut engine = RiskEngine::new(zero_fee_params());
let a = engine.add_user(0).unwrap();
let b = engine.add_user(0).unwrap();
let cap_a: u16 = kani::any();
kani::assume(cap_a > 0 && cap_a <= 10_000);
let cap_b: u16 = kani::any();
kani::assume(cap_b > 0 && cap_b <= 10_000);
engine.set_capital(a as usize, cap_a as u128);
engine.set_capital(b as usize, cap_b as u128);
// Vault has excess beyond c_tot so Residual > 0 and haircut is non-trivial
let excess: u16 = kani::any();
kani::assume(excess <= 5_000);
let c_tot = (cap_a as u128) + (cap_b as u128);
engine.vault = U128::new(c_tot + (excess as u128));
let pnl_val: i16 = kani::any();
kani::assume(pnl_val as i32 > i16::MIN as i32);
engine.set_pnl(a as usize, pnl_val as i128);
// Set pnl_matured_pos_tot to exercise h < 1 in haircut_ratio (v11.21)
let matured: u16 = kani::any();
kani::assume(matured <= 20_000);
engine.pnl_matured_pos_tot = core::cmp::min(matured as u128, engine.pnl_pos_tot);
// Exercise both positive PnL (haircut path) and negative PnL
let eq = engine.account_equity_net(&engine.accounts[a as usize], DEFAULT_ORACLE);
assert!(eq >= 0,
"flat account equity must be non-negative for any haircut level");
}
#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn proof_effective_pos_q_epoch_mismatch_returns_zero() {
let mut engine = RiskEngine::new(zero_fee_params());
let idx = engine.add_user(0).unwrap();
engine.accounts[idx as usize].position_basis_q = POS_SCALE as i128;
engine.accounts[idx as usize].adl_a_basis = ADL_ONE;
engine.accounts[idx as usize].adl_epoch_snap = 0;
engine.stored_pos_count_long = 1;
engine.adl_epoch_long = 1;
let eff = engine.effective_pos_q(idx as usize);
assert!(eff == 0);
engine.accounts[idx as usize].position_basis_q = -(POS_SCALE as i128);
engine.accounts[idx as usize].adl_epoch_snap = 0;
engine.adl_epoch_short = 1;
let eff2 = engine.effective_pos_q(idx as usize);
assert!(eff2 == 0);
}
#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn proof_effective_pos_q_flat_is_zero() {
let mut engine = RiskEngine::new(zero_fee_params());
let idx = engine.add_user(0).unwrap();
assert!(engine.accounts[idx as usize].position_basis_q == 0);
let eff = engine.effective_pos_q(idx as usize);
assert!(eff == 0);
}
#[kani::proof]
#[kani::unwind(34)]
#[kani::solver(cadical)]
fn proof_attach_effective_position_updates_side_counts() {
let mut engine = RiskEngine::new(zero_fee_params());
let idx = engine.add_user(0).unwrap();
assert!(engine.stored_pos_count_long == 0);
assert!(engine.stored_pos_count_short == 0);
let pos = POS_SCALE as i128;
engine.attach_effective_position(idx as usize, pos);
assert!(engine.stored_pos_count_long == 1);
assert!(engine.stored_pos_count_short == 0);
engine.attach_effective_position(idx as usize, 0i128);
assert!(engine.stored_pos_count_long == 0);
assert!(engine.stored_pos_count_short == 0);
let neg = -(POS_SCALE as i128);
engine.attach_effective_position(idx as usize, neg);
assert!(engine.stored_pos_count_long == 0);
assert!(engine.stored_pos_count_short == 1);
}
// ============================================================================
// NEW: proof_fee_credits_never_i128_min
// ============================================================================
/// fee_debt_u128_checked safely handles all fee_credits values including i128::MIN.
/// Verifies: checked_sub boundary behavior and fee_debt extraction never panics.
/// The settle_maintenance_fee path uses checked_sub which can produce i128::MIN,
/// but fee_debt_u128_checked uses unsigned_abs() which safely returns 2^127.
#[kani::proof]
#[kani::unwind(2)]
#[kani::solver(cadical)]
fn proof_fee_credits_never_i128_min() {
// Part 1: fee_debt_u128_checked is safe for ALL i128 values
let fc: i32 = kani::any();
let debt = fee_debt_u128_checked(fc as i128);
if fc < 0 {
assert!(debt == (fc as i128).unsigned_abs());
} else {
assert!(debt == 0);
}
// Part 2: checked_sub boundary — if fee_credits - due overflows, it returns None
let credits: i32 = kani::any();
let due: u16 = kani::any();
kani::assume(due > 0);
let due_i128: i128 = due as i128;
let result = (credits as i128).checked_sub(due_i128);
match result {
Some(new_fc) => {
// Didn't overflow — fee_debt_u128_checked must still be safe
let _ = fee_debt_u128_checked(new_fc);
}
None => {
// Overflow — implementation would return Err(Overflow)
}
}
}
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis. | Stars: 472k | Updated | Claude CodeCodex | Verified | Install |
| diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness. | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is available | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |