Let a run revise its own configuration, within bounds

AGENTS.md

@@ -25,6 +25,8 @@ code:
 - [`workspace-and-ledgers.md`](docs/specs/workspace-and-ledgers.md) — what a run
   writes down and where
 - [`budget.md`](docs/specs/budget.md) — the limits every run carries
+- [`adaptation.md`](docs/specs/adaptation.md) — what a run may revise about
+  itself mid-run, who may propose it, and what bounds it
 - [`observability.md`](docs/specs/observability.md) — the events a run emits
 - [`prior-art.md`](docs/specs/prior-art.md) — the evidence each default rests
   on, what the record contradicts, and what it does not settle; its sources are

Cargo.toml

@@ -20,7 +20,11 @@ exclude = ["vendor", "worktrees"]
 [workspace.package]
 version = "0.2.1"
 edition = "2024"
-rust-version = "1.88"
+# The floor every optional feature must clear too: the MSRV CI job builds
+# `--all-features`, and `vendor/tinyagents` (behind the `tinyagents` feature)
+# uses `if let` guards, stable since 1.95 and rejected as experimental below
+# it. A lower number here would be a number the CI job itself disproves.
+rust-version = "1.95"
 license = "GPL-3.0-only"
 repository = "https://github.com/tinyhumansai/tinyloops"
 

README.md

@@ -179,6 +179,13 @@ the reference seams, drives it to a terminal state, and prints every pass
 boundary, every step, every arm, the merge, the verdict, and the route each pass
 took with the counters it was taken on.
 
+`tuned_research_loop` is the same loop with a third arm that may revise the
+run's own configuration — its thresholds, its spend, and which arms it is still
+paying for — within the room its preset declares. Every revision and every
+refusal is an event and a line in the report; nothing here scores them, because
+scoring a configuration against outcomes spans runs and lives in
+`tinyflows-adaptive`.
+
 Every example runs against TinyFlows' mock capabilities or the reference
 implementations, so they are deterministic, offline, and need no provider
 credentials. `tinyagents` is optional: the harness example declares

crates/tinyloops/examples/research_loop.rs

@@ -88,7 +88,7 @@ fn main() -> Result<(), Error> {
     )?;
 
     println!("preset:    {}", assembled.preset());
-    println!("stuck at:  {}", assembled.thresholds().stuck);
+    println!("stuck at:  {}", assembled.profile().thresholds.stuck);
     println!("signature: {}\n", assembled.signature()?.as_str());
 
     // A recorder over the console sink: one line per event, in one ordered

crates/tinyloops/src/arm/mod.rs

@@ -55,7 +55,7 @@
 
 mod types;
 
-pub use types::{Arm, ArmOutcome, ArmSet, Edge};
+pub use types::{Arm, ArmOutcome, ArmSet, Edge, Tuner, TunerArm};
 
 use crate::state::LoopState;
 use crate::{Error, Result};

crates/tinyloops/src/arm/test.rs

@@ -484,3 +484,142 @@ fn debug_rendering_names_the_declared_arms() {
     assert!(rendered.contains("judge"));
     assert!(format!("{:?}", Edge::new("attempt", "judge")).contains("attempt"));
 }
+
+/// A tuner that proposes whatever it was constructed with.
+#[derive(Debug)]
+struct Fixed {
+    name: &'static str,
+    change: Option<crate::policy::Change>,
+}
+
+impl crate::arm::Tuner for Fixed {
+    fn name(&self) -> &'static str {
+        self.name
+    }
+
+    fn propose(
+        &self,
+        _base: &LoopState,
+        _report: &Value,
+        ctx: StepContext<'_, NoWrite>,
+    ) -> Result<Option<crate::policy::Amendment>> {
+        Ok(self
+            .change
+            .clone()
+            .map(|change| crate::policy::Amendment::new(self.name, ctx.pass(), change, "because")))
+    }
+}
+
+fn tuner(name: &'static str, change: Option<crate::policy::Change>) -> Arc<dyn Arm> {
+    Arc::new(crate::arm::TunerArm::new(Arc::new(Fixed { name, change })))
+}
+
+#[test]
+fn two_tuners_in_one_arm_set_are_refused_by_name() {
+    // The same shape as the second concluding arm, and for the same reason:
+    // two proposers means the profile a pass folds depends on which finished
+    // first, which is arrival order deciding the run's configuration.
+    let error = ArmSet::new(vec![tuner("tune", None), tuner("also_tune", None)])
+        .expect_err("two tuners are refused");
+
+    assert_eq!(
+        error,
+        Error::AmbiguousTuning {
+            first: "tune",
+            second: "also_tune",
+        }
+    );
+}
+
+#[test]
+fn a_set_names_its_tuner_and_a_set_without_one_names_nobody() {
+    let tuned = ArmSet::new(vec![tuner("tune", None)]).expect("one tuner is a valid set");
+    assert_eq!(tuned.tuning(), Some("tune"));
+    assert!(tuned.concluding().is_none());
+}
+
+#[test]
+fn a_tuner_that_proposes_nothing_folds_as_unchanged() {
+    let base = LoopState::new("goal");
+    let arm = tuner("tune", None);
+    let thresholds = crate::Thresholds::default();
+
+    let outcome = arm
+        .evaluate(&base, &Value::Null, StepContext::observing(0, &thresholds))
+        .expect("a tuner that declines still returns");
+
+    assert_eq!(outcome.state, base);
+    assert!(outcome.contribution.is_empty());
+    assert!(outcome.state.proposed().is_none());
+}
+
+#[test]
+fn a_tuner_that_proposes_puts_it_where_the_merge_reads_it() {
+    let base = LoopState::new("goal");
+    let change = crate::policy::Change::Threshold {
+        field: crate::policy::ThresholdField::Stuck,
+        to: 3,
+    };
+    let arm = tuner("tune", Some(change.clone()));
+    let thresholds = crate::Thresholds::default();
+
+    let outcome = arm
+        .evaluate(&base, &Value::Null, StepContext::observing(2, &thresholds))
+        .expect("a tuner proposes");
+
+    // Both halves: the claim, for the merge, and the state, for the trip
+    // through the graph. They have to agree or the proposal is dropped at the
+    // barrier with nothing to report it.
+    assert_eq!(
+        outcome.contribution.amendment().map(|a| a.change.clone()),
+        Some(change.clone())
+    );
+    assert_eq!(
+        outcome.state.proposed().map(|a| a.change.clone()),
+        Some(change)
+    );
+    assert_eq!(outcome.state.proposed().map(|a| a.pass), Some(2));
+}
+
+#[test]
+fn merge_refuses_two_arms_proposing_an_amendment() {
+    // The tuner is the only role that *can* propose, but the merge still
+    // arbitrates: exclusive ownership is a property of the fold, not a promise
+    // about who calls it.
+    let base = LoopState::new("goal");
+    let change = crate::policy::Change::Threshold {
+        field: crate::policy::ThresholdField::Stuck,
+        to: 3,
+    };
+    let thresholds = crate::Thresholds::default();
+
+    let first = tuner("tune", Some(change.clone()));
+    let second = tuner("also_tune", Some(change));
+    let outcomes = vec![
+        first
+            .evaluate(&base, &Value::Null, StepContext::observing(0, &thresholds))
+            .unwrap(),
+        second
+            .evaluate(&base, &Value::Null, StepContext::observing(0, &thresholds))
+            .unwrap(),
+    ];
+
+    let set = ArmSet::new(vec![tuner("tune", None)]).unwrap();
+    let deltas: Vec<_> = outcomes
+        .iter()
+        .map(|outcome| outcome.state.delta_from(&base))
+        .collect();
+    let contributions: Vec<_> = outcomes
+        .into_iter()
+        .map(|outcome| outcome.contribution)
+        .collect();
+    let _ = set;
+
+    assert!(matches!(
+        base.merge(&deltas, &contributions),
+        Err(Error::ContestedField {
+            field: "amendment",
+            ..
+        })
+    ));
+}