From 84e028bb4791bafd553de5a724b8aabbcf772025 Mon Sep 17 00:00:00 2001
From: Amy Liffey <amy.liffey@hes-so.ch>
Date: Wed, 1 Jul 2026 16:58:16 +0200
Subject: [PATCH 01/25] chore: new test

---
 build.xml                            |   1 +
 src/example/README.md                | 104 +++++++++++++++++++++++++++
 src/example/SionMobilityOption.java  |  56 +++++++++++++++
 src/example/SionTIBDecision.java     |  98 +++++++++++++++++++++++++
 src/example/SionTask.java            |  15 ++++
 src/example/SionToSierreExample.java |  74 +++++++++++++++++++
 test/example/SionToSierreTest.java   |  75 +++++++++++++++++++
 7 files changed, 423 insertions(+)
 create mode 100644 src/example/README.md
 create mode 100644 src/example/SionMobilityOption.java
 create mode 100644 src/example/SionTIBDecision.java
 create mode 100644 src/example/SionTask.java
 create mode 100644 src/example/SionToSierreExample.java
 create mode 100644 test/example/SionToSierreTest.java

diff --git a/build.xml b/build.xml
index a29a380..043935d 100644
--- a/build.xml
+++ b/build.xml
@@ -385,6 +385,7 @@
         <junit fork="yes" printsummary="yes">
             <formatter type="xml"/>
             <test name="beddem_simulator.ContextTest" todir="${junit.output.dir}"/>
+            <test name="example.SionToSierreTest" todir="${junit.output.dir}"/>
             <jvmarg line="-ea"/>
             <classpath refid="run.Test.classpath"/>
         </junit>
diff --git a/src/example/README.md b/src/example/README.md
new file mode 100644
index 0000000..579f6f9
--- /dev/null
+++ b/src/example/README.md
@@ -0,0 +1,104 @@
+# Sion → Sierre worked example (TIB)
+
+A minimal, self-contained worked example of Triandis' Theory of Interpersonal
+Behaviour (TIB) running on beddem_simulator's own decision engine
+(`framework.agent.reasoning.*`). It reproduces the running example from the
+BedDeM paper (Table 1): an **18 km trip from Sion to Sierre** with three modes —
+**car, train, bike**.
+
+Unlike `StandardDummyAgent` (where only *time* and *cost* are implemented and
+the other determinants are stubbed), every TIB determinant here has a real
+value, so **all input weights influence the outcome**.
+
+## Files
+
+| File | Role |
+|------|------|
+| `SionMobilityOption.java` | one mobility alternative + its 8 determinant inputs |
+| `SionTIBDecision.java` | TIB decision component wiring all determinants onto the engine |
+| `SionToSierreExample.java` | builds the Table 1 scenario; has a `main()` and `euByService()` |
+| `SionTask.java` | minimal task to satisfy the framework contract |
+| `../../test/example/SionToSierreTest.java` | the JUnit 4 test |
+
+## Cost semantics (lower = better)
+
+Every determinant is expressed as a **cost**: a lower value means a more
+preferred option (price in CHF, time in hours, and ranks 1 = best … 3 = worst
+for norm/role/self/comfort). The engine normalises and weights these up the TIB
+tree, and the agent chooses the option with the **lowest** aggregated expected
+utility (EU). This matches beddem_simulator's own `pickBestOpt`, which selects
+the minimum.
+
+Expected EU (paper Table 1):
+
+| Mode | EU (lower = better) |
+|------|---------------------|
+| **Car**  | **≈ 1.13**  ← chosen |
+| Train | ≈ 3.07 |
+| Bike  | ≈ 4.81 |
+
+Ranking: **Car < Train < Bike**, so the agent picks the **car**.
+
+## How to run the test
+
+### Option A — standalone, no Repast (quickest)
+
+The example depends only on `framework.*` + `example.*` and JUnit 4, so it
+compiles without Repast/Eclipse. From the repository root:
+
+```bash
+# Point these at a working JDK and a JUnit 4 jar (+ hamcrest).
+# JUnit 4.13.2 and hamcrest ship with the Repast/Eclipse plugins, e.g.:
+#   org.junit_4.13.2.v20230809-1000.jar, org.hamcrest.core_2.2.0*.jar
+JUNIT=/path/to/junit-4.13.2.jar
+HAMCREST=/path/to/hamcrest-core.jar
+
+mkdir -p out
+# compile the engine, the example, and the test
+javac -d out \
+  $(find src/framework src/example -name '*.java') \
+  -cp "$JUNIT:$HAMCREST" test/example/SionToSierreTest.java
+
+# run the JUnit 4 test
+java -cp "out:$JUNIT:$HAMCREST" org.junit.runner.JUnitCore example.SionToSierreTest
+
+# or just print the EU table without JUnit:
+java -cp out example.SionToSierreExample
+```
+
+Expected `main()` output:
+
+```
+=== Sion -> Sierre (18 km) | EU, lower = better ===
+  Car    EU = 1.1268
+  Train  EU = 3.0675
+  Bike   EU = 4.8056
+Chosen (lowest EU): Car
+```
+
+(EU values are shown to 4 dp; the test asserts them to ±0.05.)
+
+### Option B — with ant / Repast (the CI pipeline)
+
+The test is registered in `build.xml`'s `run-test` target, so it runs with the
+existing pipeline. This path compiles the whole project, so it needs Repast
+Simphony + Eclipse configured (see the top-level `README.md`):
+
+```bash
+ant build   "-DECLIPSE_HOME=/path/to/eclipse"
+ant run-test "-DECLIPSE_HOME=/path/to/eclipse"
+```
+
+Results are written as JUnit XML under `junit/`.
+
+### Option C — Eclipse
+
+Right-click `test/example/SionToSierreTest.java` → **Run As → JUnit Test**.
+
+## What the test checks
+
+- all three modes are evaluated;
+- the agent picks the option with the **lowest** EU (car);
+- the ranking is **Car < Train < Bike**;
+- the EU values match the paper's Table 1 (±0.05);
+- all EU values are positive and finite.
diff --git a/src/example/SionMobilityOption.java b/src/example/SionMobilityOption.java
new file mode 100644
index 0000000..d4c857c
--- /dev/null
+++ b/src/example/SionMobilityOption.java
@@ -0,0 +1,56 @@
+package example;
+
+import framework.concept.Option;
+
+/**
+ * A single mobility alternative for the Sion -> Sierre worked example
+ * (BedDeM paper, Table 1). It carries the raw determinant inputs for one
+ * transport mode.
+ *
+ * <p>All values follow the engine's cost convention: <b>lower = more
+ * preferred</b>. Ranks (norm/role/self/comfort) use 1 = best .. 3 = worst;
+ * price is in CHF, time in hours, frequency and facilitating are the raw
+ * Table 1 values. This keeps the whole example internally consistent with
+ * beddem_simulator's selection rule, which picks the option with the lowest
+ * aggregated expected utility.</p>
+ */
+public class SionMobilityOption implements Option {
+
+	private final String service;
+	private final double price;         // CHF, lower = cheaper = better
+	private final double time;          // hours, lower = faster = better
+	private final double norm;          // social-norm rank, 1 = best
+	private final double role;          // environmental rank, 1 = greenest = best
+	private final double selfConcept;   // identity rank, 1 = best
+	private final double comfort;       // (dis)comfort rank, 1 = best
+	private final double freq;          // habit, lower = more habitual = better
+	private final double facilitating;  // ease of access, lower = easier = better
+
+	public SionMobilityOption(String service, double price, double time, double norm, double role, double selfConcept,
+			double comfort, double freq, double facilitating) {
+		this.service = service;
+		this.price = price;
+		this.time = time;
+		this.norm = norm;
+		this.role = role;
+		this.selfConcept = selfConcept;
+		this.comfort = comfort;
+		this.freq = freq;
+		this.facilitating = facilitating;
+	}
+
+	public String getService()      { return this.service; }
+	public double getPrice()        { return this.price; }
+	public double getTime()         { return this.time; }
+	public double getNorm()         { return this.norm; }
+	public double getRole()         { return this.role; }
+	public double getSelfConcept()  { return this.selfConcept; }
+	public double getComfort()      { return this.comfort; }
+	public double getFreq()         { return this.freq; }
+	public double getFacilitating() { return this.facilitating; }
+
+	@Override
+	public String toString() {
+		return this.service;
+	}
+}
diff --git a/src/example/SionTIBDecision.java b/src/example/SionTIBDecision.java
new file mode 100644
index 0000000..88fbdf3
--- /dev/null
+++ b/src/example/SionTIBDecision.java
@@ -0,0 +1,98 @@
+package example;
+
+import java.util.Map;
+import java.util.Set;
+
+import framework.agent.core.DecisionComponent;
+import framework.agent.reasoning.Determinant;
+import framework.agent.reasoning.LeafDeterminant;
+import framework.agent.reasoning.ParentDeterminant;
+import framework.agent.reasoning.TIBModel;
+import framework.concept.Option;
+import framework.concept.Task;
+
+/**
+ * TIB decision component for the Sion -> Sierre worked example, built on
+ * beddem_simulator's own reasoning engine ({@link TIBModel} /
+ * {@link ParentDeterminant} / {@link LeafDeterminant}).
+ *
+ * <p>Unlike {@code StandardDummyAgent} (where only time and cost were
+ * implemented and the other determinants were stubbed), every TIB determinant
+ * here has a real ranking function, so all input weights influence the
+ * outcome. Each leaf returns a cost-like value where <b>lower = better</b>;
+ * the engine normalises and weights these up the tree, and the option with the
+ * lowest aggregated expected utility is the preferred one.</p>
+ *
+ * <p>Scenario data and weights come from the BedDeM paper, Table 1 (an 18 km
+ * trip from Sion to Sierre with three modes: car, train, bike).</p>
+ */
+public class SionTIBDecision extends TIBModel implements DecisionComponent {
+
+	public SionTIBDecision(Determinant belief, Determinant evaluation, Determinant norm, Determinant role,
+			Determinant selfConcept, Determinant emotion, Determinant facilitatingCond, Determinant freq,
+			double attitudeWeight, double socialWeight, double affectWeight, double intentionWeight,
+			double habitWeight) {
+		super(belief, evaluation, norm, role, selfConcept, emotion, facilitatingCond, freq, attitudeWeight, socialWeight,
+				affectWeight, intentionWeight, habitWeight);
+	}
+
+	@Override
+	public Map<Double, Set<Option>> evaluateOptions(Set<Option> options, Task task) {
+		// Return the root-level TIB aggregation (expected utility per option).
+		// We use the raw aggregate rather than the extra top-level normalisation
+		// that rankOptions applies, so the numbers reproduce the paper's Table 1
+		// EU values (Car ~1.13, Train ~3.07, Bike ~4.81). The chosen option
+		// (lowest EU) is identical either way, since normalisation is monotonic.
+		return evalOpts(options, task);
+	}
+
+	/**
+	 * Assemble a fully-wired TIB decision component from the Table 1 weights.
+	 *
+	 * @param evaluationWeight weight of the "evaluation" node grouping price and time
+	 */
+	public static SionTIBDecision build(double priceWeight, double timeWeight, double normWeight, double roleWeight,
+			double selfConceptWeight, double emotionWeight, double facilitatingWeight, double freqWeight,
+			double evaluationWeight, double attitudeWeight, double socialWeight, double affectWeight,
+			double intentionWeight, double habitWeight) {
+
+		ParentDeterminant evaluation = new ParentDeterminant("evaluation", evaluationWeight);
+		evaluation.addDeterminantChild(leaf("price", priceWeight));
+		evaluation.addDeterminantChild(leaf("time", timeWeight));
+
+		Determinant belief = null; // not used in the Table 1 example
+		Determinant norm = leaf("norm", normWeight);
+		Determinant role = leaf("role", roleWeight);
+		Determinant selfConcept = leaf("self", selfConceptWeight);
+		Determinant emotion = leaf("emotion", emotionWeight);
+		Determinant facilitating = leaf("facilitating", facilitatingWeight);
+		Determinant freq = leaf("freq", freqWeight);
+
+		return new SionTIBDecision(belief, evaluation, norm, role, selfConcept, emotion, facilitating, freq,
+				attitudeWeight, socialWeight, affectWeight, intentionWeight, habitWeight);
+	}
+
+	/**
+	 * One leaf determinant. Reads the matching cost-like value from the option
+	 * (lower = better in every case).
+	 */
+	private static LeafDeterminant leaf(final String id, double weight) {
+		return new LeafDeterminant(id, weight) {
+			@Override
+			protected double evalOpt(Option opt, Task task) {
+				SionMobilityOption o = (SionMobilityOption) opt;
+				switch (id) {
+				case "price":        return o.getPrice();
+				case "time":         return o.getTime();
+				case "norm":         return o.getNorm();
+				case "role":         return o.getRole();
+				case "self":         return o.getSelfConcept();
+				case "emotion":      return o.getComfort();
+				case "facilitating": return o.getFacilitating();
+				case "freq":         return o.getFreq();
+				default:             return 0.0;
+				}
+			}
+		};
+	}
+}
diff --git a/src/example/SionTask.java b/src/example/SionTask.java
new file mode 100644
index 0000000..64b48a1
--- /dev/null
+++ b/src/example/SionTask.java
@@ -0,0 +1,15 @@
+package example;
+
+import framework.concept.Task;
+
+/**
+ * Minimal task for the Sion -> Sierre worked example. The determinant
+ * functions in {@link SionTIBDecision} read all they need from the option
+ * itself, so this task only needs to satisfy the framework's Task contract.
+ */
+public class SionTask extends Task {
+
+	public SionTask() {
+		super(0.0);
+	}
+}
diff --git a/src/example/SionToSierreExample.java b/src/example/SionToSierreExample.java
new file mode 100644
index 0000000..ec1d7b1
--- /dev/null
+++ b/src/example/SionToSierreExample.java
@@ -0,0 +1,74 @@
+package example;
+
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import framework.concept.Option;
+
+/**
+ * Runnable worked example: an 18 km trip from Sion to Sierre with three modes
+ * (car, train, bike), using the weights and determinant values of the BedDeM
+ * paper, Table 1, evaluated through beddem_simulator's own TIB engine.
+ *
+ * <p>Every determinant uses the cost convention (lower = better) and the agent
+ * prefers the option with the lowest aggregated expected utility (EU).</p>
+ *
+ * <p>Run: {@code java example.SionToSierreExample}</p>
+ */
+public class SionToSierreExample {
+
+	/** Build the three Table 1 options. */
+	public static Set<Option> scenarioOptions() {
+		Set<Option> options = new HashSet<Option>();
+		//                                 service  price time norm role self comfort freq facil
+		options.add(new SionMobilityOption("Car",   4.0, 0.3,  2,   3,   1,   1,      0,   0));
+		options.add(new SionMobilityOption("Train", 3.0, 0.2,  1,   2,   2,   2,      0,   1));
+		options.add(new SionMobilityOption("Bike",  0.0, 1.0,  3,   1,   3,   3,      1,   0));
+		return options;
+	}
+
+	/** Build the decision component with the Table 1 weights. */
+	public static SionTIBDecision scenarioDecision() {
+		return SionTIBDecision.build(
+				2,  // price
+				4,  // time
+				3,  // norm
+				2,  // role
+				3,  // self-concept
+				1,  // emotion / enjoyment
+				2,  // facilitating
+				3,  // freq / habit
+				1,  // evaluation node
+				4,  // attitude
+				2,  // social
+				2,  // affect
+				4,  // intention
+				3); // habit
+	}
+
+	/** Map each option's service name to its aggregated EU (lower = better). */
+	public static Map<String, Double> euByService() {
+		Map<Double, Set<Option>> result = scenarioDecision().evaluateOptions(scenarioOptions(), new SionTask());
+		java.util.Map<String, Double> eu = new java.util.HashMap<String, Double>();
+		for (Map.Entry<Double, Set<Option>> entry : result.entrySet()) {
+			for (Option opt : entry.getValue()) {
+				eu.put(((SionMobilityOption) opt).getService(), entry.getKey());
+			}
+		}
+		return eu;
+	}
+
+	public static void main(String[] args) {
+		Map<String, Double> eu = euByService();
+		String winner = null;
+		double best = Double.POSITIVE_INFINITY;
+		System.out.println("=== Sion -> Sierre (18 km) | EU, lower = better ===");
+		for (String mode : new String[] { "Car", "Train", "Bike" }) {
+			double v = eu.get(mode);
+			System.out.printf(java.util.Locale.US, "  %-6s EU = %.4f%n", mode, v);
+			if (v < best) { best = v; winner = mode; }
+		}
+		System.out.println("Chosen (lowest EU): " + winner);
+	}
+}
diff --git a/test/example/SionToSierreTest.java b/test/example/SionToSierreTest.java
new file mode 100644
index 0000000..7f5dec5
--- /dev/null
+++ b/test/example/SionToSierreTest.java
@@ -0,0 +1,75 @@
+package example;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Map;
+
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * Worked-example test: an 18 km trip from Sion to Sierre with three modes
+ * (car, train, bike), using the weights and determinant values of the BedDeM
+ * paper, Table 1, evaluated through beddem_simulator's own TIB engine
+ * ({@link SionTIBDecision}).
+ *
+ * <p>The engine uses cost semantics: every determinant is expressed so that a
+ * <b>lower value is more preferred</b>, and the agent chooses the option with
+ * the <b>lowest</b> aggregated expected utility (EU). Under the Table 1 inputs
+ * the ranking is Car &lt; Train &lt; Bike, so the agent picks the car.</p>
+ */
+public class SionToSierreTest {
+
+	// Expected EU from the paper, Table 1 (lower = better).
+	private static final double EXPECTED_CAR = 1.13;
+	private static final double EXPECTED_TRAIN = 3.07;
+	private static final double EXPECTED_BIKE = 4.81;
+	private static final double TOLERANCE = 0.05;
+
+	private Map<String, Double> eu;
+
+	@Before
+	public void setUp() {
+		eu = SionToSierreExample.euByService();
+	}
+
+	@Test
+	public void allThreeOptionsAreEvaluated() {
+		assertEquals("Three modes should be evaluated", 3, eu.size());
+	}
+
+	@Test
+	public void agentPicksLowestEuOption() {
+		String winner = null;
+		double best = Double.POSITIVE_INFINITY;
+		for (Map.Entry<String, Double> e : eu.entrySet()) {
+			if (e.getValue() < best) {
+				best = e.getValue();
+				winner = e.getKey();
+			}
+		}
+		assertEquals("Car has the lowest aggregated EU and is chosen", "Car", winner);
+	}
+
+	@Test
+	public void rankingIsCarThenTrainThenBike() {
+		assertTrue("Car should be preferred over Train (lower EU)", eu.get("Car") < eu.get("Train"));
+		assertTrue("Train should be preferred over Bike (lower EU)", eu.get("Train") < eu.get("Bike"));
+	}
+
+	@Test
+	public void euMatchesPaperTable1() {
+		assertEquals("Car EU", EXPECTED_CAR, eu.get("Car"), TOLERANCE);
+		assertEquals("Train EU", EXPECTED_TRAIN, eu.get("Train"), TOLERANCE);
+		assertEquals("Bike EU", EXPECTED_BIKE, eu.get("Bike"), TOLERANCE);
+	}
+
+	@Test
+	public void allEuValuesArePositiveAndFinite() {
+		for (double v : eu.values()) {
+			assertTrue("EU should be finite", Double.isFinite(v));
+			assertTrue("EU should be positive", v > 0);
+		}
+	}
+}

From 9d4045f542d3487f3049a4ec4305a70d71804fcf Mon Sep 17 00:00:00 2001
From: Amy Liffey <amy.liffey@hes-so.ch>
Date: Wed, 1 Jul 2026 17:20:29 +0200
Subject: [PATCH 02/25] docs: adjust readme

---
 src/example/README.md | 66 +++++++++++++++++++++++--------------------
 1 file changed, 36 insertions(+), 30 deletions(-)

diff --git a/src/example/README.md b/src/example/README.md
index 579f6f9..f2fa0fd 100644
--- a/src/example/README.md
+++ b/src/example/README.md
@@ -39,59 +39,65 @@ Expected EU (paper Table 1):
 
 Ranking: **Car < Train < Bike**, so the agent picks the **car**.
 
-## How to run the test
+## How to run
 
-### Option A — standalone, no Repast (quickest)
+The example depends only on `framework.*` + `example.*` (and JUnit 4 for the
+test), so it compiles and runs **without Repast/Eclipse**. Run all commands
+from the repository root.
 
-The example depends only on `framework.*` + `example.*` and JUnit 4, so it
-compiles without Repast/Eclipse. From the repository root:
+### 1. Run the example (prints the EU table, no JUnit needed)
 
 ```bash
-# Point these at a working JDK and a JUnit 4 jar (+ hamcrest).
-# JUnit 4.13.2 and hamcrest ship with the Repast/Eclipse plugins, e.g.:
-#   org.junit_4.13.2.v20230809-1000.jar, org.hamcrest.core_2.2.0*.jar
-JUNIT=/path/to/junit-4.13.2.jar
-HAMCREST=/path/to/hamcrest-core.jar
-
 mkdir -p out
-# compile the engine, the example, and the test
-javac -d out \
-  $(find src/framework src/example -name '*.java') \
-  -cp "$JUNIT:$HAMCREST" test/example/SionToSierreTest.java
-
-# run the JUnit 4 test
-java -cp "out:$JUNIT:$HAMCREST" org.junit.runner.JUnitCore example.SionToSierreTest
-
-# or just print the EU table without JUnit:
-java -cp out example.SionToSierreExample
+javac -d out $(find src/framework src/example -name '*.java')
+java  -cp out example.SionToSierreExample
 ```
 
-Expected `main()` output:
+Expected output (EU ≈, computed by the engine):
 
 ```
 === Sion -> Sierre (18 km) | EU, lower = better ===
-  Car    EU = 1.1268
-  Train  EU = 3.0675
-  Bike   EU = 4.8056
+  Car    EU ≈ 1.13
+  Train  EU ≈ 3.07
+  Bike   EU ≈ 4.81
 Chosen (lowest EU): Car
 ```
 
-(EU values are shown to 4 dp; the test asserts them to ±0.05.)
+### 2. Run the JUnit test
+
+Standalone — needs a JUnit 4 jar + hamcrest (both ship with the Repast/Eclipse
+plugins, e.g. `org.junit_4.13.2.v20230809-1000.jar`,
+`org.hamcrest.core_2.2.0*.jar`):
+
+```bash
+JUNIT=/path/to/junit-4.13.2.jar
+HAMCREST=/path/to/hamcrest-core.jar
+
+mkdir -p out
+javac -d out $(find src/framework src/example -name '*.java') \
+  -cp "$JUNIT:$HAMCREST" test/example/SionToSierreTest.java
+
+java -cp "out:$JUNIT:$HAMCREST" org.junit.runner.JUnitCore example.SionToSierreTest
+```
+
+A passing run prints `OK (5 tests)`. The test asserts the paper EU values to
+±0.05.
 
-### Option B — with ant / Repast (the CI pipeline)
+### 3. Run inside the full build / CI (ant + Repast)
 
 The test is registered in `build.xml`'s `run-test` target, so it runs with the
-existing pipeline. This path compiles the whole project, so it needs Repast
+existing pipeline. This path compiles the whole project and needs Repast
 Simphony + Eclipse configured (see the top-level `README.md`):
 
 ```bash
-ant build   "-DECLIPSE_HOME=/path/to/eclipse"
+ant build    "-DECLIPSE_HOME=/path/to/eclipse"
 ant run-test "-DECLIPSE_HOME=/path/to/eclipse"
 ```
 
-Results are written as JUnit XML under `junit/`.
+Results are written as JUnit XML under `junit/`. In GitHub Actions this runs
+automatically on pull requests to `master`.
 
-### Option C — Eclipse
+### 4. Eclipse
 
 Right-click `test/example/SionToSierreTest.java` → **Run As → JUnit Test**.
 

From 1c4ca7b1c29ce1142c0b587b0e21b6bc4c30ae45 Mon Sep 17 00:00:00 2001
From: Amy Liffey <amy.liffey@hes-so.ch>
Date: Wed, 1 Jul 2026 17:50:43 +0200
Subject: [PATCH 03/25] chore: results

---
 .github/workflows/ant.yml | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/.github/workflows/ant.yml b/.github/workflows/ant.yml
index cfbcf97..edd56ea 100644
--- a/.github/workflows/ant.yml
+++ b/.github/workflows/ant.yml
@@ -14,6 +14,12 @@ jobs:
 
     runs-on: ubuntu-latest
 
+    # Needed so the test-results step can post a check + comment on the PR.
+    permissions:
+      checks: write
+      pull-requests: write
+      contents: read
+
     steps:
     - uses: actions/checkout@v4
     - name: Set up JDK 11
@@ -33,7 +39,14 @@ jobs:
         ant junitreport
     - name: Publish Test Results
       uses: EnricoMi/publish-unit-test-result-action@v2
+      if: always()          # publish even when a test fails
       with:
         files: |
           junit/**/*.xml
+    - name: Upload JUnit report
+      uses: actions/upload-artifact@v4
+      if: always()          # keep the HTML/XML report even on failure
+      with:
+        name: junit-report
+        path: junit/
 

From 74aa490446958b4978b80f762c463533106eb90f Mon Sep 17 00:00:00 2001
From: Amy Liffey <amy.liffey@hes-so.ch>
Date: Wed, 1 Jul 2026 21:15:32 +0200
Subject: [PATCH 04/25] chore: pr

---
 .github/workflows/ant.yml | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/.github/workflows/ant.yml b/.github/workflows/ant.yml
index edd56ea..d039101 100644
--- a/.github/workflows/ant.yml
+++ b/.github/workflows/ant.yml
@@ -43,6 +43,9 @@ jobs:
       with:
         files: |
           junit/**/*.xml
+        check_name: "Test Results"
+        comment_mode: always        # always post/update a comment on the PR
+        comment_title: "BedDeM test results"
     - name: Upload JUnit report
       uses: actions/upload-artifact@v4
       if: always()          # keep the HTML/XML report even on failure

From 5cf22c3358d86334a152e0c51f819f39c1f300d3 Mon Sep 17 00:00:00 2001
From: Amy Liffey <amy.liffey@hes-so.ch>
Date: Thu, 2 Jul 2026 12:39:40 +0200
Subject: [PATCH 05/25] docs: reword

---
 src/example/README.md | 115 +++++++++---------------------------------
 1 file changed, 25 insertions(+), 90 deletions(-)

diff --git a/src/example/README.md b/src/example/README.md
index f2fa0fd..b5ce925 100644
--- a/src/example/README.md
+++ b/src/example/README.md
@@ -1,110 +1,45 @@
 # Sion → Sierre worked example (TIB)
 
-A minimal, self-contained worked example of Triandis' Theory of Interpersonal
-Behaviour (TIB) running on beddem_simulator's own decision engine
-(`framework.agent.reasoning.*`). It reproduces the running example from the
-BedDeM paper (Table 1): an **18 km trip from Sion to Sierre** with three modes —
-**car, train, bike**.
+A self-contained worked example of Triandis' Theory of Interpersonal Behaviour
+(TIB) on beddem_simulator's own decision engine. It reproduces the BedDeM paper
+(Table 1): an **18 km trip from Sion to Sierre** with three modes — car, train,
+bike. Unlike `StandardDummyAgent` (only *time*/*cost* implemented), **every
+determinant here has a real value, so all input weights matter**.
 
-Unlike `StandardDummyAgent` (where only *time* and *cost* are implemented and
-the other determinants are stubbed), every TIB determinant here has a real
-value, so **all input weights influence the outcome**.
+## Result
 
-## Files
-
-| File | Role |
-|------|------|
-| `SionMobilityOption.java` | one mobility alternative + its 8 determinant inputs |
-| `SionTIBDecision.java` | TIB decision component wiring all determinants onto the engine |
-| `SionToSierreExample.java` | builds the Table 1 scenario; has a `main()` and `euByService()` |
-| `SionTask.java` | minimal task to satisfy the framework contract |
-| `../../test/example/SionToSierreTest.java` | the JUnit 4 test |
-
-## Cost semantics (lower = better)
-
-Every determinant is expressed as a **cost**: a lower value means a more
-preferred option (price in CHF, time in hours, and ranks 1 = best … 3 = worst
-for norm/role/self/comfort). The engine normalises and weights these up the TIB
-tree, and the agent chooses the option with the **lowest** aggregated expected
-utility (EU). This matches beddem_simulator's own `pickBestOpt`, which selects
-the minimum.
-
-Expected EU (paper Table 1):
+Every determinant is a **cost** (lower = better), and the agent picks the option
+with the lowest aggregated expected utility (EU):
 
 | Mode | EU (lower = better) |
 |------|---------------------|
-| **Car**  | **≈ 1.13**  ← chosen |
+| **Car** | **≈ 1.13** ← chosen |
 | Train | ≈ 3.07 |
-| Bike  | ≈ 4.81 |
-
-Ranking: **Car < Train < Bike**, so the agent picks the **car**.
-
-## How to run
+| Bike | ≈ 4.81 |
 
-The example depends only on `framework.*` + `example.*` (and JUnit 4 for the
-test), so it compiles and runs **without Repast/Eclipse**. Run all commands
-from the repository root.
+## Run it
 
-### 1. Run the example (prints the EU table, no JUnit needed)
+Depends only on `framework.*` + `example.*` (+ JUnit 4 for the test), so it runs
+**without Repast/Eclipse**. From the repo root:
 
 ```bash
 mkdir -p out
 javac -d out $(find src/framework src/example -name '*.java')
-java  -cp out example.SionToSierreExample
-```
-
-Expected output (EU ≈, computed by the engine):
-
-```
-=== Sion -> Sierre (18 km) | EU, lower = better ===
-  Car    EU ≈ 1.13
-  Train  EU ≈ 3.07
-  Bike   EU ≈ 4.81
-Chosen (lowest EU): Car
-```
-
-### 2. Run the JUnit test
 
-Standalone — needs a JUnit 4 jar + hamcrest (both ship with the Repast/Eclipse
-plugins, e.g. `org.junit_4.13.2.v20230809-1000.jar`,
-`org.hamcrest.core_2.2.0*.jar`):
+# print the EU table
+java -cp out example.SionToSierreExample
 
-```bash
-JUNIT=/path/to/junit-4.13.2.jar
-HAMCREST=/path/to/hamcrest-core.jar
-
-mkdir -p out
-javac -d out $(find src/framework src/example -name '*.java') \
-  -cp "$JUNIT:$HAMCREST" test/example/SionToSierreTest.java
-
-java -cp "out:$JUNIT:$HAMCREST" org.junit.runner.JUnitCore example.SionToSierreTest
+# or run the JUnit test (junit + hamcrest ship with the Repast/Eclipse plugins)
+javac -d out -cp junit.jar:hamcrest.jar test/example/SionToSierreTest.java
+java -cp out:junit.jar:hamcrest.jar org.junit.runner.JUnitCore example.SionToSierreTest
 ```
 
-A passing run prints `OK (5 tests)`. The test asserts the paper EU values to
-±0.05.
+In CI the test runs via `build.xml`'s `run-test` target on pull requests to
+`master`; in Eclipse, right-click the test → **Run As → JUnit Test**.
 
-### 3. Run inside the full build / CI (ant + Repast)
-
-The test is registered in `build.xml`'s `run-test` target, so it runs with the
-existing pipeline. This path compiles the whole project and needs Repast
-Simphony + Eclipse configured (see the top-level `README.md`):
-
-```bash
-ant build    "-DECLIPSE_HOME=/path/to/eclipse"
-ant run-test "-DECLIPSE_HOME=/path/to/eclipse"
-```
-
-Results are written as JUnit XML under `junit/`. In GitHub Actions this runs
-automatically on pull requests to `master`.
-
-### 4. Eclipse
-
-Right-click `test/example/SionToSierreTest.java` → **Run As → JUnit Test**.
-
-## What the test checks
+## Files
 
-- all three modes are evaluated;
-- the agent picks the option with the **lowest** EU (car);
-- the ranking is **Car < Train < Bike**;
-- the EU values match the paper's Table 1 (±0.05);
-- all EU values are positive and finite.
+- `SionMobilityOption.java` — one mode + its 8 determinant inputs
+- `SionTIBDecision.java` — wires all determinants onto the TIB engine
+- `SionToSierreExample.java` — builds the scenario (`main()` + `euByService()`)
+- `../../test/example/SionToSierreTest.java` — the JUnit 4 test

From 5c03137625d748d1c9f9d08c666c60a02ba4c24d Mon Sep 17 00:00:00 2001
From: Amy Liffey <amy.liffey@hes-so.ch>
Date: Thu, 2 Jul 2026 12:45:07 +0200
Subject: [PATCH 06/25] docs: reword

---
 README.md | 73 ++++++++++++-------------------------------------------
 1 file changed, 15 insertions(+), 58 deletions(-)

diff --git a/README.md b/README.md
index 3d54222..dda9c61 100644
--- a/README.md
+++ b/README.md
@@ -58,63 +58,22 @@ agentID,start_time,km,vehicle
 ```
 This output corresponds to the `time_weight` set to 5 and `cost_weight` set to 1.
 
-## Project structure
-In this case we have example `<scenario>` called `dummy`. The directory structure:
-* **`src`**
-	- `<scenario>.agent`: specific implementation of all agents for scenario and external inputs for processing
-	   + CommunicationComponent: decision communication
-	   + DecisionComponent: decision determinants definition
-	   + MemoryComponent: memory definition and feelings
-	   + PerceptionComponent: perception component of possibilities
-	   + StandardDummyAgent: definition of the agent and its functions
-	- `<scenario>.concept`: basic concepts used around model such as Task and Option available for agent
-	   + EnvironmentalState: state of the environment and availability
-	   + Feedback: feedback of the environment
-	   + InternalState: state of the environment
-	   + Option: environment options
-	   + Task: one task in the agent schedule with all its constraints
-	   + Vehicle: vehicle definition and properties
-	- `<scenario>.context`: context definitions usually taken from the GlobVariables file
-	   + AgentContext: context definition for agent
-	   + LocationContext: context definition for location
-	- `<scenario>.database`: data retrievers
-	   + CSVReader: reader for csv files
-	- `<scenario>.environment`: definitions of the environment
-	- `<scenario>.report`: contains scenario specific reporter classes.
-		+ Reporter classes: describes how what we want from the model. We can select which method to be run in Repast interface.
-	- `<scenario>.simulator`: contain the Repast controller, scheduler and logger of the project. This is the core function of Repast and you should not modify it. The two simulator classes here are ContextManager (the simulator controller and entry points of the simulator) and ThreadAgentScheduler (schedules the Tasks and execute them).
-		+ ContextManager: describes how the input should be read and can be modified to fit the project. Container of all the agents and locations.
-	- `framework.agent.core`: anything that is related to the agent's operation
-		+ IAgent: the Interface of agent. Contains some methods that an agent should have. 
-		+ DefaultAgent: the standard agent that can be extended depend on the type of project. Its simulator operation is described in the step() method which is controlled by the Scheduler mentioned above.
-		+ StandardTraveller: the class used specific for transportation demand. Contains the logic to evaluate an option. 
-	- `framework.agent.reasoning`: containing the TPB and TIB model and determinant interfaces
-		+ Determinant: standard determinant for evaluation of options
-		+ LeafDeterminant: base determinant node in decision making 
-		+ ParentDeterminant: parent determinant in decision making model defines ranking options
-		+ TIBModel: Triandis decision making model, definition all base determinants according to this model
-		+ TPBModel: Theory of planned behavior model
-	- `framework.concept`: some basic concepts that are used around the model (i.e Task and Option available for the agent). Note that at the moment time is setup as hour and distance is in km. Also some classes that are implemented specifically for transportation demand.
-	    + EnvironmentalState: state of environment
-	    + Feedback: interface definition of feedback
-	    + InternalState: interface for agent state 
-	    + Opinion: interface for agent opinion
-	    + Option: option interface
-	    + Task: task interface
-	- `framework.environment`: information of the environment where the agents reside in. (ex: available transportations, total demand, kms, spending for each mode, etc.).
-	    + Environment: interface for location of the agent its environment
-	- `framework.exception`: all the exceptions and how to handle them.
-	
-* **`data`**
-	- `csv_files`: two scenario example files one with `dummy` prefix and one without. Both are containing schedule for only for next day.
-		+ agents: list of all the agent and their parameters.
-		+ vehicle: list of all available transportation mode and their parameters.
-		+ schedule: list of all the events to be assigned to agents. At the moment, the price point of car is added at the end of the file name (ex: 0.0 mean car_price * 0.0). This is for when we want to run in batch mode where we want to define different price points in the demand curve.
-		+ location: list of all locations with available modes of transport
-	- testing: csv files for modular + system testing, will be generated if you run the testing classes.
-	- beddem_simulator.properties: locations of all the inputs, parameters and outputs of the model.
-* **`your_project_name.rs`**: Define the inputs, outputs, parameters and observers for the model
+## Worked example: Sion → Sierre (TIB)
+A small, self-contained TIB example (no Repast needed) that reproduces the BedDeM paper Table 1: an 18 km trip with three modes. Every determinant is a **cost** (lower = better), so the agent picks the option with the lowest expected utility (EU):
 
+| Mode | EU (lower = better) |
+|------|---------------------|
+| **Car** | **≈ 1.13** ← chosen |
+| Train | ≈ 3.07 |
+| Bike | ≈ 4.81 |
+
+```bash
+mkdir -p out
+javac -d out $(find src/framework src/example -name '*.java')
+java -cp out example.SionToSierreExample
+```
+
+More detail (JUnit test, CI): [`src/example/README.md`](src/example/README.md).
 
 ## Tested with versions
 	- Eclipse: 2024-03
@@ -129,5 +88,3 @@ To enable the debug logging for the BedDeM specific classes add or uncomment in
 ```bash
 log4j.logger.dummy.database.CSVReader = DEBUG, stdout, R
 ```
-Logger levels and the description of log4j architecture can be find [here](https://logging.apache.org/log4j/2.x/manual/architecture.html)
-

From a2223c2e23c085b3930034f6062cbb65de4a37be Mon Sep 17 00:00:00 2001
From: Amy Liffey <amy.liffey@hes-so.ch>
Date: Fri, 3 Jul 2026 16:10:11 +0200
Subject: [PATCH 07/25] feat: unify the example

---
 MessageCenter.log4j.properties            |  4 +
 README.md                                 | 22 ++---
 build.xml                                 |  1 -
 data/agent.csv                            |  5 +-
 data/location.csv                         |  5 +-
 data/schedule.0.csv                       | 10 ++-
 src/dummy/agent/DummyMemoryComponent.java | 12 +++
 src/dummy/agent/StandardDummyAgent.java   | 98 +++++++++++++++++++----
 src/dummy/database/CSVReader.java         |  5 +-
 src/dummy/environment/Location.java       |  8 +-
 src/example/README.md                     | 45 -----------
 src/example/SionMobilityOption.java       | 56 -------------
 src/example/SionTIBDecision.java          | 98 -----------------------
 src/example/SionTask.java                 | 15 ----
 src/example/SionToSierreExample.java      | 74 -----------------
 test/example/SionToSierreTest.java        | 75 -----------------
 16 files changed, 134 insertions(+), 399 deletions(-)
 delete mode 100644 src/example/README.md
 delete mode 100644 src/example/SionMobilityOption.java
 delete mode 100644 src/example/SionTIBDecision.java
 delete mode 100644 src/example/SionTask.java
 delete mode 100644 src/example/SionToSierreExample.java
 delete mode 100644 test/example/SionToSierreTest.java

diff --git a/MessageCenter.log4j.properties b/MessageCenter.log4j.properties
index c5cfa15..de67c67 100644
--- a/MessageCenter.log4j.properties
+++ b/MessageCenter.log4j.properties
@@ -44,6 +44,10 @@ log4j.logger.dummy.database.CSVReader = DEBUG, R
 log4j.logger.framework.agent.core.TaskExecutionAgent = DEBUG, R
 log4j.logger.framework.agent.reasoning.Determinant = DEBUG, R
 
+# Per-determinant TIB scores (norm/role/self/emotion/facilitating/freq + time/cost).
+# Comment this out to silence the determinant traces.
+log4j.logger.dummy.agent.StandardDummyAgent = DEBUG, stdout, R
+
 log4j.appender.R=org.apache.log4j.RollingFileAppender
 log4j.appender.R.File=debug.log
 log4j.appender.R.MaxFileSize=100KB
diff --git a/README.md b/README.md
index dda9c61..b71a14b 100644
--- a/README.md
+++ b/README.md
@@ -58,22 +58,16 @@ agentID,start_time,km,vehicle
 ```
 This output corresponds to the `time_weight` set to 5 and `cost_weight` set to 1.
 
-## Worked example: Sion → Sierre (TIB)
-A small, self-contained TIB example (no Repast needed) that reproduces the BedDeM paper Table 1: an 18 km trip with three modes. Every determinant is a **cost** (lower = better), so the agent picks the option with the lowest expected utility (EU):
+## Scenario: Sion ↔ Sierre
+The bundled scenario models a full TIB decision with **two locations** — Sion (`loc_id 1`) and Sierre (`loc_id 2`), both offering train + bus — and several agents with different attributes (weights and owned vehicles). Every TIB determinant is implemented in `StandardDummyAgent` (norm, role, self-concept, emotion, facilitating, habit, plus time/cost), each expressed as a **cost** (lower = better), so an agent picks the option with the lowest expected utility.
 
-| Mode | EU (lower = better) |
-|------|---------------------|
-| **Car** | **≈ 1.13** ← chosen |
-| Train | ≈ 3.07 |
-| Bike | ≈ 4.81 |
+Everything is data-driven from `data/`:
+- `agent.csv` — one row per agent: home location, funding, owned vehicles (`resources`), and the TIB weights.
+- `location.csv` — `loc_id, train, bus, tram, name` (which transit each location offers).
+- `schedule.0.csv` — the trips (`agent_id, start, km, time_limit, purpose`); a Sion↔Sierre trip is an 18 km row.
+- `vehicle.csv` — the modes and their speed/cost.
 
-```bash
-mkdir -p out
-javac -d out $(find src/framework src/example -name '*.java')
-java -cp out example.SionToSierreExample
-```
-
-More detail (JUnit test, CI): [`src/example/README.md`](src/example/README.md).
+Add agents, locations, or trips by editing those CSVs — the `ContextManager` loads them at startup. To see each determinant's score per mode, enable `dummy.agent.StandardDummyAgent = DEBUG` in `MessageCenter.log4j.properties`.
 
 ## Tested with versions
 	- Eclipse: 2024-03
diff --git a/build.xml b/build.xml
index 043935d..a29a380 100644
--- a/build.xml
+++ b/build.xml
@@ -385,7 +385,6 @@
         <junit fork="yes" printsummary="yes">
             <formatter type="xml"/>
             <test name="beddem_simulator.ContextTest" todir="${junit.output.dir}"/>
-            <test name="example.SionToSierreTest" todir="${junit.output.dir}"/>
             <jvmarg line="-ea"/>
             <classpath refid="run.Test.classpath"/>
         </junit>
diff --git a/data/agent.csv b/data/agent.csv
index dabeb32..d9814e4 100644
--- a/data/agent.csv
+++ b/data/agent.csv
@@ -1,2 +1,5 @@
 id,loc_id,funding,resources,time_weight,cost_weight,norm_weight,role_weight,self_weight,emotion_weight,facilitating_weight,frequency_weight,attitude_weight,social_weight,affect_weight,intention_weight,habit_weight
-1,1,100,4;5,1,5,1,1,1,1,1,1,1,1,1,1,1
+1,1,100,4;5;6,1,5,1,1,1,1,1,1,1,1,1,1,1
+2,1,150,4;5,5,1,2,1,1,3,1,1,1,1,1,1,1
+3,2,90,5;6,2,1,2,5,2,1,1,1,1,1,1,1,1
+4,2,200,4,3,2,1,1,1,2,1,4,1,1,1,1,1
diff --git a/data/location.csv b/data/location.csv
index 503f958..a7392d4 100644
--- a/data/location.csv
+++ b/data/location.csv
@@ -1,2 +1,3 @@
-loc_id,train,bus,tram
-1,0,0,0
+loc_id,train,bus,tram,name
+1,1,1,0,Sion
+2,1,1,0,Sierre
diff --git a/data/schedule.0.csv b/data/schedule.0.csv
index 8e90851..a4b5155 100644
--- a/data/schedule.0.csv
+++ b/data/schedule.0.csv
@@ -1,3 +1,9 @@
 agent_id,start,km,time_limit,purpose
-1,6,2,1.2,1
-1,12,10,1.2,1
+1,8,18,2.5,2
+1,17,18,2.5,11
+2,8,18,2.5,2
+2,18,18,2.5,11
+3,7,18,3,2
+3,17,18,3,11
+4,8,18,2.5,2
+4,17,18,2.5,11
diff --git a/src/dummy/agent/DummyMemoryComponent.java b/src/dummy/agent/DummyMemoryComponent.java
index e25197d..c2b6a43 100644
--- a/src/dummy/agent/DummyMemoryComponent.java
+++ b/src/dummy/agent/DummyMemoryComponent.java
@@ -66,4 +66,16 @@ public Map<Task, Option> getDecisionResults() {
 		return this.decisionResults;
 	}
 
+	/**
+	 * Number of times the given vehicle/mode has been chosen so far. Used by the
+	 * habit (frequency) determinant.
+	 *
+	 * @param vehicle the mode to look up
+	 * @return how often it has been picked (0 if never)
+	 */
+	public int getPastFrequency(Vehicle vehicle) {
+		Integer count = this.pastFreq.get(vehicle);
+		return (count == null) ? 0 : count;
+	}
+
 }
diff --git a/src/dummy/agent/StandardDummyAgent.java b/src/dummy/agent/StandardDummyAgent.java
index 4025795..68c61ea 100644
--- a/src/dummy/agent/StandardDummyAgent.java
+++ b/src/dummy/agent/StandardDummyAgent.java
@@ -1,5 +1,7 @@
 package dummy.agent;
 
+import java.util.HashMap;
+import java.util.Map;
 import java.util.Set;
 import org.apache.log4j.Level;
 import org.apache.log4j.Logger;
@@ -119,7 +121,7 @@ private Determinant createBeliefDeterminant() {
 	}
 
 	private Determinant createEvaluationDeterminant() {
-		ParentDeterminant evaluation = new ParentDeterminant("evaluation", 1);
+		ParentDeterminant evaluation = new ParentDeterminant("evaluation", this.evaluationWeight);
 		evaluation.addDeterminantChild(new LeafDeterminant("time", this.timeWeight) {
 
 			@Override
@@ -142,39 +144,107 @@ protected double evalOpt(Option opt, Task task) {
 	}
 
 	private Determinant createNormDeterminant() {
+		// Social norm: how socially accepted the mode is (car slightly less so).
 		return new LeafDeterminant("norm", this.normWeight) {
-
 			@Override
 			protected double evalOpt(Option opt, Task task) {
-				// TODO Auto-generated method stub
-				return 0;
+				return logged("NORM", opt, lookup(SOCIAL_NORM, modeOf(opt)));
 			}
 		};
 	}
 
 	private Determinant createRoleDeterminant() {
-		// TODO Auto-generated method stub
-		return null;
+		// Role / environmental values: emissions penalty (active < public < car).
+		return new LeafDeterminant("role", this.roleWeight) {
+			@Override
+			protected double evalOpt(Option opt, Task task) {
+				return logged("ROLE", opt, lookup(EMISSIONS, modeOf(opt)));
+			}
+		};
 	}
 
 	private Determinant createSelfDeterminant() {
-		// TODO Auto-generated method stub
-		return null;
+		// Self-concept: the agent identifies with the modes it owns.
+		return new LeafDeterminant("self", this.selfWeight) {
+			@Override
+			protected double evalOpt(Option opt, Task task) {
+				Vehicle v = ((MobilityOption) opt).getMainVehicle();
+				return logged("SELF", opt, StandardDummyAgent.this.ownVehicles.contains(v) ? 0.0 : 2.0);
+			}
+		};
 	}
 
 	private Determinant createEmotionDeterminant() {
-		// TODO Auto-generated method stub
-		return null;
+		// Emotion / comfort: perceived (dis)comfort of the mode (car comfiest).
+		return new LeafDeterminant("emotion", this.emotionWeight) {
+			@Override
+			protected double evalOpt(Option opt, Task task) {
+				return logged("EMOTION", opt, lookup(DISCOMFORT, modeOf(opt)));
+			}
+		};
 	}
 
 	private Determinant createFacilitatingDeterminant() {
-		// TODO Auto-generated method stub
-		return null;
+		// Facilitating conditions: convenience / directness (transfers penalised).
+		return new LeafDeterminant("facilitating", this.facilitatingWeight) {
+			@Override
+			protected double evalOpt(Option opt, Task task) {
+				return logged("FACILITATING", opt, lookup(INCONVENIENCE, modeOf(opt)));
+			}
+		};
 	}
 
 	private Determinant createFreqDeterminant() {
-		// TODO Auto-generated method stub
-		return null;
+		// Habit: modes used more often in the past get a lower penalty. Reads the
+		// running frequency count from the agent's memory, so this determinant
+		// reflects the agent's earlier choices during the simulation.
+		return new LeafDeterminant("freq", this.freqWeight) {
+			@Override
+			protected double evalOpt(Option opt, Task task) {
+				Vehicle v = ((MobilityOption) opt).getMainVehicle();
+				int past = ((DummyMemoryComponent) StandardDummyAgent.this.memoryComponent).getPastFrequency(v);
+				return logged("FREQ", opt, 1.0 / (1.0 + past));
+			}
+		};
+	}
+
+	/*
+	 * Helper penalty tables. Every determinant above returns a cost-like value in
+	 * which LOWER == more preferred, matching the engine's selection rule
+	 * (DummyCommunicationComponent picks the option with the lowest EU). The six
+	 * columns are the modes defined in data/vehicle.csv.
+	 */
+	private static String modeOf(Option opt) {
+		return ((MobilityOption) opt).getMainVehicle().getName().toLowerCase();
+	}
+
+	/** Log a determinant's value for one option, then return it unchanged. */
+	private static double logged(String determinant, Option opt, double value) {
+		LOGGER.log(Level.DEBUG, "Evaluating " + determinant + " " + modeOf(opt) + " = " + value);
+		return value;
+	}
+
+	private static double lookup(Map<String, Double> table, String mode) {
+		// Unknown modes get a neutral mid penalty rather than crashing.
+		return table.getOrDefault(mode, 2.0);
+	}
+
+	//                                             train  bus  tram  car  walking  biking
+	private static final Map<String, Double> SOCIAL_NORM   = penalties(1, 1, 1, 2, 1, 1);
+	private static final Map<String, Double> EMISSIONS     = penalties(1, 2, 1, 3, 0, 0);
+	private static final Map<String, Double> DISCOMFORT    = penalties(1, 2, 1, 0, 3, 2);
+	private static final Map<String, Double> INCONVENIENCE = penalties(1, 2, 1, 0, 0, 0);
+
+	private static Map<String, Double> penalties(double train, double bus, double tram, double car, double walking,
+			double biking) {
+		Map<String, Double> t = new HashMap<String, Double>();
+		t.put("train", train);
+		t.put("bus", bus);
+		t.put("tram", tram);
+		t.put("car", car);
+		t.put("walking", walking);
+		t.put("biking", biking);
+		return t;
 	}
 	/*******************************************************************************************/
 
diff --git a/src/dummy/database/CSVReader.java b/src/dummy/database/CSVReader.java
index b7dcc16..a5d73b4 100644
--- a/src/dummy/database/CSVReader.java
+++ b/src/dummy/database/CSVReader.java
@@ -103,9 +103,12 @@ public void createLocations(LocationContext locContext, HashMap<String, Environm
 			if (inputs[3].equals("1")) {
 				publicTransports.add(this.idToVehicleMap.get("3"));
 			}
-			Location loc = new Location(inputs[0], publicTransports);
+			// Optional location name in the last column (e.g. Sion, Sierre).
+			String name = (inputs.length > 4) ? inputs[4] : inputs[0];
+			Location loc = new Location(inputs[0], name, publicTransports);
 			idToLocationMap.put(inputs[0], loc);
 			locContext.add(loc);
+			LOGGER.log(Level.DEBUG, "Location created: " + name + " (id " + inputs[0] + ")");
 		}
 
 		br.close();
diff --git a/src/dummy/environment/Location.java b/src/dummy/environment/Location.java
index 7bf655c..0decb2d 100644
--- a/src/dummy/environment/Location.java
+++ b/src/dummy/environment/Location.java
@@ -11,9 +11,11 @@ public class Location implements Environment {
 
 	private Set<Vehicle> publicTransports;
 	private String id;
+	private String name;
 
-	public Location(String id, Set<Vehicle> publicTransports) {
+	public Location(String id, String name, Set<Vehicle> publicTransports) {
 		this.id = id;
+		this.name = name;
 		this.publicTransports = publicTransports;
 	}
 
@@ -26,4 +28,8 @@ public String getId() {
 		return this.id;
 	}
 
+	public String getName() {
+		return this.name;
+	}
+
 }
diff --git a/src/example/README.md b/src/example/README.md
deleted file mode 100644
index b5ce925..0000000
--- a/src/example/README.md
+++ /dev/null
@@ -1,45 +0,0 @@
-# Sion → Sierre worked example (TIB)
-
-A self-contained worked example of Triandis' Theory of Interpersonal Behaviour
-(TIB) on beddem_simulator's own decision engine. It reproduces the BedDeM paper
-(Table 1): an **18 km trip from Sion to Sierre** with three modes — car, train,
-bike. Unlike `StandardDummyAgent` (only *time*/*cost* implemented), **every
-determinant here has a real value, so all input weights matter**.
-
-## Result
-
-Every determinant is a **cost** (lower = better), and the agent picks the option
-with the lowest aggregated expected utility (EU):
-
-| Mode | EU (lower = better) |
-|------|---------------------|
-| **Car** | **≈ 1.13** ← chosen |
-| Train | ≈ 3.07 |
-| Bike | ≈ 4.81 |
-
-## Run it
-
-Depends only on `framework.*` + `example.*` (+ JUnit 4 for the test), so it runs
-**without Repast/Eclipse**. From the repo root:
-
-```bash
-mkdir -p out
-javac -d out $(find src/framework src/example -name '*.java')
-
-# print the EU table
-java -cp out example.SionToSierreExample
-
-# or run the JUnit test (junit + hamcrest ship with the Repast/Eclipse plugins)
-javac -d out -cp junit.jar:hamcrest.jar test/example/SionToSierreTest.java
-java -cp out:junit.jar:hamcrest.jar org.junit.runner.JUnitCore example.SionToSierreTest
-```
-
-In CI the test runs via `build.xml`'s `run-test` target on pull requests to
-`master`; in Eclipse, right-click the test → **Run As → JUnit Test**.
-
-## Files
-
-- `SionMobilityOption.java` — one mode + its 8 determinant inputs
-- `SionTIBDecision.java` — wires all determinants onto the TIB engine
-- `SionToSierreExample.java` — builds the scenario (`main()` + `euByService()`)
-- `../../test/example/SionToSierreTest.java` — the JUnit 4 test
diff --git a/src/example/SionMobilityOption.java b/src/example/SionMobilityOption.java
deleted file mode 100644
index d4c857c..0000000
--- a/src/example/SionMobilityOption.java
+++ /dev/null
@@ -1,56 +0,0 @@
-package example;
-
-import framework.concept.Option;
-
-/**
- * A single mobility alternative for the Sion -> Sierre worked example
- * (BedDeM paper, Table 1). It carries the raw determinant inputs for one
- * transport mode.
- *
- * <p>All values follow the engine's cost convention: <b>lower = more
- * preferred</b>. Ranks (norm/role/self/comfort) use 1 = best .. 3 = worst;
- * price is in CHF, time in hours, frequency and facilitating are the raw
- * Table 1 values. This keeps the whole example internally consistent with
- * beddem_simulator's selection rule, which picks the option with the lowest
- * aggregated expected utility.</p>
- */
-public class SionMobilityOption implements Option {
-
-	private final String service;
-	private final double price;         // CHF, lower = cheaper = better
-	private final double time;          // hours, lower = faster = better
-	private final double norm;          // social-norm rank, 1 = best
-	private final double role;          // environmental rank, 1 = greenest = best
-	private final double selfConcept;   // identity rank, 1 = best
-	private final double comfort;       // (dis)comfort rank, 1 = best
-	private final double freq;          // habit, lower = more habitual = better
-	private final double facilitating;  // ease of access, lower = easier = better
-
-	public SionMobilityOption(String service, double price, double time, double norm, double role, double selfConcept,
-			double comfort, double freq, double facilitating) {
-		this.service = service;
-		this.price = price;
-		this.time = time;
-		this.norm = norm;
-		this.role = role;
-		this.selfConcept = selfConcept;
-		this.comfort = comfort;
-		this.freq = freq;
-		this.facilitating = facilitating;
-	}
-
-	public String getService()      { return this.service; }
-	public double getPrice()        { return this.price; }
-	public double getTime()         { return this.time; }
-	public double getNorm()         { return this.norm; }
-	public double getRole()         { return this.role; }
-	public double getSelfConcept()  { return this.selfConcept; }
-	public double getComfort()      { return this.comfort; }
-	public double getFreq()         { return this.freq; }
-	public double getFacilitating() { return this.facilitating; }
-
-	@Override
-	public String toString() {
-		return this.service;
-	}
-}
diff --git a/src/example/SionTIBDecision.java b/src/example/SionTIBDecision.java
deleted file mode 100644
index 88fbdf3..0000000
--- a/src/example/SionTIBDecision.java
+++ /dev/null
@@ -1,98 +0,0 @@
-package example;
-
-import java.util.Map;
-import java.util.Set;
-
-import framework.agent.core.DecisionComponent;
-import framework.agent.reasoning.Determinant;
-import framework.agent.reasoning.LeafDeterminant;
-import framework.agent.reasoning.ParentDeterminant;
-import framework.agent.reasoning.TIBModel;
-import framework.concept.Option;
-import framework.concept.Task;
-
-/**
- * TIB decision component for the Sion -> Sierre worked example, built on
- * beddem_simulator's own reasoning engine ({@link TIBModel} /
- * {@link ParentDeterminant} / {@link LeafDeterminant}).
- *
- * <p>Unlike {@code StandardDummyAgent} (where only time and cost were
- * implemented and the other determinants were stubbed), every TIB determinant
- * here has a real ranking function, so all input weights influence the
- * outcome. Each leaf returns a cost-like value where <b>lower = better</b>;
- * the engine normalises and weights these up the tree, and the option with the
- * lowest aggregated expected utility is the preferred one.</p>
- *
- * <p>Scenario data and weights come from the BedDeM paper, Table 1 (an 18 km
- * trip from Sion to Sierre with three modes: car, train, bike).</p>
- */
-public class SionTIBDecision extends TIBModel implements DecisionComponent {
-
-	public SionTIBDecision(Determinant belief, Determinant evaluation, Determinant norm, Determinant role,
-			Determinant selfConcept, Determinant emotion, Determinant facilitatingCond, Determinant freq,
-			double attitudeWeight, double socialWeight, double affectWeight, double intentionWeight,
-			double habitWeight) {
-		super(belief, evaluation, norm, role, selfConcept, emotion, facilitatingCond, freq, attitudeWeight, socialWeight,
-				affectWeight, intentionWeight, habitWeight);
-	}
-
-	@Override
-	public Map<Double, Set<Option>> evaluateOptions(Set<Option> options, Task task) {
-		// Return the root-level TIB aggregation (expected utility per option).
-		// We use the raw aggregate rather than the extra top-level normalisation
-		// that rankOptions applies, so the numbers reproduce the paper's Table 1
-		// EU values (Car ~1.13, Train ~3.07, Bike ~4.81). The chosen option
-		// (lowest EU) is identical either way, since normalisation is monotonic.
-		return evalOpts(options, task);
-	}
-
-	/**
-	 * Assemble a fully-wired TIB decision component from the Table 1 weights.
-	 *
-	 * @param evaluationWeight weight of the "evaluation" node grouping price and time
-	 */
-	public static SionTIBDecision build(double priceWeight, double timeWeight, double normWeight, double roleWeight,
-			double selfConceptWeight, double emotionWeight, double facilitatingWeight, double freqWeight,
-			double evaluationWeight, double attitudeWeight, double socialWeight, double affectWeight,
-			double intentionWeight, double habitWeight) {
-
-		ParentDeterminant evaluation = new ParentDeterminant("evaluation", evaluationWeight);
-		evaluation.addDeterminantChild(leaf("price", priceWeight));
-		evaluation.addDeterminantChild(leaf("time", timeWeight));
-
-		Determinant belief = null; // not used in the Table 1 example
-		Determinant norm = leaf("norm", normWeight);
-		Determinant role = leaf("role", roleWeight);
-		Determinant selfConcept = leaf("self", selfConceptWeight);
-		Determinant emotion = leaf("emotion", emotionWeight);
-		Determinant facilitating = leaf("facilitating", facilitatingWeight);
-		Determinant freq = leaf("freq", freqWeight);
-
-		return new SionTIBDecision(belief, evaluation, norm, role, selfConcept, emotion, facilitating, freq,
-				attitudeWeight, socialWeight, affectWeight, intentionWeight, habitWeight);
-	}
-
-	/**
-	 * One leaf determinant. Reads the matching cost-like value from the option
-	 * (lower = better in every case).
-	 */
-	private static LeafDeterminant leaf(final String id, double weight) {
-		return new LeafDeterminant(id, weight) {
-			@Override
-			protected double evalOpt(Option opt, Task task) {
-				SionMobilityOption o = (SionMobilityOption) opt;
-				switch (id) {
-				case "price":        return o.getPrice();
-				case "time":         return o.getTime();
-				case "norm":         return o.getNorm();
-				case "role":         return o.getRole();
-				case "self":         return o.getSelfConcept();
-				case "emotion":      return o.getComfort();
-				case "facilitating": return o.getFacilitating();
-				case "freq":         return o.getFreq();
-				default:             return 0.0;
-				}
-			}
-		};
-	}
-}
diff --git a/src/example/SionTask.java b/src/example/SionTask.java
deleted file mode 100644
index 64b48a1..0000000
--- a/src/example/SionTask.java
+++ /dev/null
@@ -1,15 +0,0 @@
-package example;
-
-import framework.concept.Task;
-
-/**
- * Minimal task for the Sion -> Sierre worked example. The determinant
- * functions in {@link SionTIBDecision} read all they need from the option
- * itself, so this task only needs to satisfy the framework's Task contract.
- */
-public class SionTask extends Task {
-
-	public SionTask() {
-		super(0.0);
-	}
-}
diff --git a/src/example/SionToSierreExample.java b/src/example/SionToSierreExample.java
deleted file mode 100644
index ec1d7b1..0000000
--- a/src/example/SionToSierreExample.java
+++ /dev/null
@@ -1,74 +0,0 @@
-package example;
-
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
-
-import framework.concept.Option;
-
-/**
- * Runnable worked example: an 18 km trip from Sion to Sierre with three modes
- * (car, train, bike), using the weights and determinant values of the BedDeM
- * paper, Table 1, evaluated through beddem_simulator's own TIB engine.
- *
- * <p>Every determinant uses the cost convention (lower = better) and the agent
- * prefers the option with the lowest aggregated expected utility (EU).</p>
- *
- * <p>Run: {@code java example.SionToSierreExample}</p>
- */
-public class SionToSierreExample {
-
-	/** Build the three Table 1 options. */
-	public static Set<Option> scenarioOptions() {
-		Set<Option> options = new HashSet<Option>();
-		//                                 service  price time norm role self comfort freq facil
-		options.add(new SionMobilityOption("Car",   4.0, 0.3,  2,   3,   1,   1,      0,   0));
-		options.add(new SionMobilityOption("Train", 3.0, 0.2,  1,   2,   2,   2,      0,   1));
-		options.add(new SionMobilityOption("Bike",  0.0, 1.0,  3,   1,   3,   3,      1,   0));
-		return options;
-	}
-
-	/** Build the decision component with the Table 1 weights. */
-	public static SionTIBDecision scenarioDecision() {
-		return SionTIBDecision.build(
-				2,  // price
-				4,  // time
-				3,  // norm
-				2,  // role
-				3,  // self-concept
-				1,  // emotion / enjoyment
-				2,  // facilitating
-				3,  // freq / habit
-				1,  // evaluation node
-				4,  // attitude
-				2,  // social
-				2,  // affect
-				4,  // intention
-				3); // habit
-	}
-
-	/** Map each option's service name to its aggregated EU (lower = better). */
-	public static Map<String, Double> euByService() {
-		Map<Double, Set<Option>> result = scenarioDecision().evaluateOptions(scenarioOptions(), new SionTask());
-		java.util.Map<String, Double> eu = new java.util.HashMap<String, Double>();
-		for (Map.Entry<Double, Set<Option>> entry : result.entrySet()) {
-			for (Option opt : entry.getValue()) {
-				eu.put(((SionMobilityOption) opt).getService(), entry.getKey());
-			}
-		}
-		return eu;
-	}
-
-	public static void main(String[] args) {
-		Map<String, Double> eu = euByService();
-		String winner = null;
-		double best = Double.POSITIVE_INFINITY;
-		System.out.println("=== Sion -> Sierre (18 km) | EU, lower = better ===");
-		for (String mode : new String[] { "Car", "Train", "Bike" }) {
-			double v = eu.get(mode);
-			System.out.printf(java.util.Locale.US, "  %-6s EU = %.4f%n", mode, v);
-			if (v < best) { best = v; winner = mode; }
-		}
-		System.out.println("Chosen (lowest EU): " + winner);
-	}
-}
diff --git a/test/example/SionToSierreTest.java b/test/example/SionToSierreTest.java
deleted file mode 100644
index 7f5dec5..0000000
--- a/test/example/SionToSierreTest.java
+++ /dev/null
@@ -1,75 +0,0 @@
-package example;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-
-import java.util.Map;
-
-import org.junit.Before;
-import org.junit.Test;
-
-/**
- * Worked-example test: an 18 km trip from Sion to Sierre with three modes
- * (car, train, bike), using the weights and determinant values of the BedDeM
- * paper, Table 1, evaluated through beddem_simulator's own TIB engine
- * ({@link SionTIBDecision}).
- *
- * <p>The engine uses cost semantics: every determinant is expressed so that a
- * <b>lower value is more preferred</b>, and the agent chooses the option with
- * the <b>lowest</b> aggregated expected utility (EU). Under the Table 1 inputs
- * the ranking is Car &lt; Train &lt; Bike, so the agent picks the car.</p>
- */
-public class SionToSierreTest {
-
-	// Expected EU from the paper, Table 1 (lower = better).
-	private static final double EXPECTED_CAR = 1.13;
-	private static final double EXPECTED_TRAIN = 3.07;
-	private static final double EXPECTED_BIKE = 4.81;
-	private static final double TOLERANCE = 0.05;
-
-	private Map<String, Double> eu;
-
-	@Before
-	public void setUp() {
-		eu = SionToSierreExample.euByService();
-	}
-
-	@Test
-	public void allThreeOptionsAreEvaluated() {
-		assertEquals("Three modes should be evaluated", 3, eu.size());
-	}
-
-	@Test
-	public void agentPicksLowestEuOption() {
-		String winner = null;
-		double best = Double.POSITIVE_INFINITY;
-		for (Map.Entry<String, Double> e : eu.entrySet()) {
-			if (e.getValue() < best) {
-				best = e.getValue();
-				winner = e.getKey();
-			}
-		}
-		assertEquals("Car has the lowest aggregated EU and is chosen", "Car", winner);
-	}
-
-	@Test
-	public void rankingIsCarThenTrainThenBike() {
-		assertTrue("Car should be preferred over Train (lower EU)", eu.get("Car") < eu.get("Train"));
-		assertTrue("Train should be preferred over Bike (lower EU)", eu.get("Train") < eu.get("Bike"));
-	}
-
-	@Test
-	public void euMatchesPaperTable1() {
-		assertEquals("Car EU", EXPECTED_CAR, eu.get("Car"), TOLERANCE);
-		assertEquals("Train EU", EXPECTED_TRAIN, eu.get("Train"), TOLERANCE);
-		assertEquals("Bike EU", EXPECTED_BIKE, eu.get("Bike"), TOLERANCE);
-	}
-
-	@Test
-	public void allEuValuesArePositiveAndFinite() {
-		for (double v : eu.values()) {
-			assertTrue("EU should be finite", Double.isFinite(v));
-			assertTrue("EU should be positive", v > 0);
-		}
-	}
-}

From 839654cad9c11a397a348ab5e8552b1bc9ec4f20 Mon Sep 17 00:00:00 2001
From: Amy Liffey <amy.liffey@hes-so.ch>
Date: Fri, 3 Jul 2026 17:21:44 +0200
Subject: [PATCH 08/25] chore: more agents and analysis

---
 .github/workflows/ant.yml           |  20 +++
 .gitignore                          |   3 +
 analysis/plot_tib.py                | 181 ++++++++++++++++++++++++++++
 src/dummy/report/DummyReporter.java |   8 +-
 4 files changed, 209 insertions(+), 3 deletions(-)
 create mode 100644 analysis/plot_tib.py

diff --git a/.github/workflows/ant.yml b/.github/workflows/ant.yml
index d039101..63e4900 100644
--- a/.github/workflows/ant.yml
+++ b/.github/workflows/ant.yml
@@ -53,3 +53,23 @@ jobs:
         name: junit-report
         path: junit/
 
+  visualize:
+    # Fast, standalone job: renders the TIB decision charts from data/*.csv.
+    # No Repast needed, so it does not depend on the build job.
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: '3.11'
+    - name: Render TIB decision charts
+      run: |
+        pip install matplotlib
+        for a in 1 2 3 4; do python analysis/plot_tib.py $a 0; done
+    - name: Upload TIB charts
+      uses: actions/upload-artifact@v4
+      with:
+        name: tib-charts
+        path: analysis/tib_decision_agent*.png
+
diff --git a/.gitignore b/.gitignore
index 4345fe9..128e608 100644
--- a/.gitignore
+++ b/.gitignore
@@ -16,3 +16,6 @@ Repast.settings
 /testbin/
 junit/*
 .idea/*
+
+# Generated TIB charts
+analysis/*.png
diff --git a/analysis/plot_tib.py b/analysis/plot_tib.py
new file mode 100644
index 0000000..22ccf00
--- /dev/null
+++ b/analysis/plot_tib.py
@@ -0,0 +1,181 @@
+#!/usr/bin/env python3
+"""Render the TIB decision for one agent's trip as a PNG.
+
+Reads the scenario CSVs in ``data/`` and reproduces beddem_simulator's TIB
+aggregation (see StandardDummyAgent / framework.agent.reasoning). For the chosen
+agent and trip it plots:
+
+  * the expected utility (EU) per feasible mode  (lower = better, lowest chosen)
+  * the per-determinant profile per mode          (scaled 0-1, lower preferred)
+
+Usage:  python analysis/plot_tib.py [agent_id] [trip_index]
+Output: analysis/tib_decision.png
+
+This is an analysis/visualisation helper; it mirrors the Java engine's maths but
+is not the model itself.
+"""
+import csv
+import os
+import sys
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+
+ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+DATA = os.path.join(ROOT, "data")
+
+CAR, TRAIN, BIKE = "#2a78d6", "#1baf7a", "#eda100"
+MODE_COLOR = {"car": CAR, "train": TRAIN, "biking": BIKE, "walking": "#e34948", "bus": "#eb6834", "tram": "#4a3aa7"}
+
+# Cost-like penalty tables (lower = better), keyed on the mode name in vehicle.csv.
+SOCIAL_NORM = {"train": 1, "bus": 1, "tram": 1, "car": 2, "walking": 1, "biking": 1}
+EMISSIONS = {"train": 1, "bus": 2, "tram": 1, "car": 3, "walking": 0, "biking": 0}
+DISCOMFORT = {"train": 1, "bus": 2, "tram": 1, "car": 0, "walking": 3, "biking": 2}
+INCONVENIENCE = {"train": 1, "bus": 2, "tram": 1, "car": 0, "walking": 0, "biking": 0}
+
+
+def read_csv(name):
+    with open(os.path.join(DATA, name), newline="") as f:
+        return list(csv.DictReader(f))
+
+
+def load():
+    vehicles = {r["vehicle_id"]: {"name": r["name"].lower(),
+                                  "speed": float(r["speed_km_per_hr"]),
+                                  "cost": float(r["cost_per_km"])}
+                for r in read_csv("vehicle.csv")}
+    name_to_id = {v["name"]: vid for vid, v in vehicles.items()}
+    locations = {r["loc_id"]: {n: r.get(n, "0") for n in ("train", "bus", "tram")}
+                 for r in read_csv("location.csv")}
+    agents = {r["id"]: r for r in read_csv("agent.csv")}
+    schedule = read_csv("schedule.0.csv")
+    return vehicles, name_to_id, locations, agents, schedule
+
+
+def feasible_options(agent, vehicles, name_to_id, locations, trip):
+    dist, limit, fund = float(trip["km"]), float(trip["time_limit"]), float(agent["funding"])
+    owned = set(agent["resources"].split(";"))
+    loc = locations[agent["loc_id"]]
+    avail = set(owned)
+    for mode_name, vid in (("train", "1"), ("bus", "2"), ("tram", "3")):
+        if loc.get(mode_name) == "1":
+            avail.add(vid)
+    opts = []
+    for vid in avail:
+        v = vehicles[vid]
+        t = dist / v["speed"]
+        c = dist * v["cost"]
+        if t < limit and c <= fund:
+            opts.append({"name": v["name"], "time": t, "cost": c, "owned": vid in owned})
+    return opts
+
+
+def leaf_values(opts, agent):
+    """Raw cost-like value per determinant per option (lower = better)."""
+    return {
+        "time": {o["name"]: o["time"] for o in opts},
+        "cost": {o["name"]: o["cost"] for o in opts},
+        "norm": {o["name"]: SOCIAL_NORM.get(o["name"], 2) for o in opts},
+        "role": {o["name"]: EMISSIONS.get(o["name"], 2) for o in opts},
+        "self": {o["name"]: (0.0 if o["owned"] else 2.0) for o in opts},
+        "emotion": {o["name"]: DISCOMFORT.get(o["name"], 2) for o in opts},
+        "facilitating": {o["name"]: INCONVENIENCE.get(o["name"], 2) for o in opts},
+        "freq": {o["name"]: 1.0 for o in opts},  # first trip: no habit yet
+    }
+
+
+def rank(values):
+    """Normalise by the sum of DISTINCT values, as Determinant.rankOptions does."""
+    s = sum(set(values.values())) or 1.0
+    return {k: v / s for k, v in values.items()}
+
+
+def aggregate(children, options):
+    """Parent raw value per option = sum of rank(child) * child_weight."""
+    acc = {o: 0.0 for o in options}
+    for weight, child_raw in children:
+        cn = rank(child_raw)
+        for o in options:
+            acc[o] += cn[o] * weight
+    return acc
+
+
+def tib_eu(leaf, weights, options):
+    price_time = aggregate([(weights["time"], leaf["time"]), (weights["cost"], leaf["cost"])], options)
+    evaluation = aggregate([(weights["evaluation"], price_time)], options)          # belief is null
+    attitude = evaluation                                                            # attitude has only evaluation
+    affect = aggregate([(weights["emotion"], leaf["emotion"])], options)
+    social = aggregate([(weights["norm"], leaf["norm"]), (weights["role"], leaf["role"]),
+                        (weights["self"], leaf["self"])], options)
+    intention = aggregate([(weights["affect"], affect), (weights["social"], social),
+                           (weights["attitude"], attitude)], options)
+    habits = aggregate([(weights["freq"], leaf["freq"])], options)
+    root = aggregate([(weights["intention"], intention), (weights["habit"], habits),
+                      (weights["facilitating"], leaf["facilitating"])], options)
+    return root
+
+
+def weights_of(agent):
+    return {
+        "time": float(agent["time_weight"]), "cost": float(agent["cost_weight"]),
+        "norm": float(agent["norm_weight"]), "role": float(agent["role_weight"]),
+        "self": float(agent["self_weight"]), "emotion": float(agent["emotion_weight"]),
+        "facilitating": float(agent["facilitating_weight"]), "freq": float(agent["frequency_weight"]),
+        "attitude": float(agent["attitude_weight"]), "social": float(agent["social_weight"]),
+        "affect": float(agent["affect_weight"]), "intention": float(agent["intention_weight"]),
+        "habit": float(agent["habit_weight"]), "evaluation": 1.0,
+    }
+
+
+def main():
+    agent_id = sys.argv[1] if len(sys.argv) > 1 else "1"
+    trip_idx = int(sys.argv[2]) if len(sys.argv) > 2 else 0
+
+    vehicles, name_to_id, locations, agents, schedule = load()
+    agent = agents[agent_id]
+    trips = [t for t in schedule if t["agent_id"] == agent_id]
+    trip = trips[trip_idx]
+
+    opts = feasible_options(agent, vehicles, name_to_id, locations, trip)
+    options = [o["name"] for o in opts]
+    leaf = leaf_values(opts, agent)
+    weights = weights_of(agent)
+    eu = tib_eu(leaf, weights, options)
+    winner = min(eu, key=eu.get)
+
+    order = sorted(options, key=lambda m: eu[m])
+    dets = ["time", "cost", "norm", "role", "self", "emotion", "facilitating", "freq"]
+
+    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(11, 4.2))
+    fig.suptitle(f"Agent {agent_id} ({locations[agent['loc_id']].get('name', agent['loc_id']) if 'name' in locations[agent['loc_id']] else agent['loc_id']}) "
+                 f"— {int(float(trip['km']))} km trip", fontsize=13)
+
+    ax1.barh(order[::-1], [eu[m] for m in order[::-1]], color=[MODE_COLOR.get(m, "#888") for m in order[::-1]])
+    ax1.set_title("Expected utility (lower = chosen)", fontsize=11)
+    for i, m in enumerate(order[::-1]):
+        ax1.text(eu[m], i, f"  {eu[m]:.2f}" + ("  ← chosen" if m == winner else ""), va="center", fontsize=9)
+    ax1.margins(x=0.25)
+
+    x = range(len(dets))
+    n = len(order)
+    w = 0.8 / n
+    for i, m in enumerate(order):
+        col = [leaf[d][m] for d in dets]
+        mx = [max(leaf[d].values()) or 1 for d in dets]
+        norm = [c / mmx for c, mmx in zip(col, mx)]
+        ax2.bar([xi + i * w for xi in x], norm, width=w, label=m, color=MODE_COLOR.get(m, "#888"))
+    ax2.set_title("Determinant profile (scaled, lower = preferred)", fontsize=11)
+    ax2.set_xticks([xi + w * (n - 1) / 2 for xi in x])
+    ax2.set_xticklabels(dets, rotation=40, ha="right", fontsize=9)
+    ax2.set_ylim(0, 1)
+    ax2.legend(fontsize=9, frameon=False)
+
+    fig.tight_layout(rect=[0, 0, 1, 0.94])
+    out = os.path.join(os.path.dirname(os.path.abspath(__file__)), f"tib_decision_agent{agent_id}.png")
+    fig.savefig(out, dpi=130)
+    print(f"Wrote {out}: options {options}, EU {{" + ", ".join(f'{m}:{eu[m]:.2f}' for m in order) + f"}}, chosen {winner}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/dummy/report/DummyReporter.java b/src/dummy/report/DummyReporter.java
index 3e21f4a..aafa7e4 100644
--- a/src/dummy/report/DummyReporter.java
+++ b/src/dummy/report/DummyReporter.java
@@ -6,6 +6,7 @@
 import dummy.concept.MobilityOption;
 import dummy.concept.MobilityTask;
 import dummy.context.AgentContext;
+import dummy.environment.Location;
 import framework.agent.core.IAgent;
 import framework.concept.Option;
 import framework.concept.Task;
@@ -24,15 +25,16 @@ public DummyReporter(AgentContext agentContext) {
 
 	@Override
 	public String printReport() {
-		String reportString = "\nagentID,start_time,km,vehicle\n";
+		String reportString = "\nagentID,location,start_time,km,vehicle\n";
 		for (IAgent agent : this.agentContext) {
 			StandardDummyAgent mobilityAgent = (StandardDummyAgent) agent;
+			String location = ((Location) mobilityAgent.getLoc()).getName();
 			Map<Task, Option> results = mobilityAgent.getDecisionResults();
 			for (Task task : results.keySet()) {
 				MobilityOption mobilityOption = (MobilityOption) results.get(task);
 				MobilityTask mobilityTask = (MobilityTask) task;
-				reportString += agent.getID() + "," + mobilityTask.getExecutingTime() + "," + mobilityTask.getDistance()
-						+ "," + mobilityOption.getMainVehicle().getName() + "\n";
+				reportString += agent.getID() + "," + location + "," + mobilityTask.getExecutingTime() + ","
+						+ mobilityTask.getDistance() + "," + mobilityOption.getMainVehicle().getName() + "\n";
 			}
 		}
 

From cc726d0b8f972d33bc341ad4863702cb1085745c Mon Sep 17 00:00:00 2001
From: Amy Liffey <amy.liffey@hes-so.ch>
Date: Mon, 6 Jul 2026 20:34:50 +0200
Subject: [PATCH 09/25] feat: refactor

---
 analysis/plot_tib.py                          | 218 +++++-------------
 src/dummy/agent/DummyDecisionComponent.java   |  23 +-
 src/dummy/agent/DummyPerceptionComponent.java |   7 -
 src/dummy/agent/StandardDummyAgent.java       |  29 ++-
 src/dummy/report/DummyReporter.java           |  57 ++++-
 .../simulator/ThreadedAgentScheduler.java     |  13 ++
 .../agent/core/PerceptionComponent.java       |  17 --
 .../agent/core/TaskExecutionAgent.java        |   6 +-
 src/framework/agent/reasoning/TPBModel.java   |   3 +-
 .../exception/AgentCreationException.java     |  15 --
 .../DuplicateIdentifierException.java         |  11 -
 .../exception/MissingElementException.java    |  11 -
 .../exception/NoIdentifierException.java      |  11 -
 .../exception/ParameterNotFoundException.java |  11 -
 14 files changed, 178 insertions(+), 254 deletions(-)
 delete mode 100644 src/framework/exception/AgentCreationException.java
 delete mode 100644 src/framework/exception/DuplicateIdentifierException.java
 delete mode 100644 src/framework/exception/MissingElementException.java
 delete mode 100644 src/framework/exception/NoIdentifierException.java
 delete mode 100644 src/framework/exception/ParameterNotFoundException.java

diff --git a/analysis/plot_tib.py b/analysis/plot_tib.py
index 22ccf00..09e30e1 100644
--- a/analysis/plot_tib.py
+++ b/analysis/plot_tib.py
@@ -1,180 +1,86 @@
 #!/usr/bin/env python3
-"""Render the TIB decision for one agent's trip as a PNG.
+"""Plot the model's decision results.
 
-Reads the scenario CSVs in ``data/`` and reproduces beddem_simulator's TIB
-aggregation (see StandardDummyAgent / framework.agent.reasoning). For the chosen
-agent and trip it plots:
+Reads ``output/decisions.csv`` (written by DummyReporter during a simulation
+run) and plots the expected utility (EU) of each mode per trip, with the chosen
+mode highlighted. It does NOT recompute the decision -- it visualises what the
+model produced.
 
-  * the expected utility (EU) per feasible mode  (lower = better, lowest chosen)
-  * the per-determinant profile per mode          (scaled 0-1, lower preferred)
+Usage:  python analysis/plot_tib.py [agent_id]
+Output: analysis/tib_decision_agent<id>.png  (one agent), or
+        analysis/tib_decisions.png            (all agents, no arg)
 
-Usage:  python analysis/plot_tib.py [agent_id] [trip_index]
-Output: analysis/tib_decision.png
-
-This is an analysis/visualisation helper; it mirrors the Java engine's maths but
-is not the model itself.
+Generate the input first by running the simulation (see README) so that
+output/decisions.csv exists.
 """
 import csv
 import os
 import sys
+from collections import defaultdict
 
 import matplotlib
 matplotlib.use("Agg")
 import matplotlib.pyplot as plt
 
 ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-DATA = os.path.join(ROOT, "data")
-
-CAR, TRAIN, BIKE = "#2a78d6", "#1baf7a", "#eda100"
-MODE_COLOR = {"car": CAR, "train": TRAIN, "biking": BIKE, "walking": "#e34948", "bus": "#eb6834", "tram": "#4a3aa7"}
-
-# Cost-like penalty tables (lower = better), keyed on the mode name in vehicle.csv.
-SOCIAL_NORM = {"train": 1, "bus": 1, "tram": 1, "car": 2, "walking": 1, "biking": 1}
-EMISSIONS = {"train": 1, "bus": 2, "tram": 1, "car": 3, "walking": 0, "biking": 0}
-DISCOMFORT = {"train": 1, "bus": 2, "tram": 1, "car": 0, "walking": 3, "biking": 2}
-INCONVENIENCE = {"train": 1, "bus": 2, "tram": 1, "car": 0, "walking": 0, "biking": 0}
-
-
-def read_csv(name):
-    with open(os.path.join(DATA, name), newline="") as f:
-        return list(csv.DictReader(f))
+CSV = os.path.join(ROOT, "output", "decisions.csv")
+OUTDIR = os.path.dirname(os.path.abspath(__file__))
+COLOR = {"car": "#2a78d6", "train": "#1baf7a", "biking": "#eda100",
+         "walking": "#e34948", "bus": "#eb6834", "tram": "#4a3aa7"}
+LABEL = {"car": "Car", "train": "Train", "biking": "Bike", "walking": "Walk", "bus": "Bus", "tram": "Tram"}
 
 
 def load():
-    vehicles = {r["vehicle_id"]: {"name": r["name"].lower(),
-                                  "speed": float(r["speed_km_per_hr"]),
-                                  "cost": float(r["cost_per_km"])}
-                for r in read_csv("vehicle.csv")}
-    name_to_id = {v["name"]: vid for vid, v in vehicles.items()}
-    locations = {r["loc_id"]: {n: r.get(n, "0") for n in ("train", "bus", "tram")}
-                 for r in read_csv("location.csv")}
-    agents = {r["id"]: r for r in read_csv("agent.csv")}
-    schedule = read_csv("schedule.0.csv")
-    return vehicles, name_to_id, locations, agents, schedule
-
-
-def feasible_options(agent, vehicles, name_to_id, locations, trip):
-    dist, limit, fund = float(trip["km"]), float(trip["time_limit"]), float(agent["funding"])
-    owned = set(agent["resources"].split(";"))
-    loc = locations[agent["loc_id"]]
-    avail = set(owned)
-    for mode_name, vid in (("train", "1"), ("bus", "2"), ("tram", "3")):
-        if loc.get(mode_name) == "1":
-            avail.add(vid)
-    opts = []
-    for vid in avail:
-        v = vehicles[vid]
-        t = dist / v["speed"]
-        c = dist * v["cost"]
-        if t < limit and c <= fund:
-            opts.append({"name": v["name"], "time": t, "cost": c, "owned": vid in owned})
-    return opts
-
-
-def leaf_values(opts, agent):
-    """Raw cost-like value per determinant per option (lower = better)."""
-    return {
-        "time": {o["name"]: o["time"] for o in opts},
-        "cost": {o["name"]: o["cost"] for o in opts},
-        "norm": {o["name"]: SOCIAL_NORM.get(o["name"], 2) for o in opts},
-        "role": {o["name"]: EMISSIONS.get(o["name"], 2) for o in opts},
-        "self": {o["name"]: (0.0 if o["owned"] else 2.0) for o in opts},
-        "emotion": {o["name"]: DISCOMFORT.get(o["name"], 2) for o in opts},
-        "facilitating": {o["name"]: INCONVENIENCE.get(o["name"], 2) for o in opts},
-        "freq": {o["name"]: 1.0 for o in opts},  # first trip: no habit yet
-    }
-
-
-def rank(values):
-    """Normalise by the sum of DISTINCT values, as Determinant.rankOptions does."""
-    s = sum(set(values.values())) or 1.0
-    return {k: v / s for k, v in values.items()}
-
-
-def aggregate(children, options):
-    """Parent raw value per option = sum of rank(child) * child_weight."""
-    acc = {o: 0.0 for o in options}
-    for weight, child_raw in children:
-        cn = rank(child_raw)
-        for o in options:
-            acc[o] += cn[o] * weight
-    return acc
-
-
-def tib_eu(leaf, weights, options):
-    price_time = aggregate([(weights["time"], leaf["time"]), (weights["cost"], leaf["cost"])], options)
-    evaluation = aggregate([(weights["evaluation"], price_time)], options)          # belief is null
-    attitude = evaluation                                                            # attitude has only evaluation
-    affect = aggregate([(weights["emotion"], leaf["emotion"])], options)
-    social = aggregate([(weights["norm"], leaf["norm"]), (weights["role"], leaf["role"]),
-                        (weights["self"], leaf["self"])], options)
-    intention = aggregate([(weights["affect"], affect), (weights["social"], social),
-                           (weights["attitude"], attitude)], options)
-    habits = aggregate([(weights["freq"], leaf["freq"])], options)
-    root = aggregate([(weights["intention"], intention), (weights["habit"], habits),
-                      (weights["facilitating"], leaf["facilitating"])], options)
-    return root
-
-
-def weights_of(agent):
-    return {
-        "time": float(agent["time_weight"]), "cost": float(agent["cost_weight"]),
-        "norm": float(agent["norm_weight"]), "role": float(agent["role_weight"]),
-        "self": float(agent["self_weight"]), "emotion": float(agent["emotion_weight"]),
-        "facilitating": float(agent["facilitating_weight"]), "freq": float(agent["frequency_weight"]),
-        "attitude": float(agent["attitude_weight"]), "social": float(agent["social_weight"]),
-        "affect": float(agent["affect_weight"]), "intention": float(agent["intention_weight"]),
-        "habit": float(agent["habit_weight"]), "evaluation": 1.0,
-    }
-
-
-def main():
-    agent_id = sys.argv[1] if len(sys.argv) > 1 else "1"
-    trip_idx = int(sys.argv[2]) if len(sys.argv) > 2 else 0
-
-    vehicles, name_to_id, locations, agents, schedule = load()
-    agent = agents[agent_id]
-    trips = [t for t in schedule if t["agent_id"] == agent_id]
-    trip = trips[trip_idx]
-
-    opts = feasible_options(agent, vehicles, name_to_id, locations, trip)
-    options = [o["name"] for o in opts]
-    leaf = leaf_values(opts, agent)
-    weights = weights_of(agent)
-    eu = tib_eu(leaf, weights, options)
-    winner = min(eu, key=eu.get)
-
-    order = sorted(options, key=lambda m: eu[m])
-    dets = ["time", "cost", "norm", "role", "self", "emotion", "facilitating", "freq"]
-
-    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(11, 4.2))
-    fig.suptitle(f"Agent {agent_id} ({locations[agent['loc_id']].get('name', agent['loc_id']) if 'name' in locations[agent['loc_id']] else agent['loc_id']}) "
-                 f"— {int(float(trip['km']))} km trip", fontsize=13)
-
-    ax1.barh(order[::-1], [eu[m] for m in order[::-1]], color=[MODE_COLOR.get(m, "#888") for m in order[::-1]])
-    ax1.set_title("Expected utility (lower = chosen)", fontsize=11)
+    """agent -> location, and agent -> first-trip {mode: (eu, chosen)}."""
+    if not os.path.exists(CSV):
+        print("No " + CSV + " yet -- run the simulation first (see README). Nothing to plot.")
+        sys.exit(0)
+    rows = list(csv.DictReader(open(CSV, newline="")))
+    loc = {}
+    trips = defaultdict(lambda: defaultdict(dict))   # agent -> start_time -> mode -> (eu, chosen)
+    for r in rows:
+        loc[r["agent"]] = r["location"]
+        trips[r["agent"]][float(r["start_time"])][r["mode"]] = (float(r["eu"]), r["chosen"] == "1")
+    first = {a: t[min(t)] for a, t in trips.items()}   # each agent's earliest trip
+    return loc, first
+
+
+def draw(ax, agent, location, modes):
+    order = sorted(modes, key=lambda m: modes[m][0])
+    ax.barh(range(len(order)), [modes[m][0] for m in order][::-1],
+            color=[COLOR.get(m, "#888") for m in order][::-1])
+    ax.set_yticks(range(len(order)))
+    ax.set_yticklabels([LABEL.get(m, m) for m in order[::-1]], fontsize=9)
     for i, m in enumerate(order[::-1]):
-        ax1.text(eu[m], i, f"  {eu[m]:.2f}" + ("  ← chosen" if m == winner else ""), va="center", fontsize=9)
-    ax1.margins(x=0.25)
+        eu, chosen = modes[m]
+        ax.text(eu, i, "  %.2f" % eu + ("  ← chosen" if chosen else ""), va="center", fontsize=8)
+    ax.set_title("Agent %s (%s)" % (agent, location), fontsize=11)
+    ax.margins(x=0.3)
+    ax.set_xlabel("expected utility (lower = chosen)", fontsize=8)
 
-    x = range(len(dets))
-    n = len(order)
-    w = 0.8 / n
-    for i, m in enumerate(order):
-        col = [leaf[d][m] for d in dets]
-        mx = [max(leaf[d].values()) or 1 for d in dets]
-        norm = [c / mmx for c, mmx in zip(col, mx)]
-        ax2.bar([xi + i * w for xi in x], norm, width=w, label=m, color=MODE_COLOR.get(m, "#888"))
-    ax2.set_title("Determinant profile (scaled, lower = preferred)", fontsize=11)
-    ax2.set_xticks([xi + w * (n - 1) / 2 for xi in x])
-    ax2.set_xticklabels(dets, rotation=40, ha="right", fontsize=9)
-    ax2.set_ylim(0, 1)
-    ax2.legend(fontsize=9, frameon=False)
 
-    fig.tight_layout(rect=[0, 0, 1, 0.94])
-    out = os.path.join(os.path.dirname(os.path.abspath(__file__)), f"tib_decision_agent{agent_id}.png")
+def main():
+    loc, first = load()
+    if len(sys.argv) > 1:
+        a = sys.argv[1]
+        if a not in first:
+            print("Agent %s not in %s" % (a, CSV)); sys.exit(0)
+        fig, ax = plt.subplots(figsize=(6, 3))
+        draw(ax, a, loc[a], first[a])
+        out = os.path.join(OUTDIR, "tib_decision_agent%s.png" % a)
+    else:
+        ags = sorted(first, key=lambda x: int(x))
+        n = len(ags)
+        fig, axes = plt.subplots((n + 1) // 2, 2, figsize=(11, 2.6 * ((n + 1) // 2)))
+        axes = axes.ravel()
+        for i, a in enumerate(ags):
+            draw(axes[i], a, loc[a], first[a])
+        for j in range(n, len(axes)):
+            axes[j].axis("off")
+        out = os.path.join(OUTDIR, "tib_decisions.png")
+    fig.tight_layout()
     fig.savefig(out, dpi=130)
-    print(f"Wrote {out}: options {options}, EU {{" + ", ".join(f'{m}:{eu[m]:.2f}' for m in order) + f"}}, chosen {winner}")
+    print("Wrote " + out)
 
 
 if __name__ == "__main__":
diff --git a/src/dummy/agent/DummyDecisionComponent.java b/src/dummy/agent/DummyDecisionComponent.java
index eb26e17..cfb0061 100644
--- a/src/dummy/agent/DummyDecisionComponent.java
+++ b/src/dummy/agent/DummyDecisionComponent.java
@@ -1,11 +1,14 @@
 package dummy.agent;
 
+import java.util.HashMap;
 import java.util.Map;
 import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 
 import org.apache.log4j.Level;
 import org.apache.log4j.Logger;
 
+import dummy.concept.MobilityOption;
 import framework.agent.core.DecisionComponent;
 import framework.agent.reasoning.Determinant;
 import framework.agent.reasoning.TIBModel;
@@ -16,6 +19,10 @@ public class DummyDecisionComponent extends TIBModel implements DecisionComponen
 
 	private static Logger LOGGER = Logger.getLogger(DummyDecisionComponent.class.getName());
 
+	// Expected utility per mode for each trip, keyed by task executing time.
+	// Recorded so the reporter can export the model's real decision output.
+	private final Map<Double, Map<String, Double>> euByTime = new ConcurrentHashMap<Double, Map<String, Double>>();
+
 	public DummyDecisionComponent(Determinant belief, Determinant evaluation, Determinant norm, Determinant role,
 			Determinant self_concept, Determinant emotion, Determinant facilitatingCond, Determinant freq,
 			double attitudeWeight, double socialWeight, double affectWeight, double intentionWeight,
@@ -29,7 +36,21 @@ public DummyDecisionComponent(Determinant belief, Determinant evaluation, Determ
 	public Map<Double, Set<Option>> evaluateOptions(Set<Option> options, Task task) {
 		// Get the list of all ranked options from agent's decision making model.
 		LOGGER.log(Level.DEBUG, "Rank options" + options.toString());
-		return rankOptions(options, task);
+		Map<Double, Set<Option>> result = rankOptions(options, task);
+		// Record the expected utility (map key) of each option for this trip.
+		Map<String, Double> perMode = new HashMap<String, Double>();
+		for (Map.Entry<Double, Set<Option>> entry : result.entrySet()) {
+			for (Option opt : entry.getValue()) {
+				perMode.put(((MobilityOption) opt).getMainVehicle().getName(), entry.getKey());
+			}
+		}
+		this.euByTime.put(task.getExecutingTime(), perMode);
+		return result;
+	}
+
+	/** Expected utility per mode for each trip (task executing time -&gt; mode -&gt; EU). */
+	public Map<Double, Map<String, Double>> getEuByTime() {
+		return this.euByTime;
 	}
 
 }
diff --git a/src/dummy/agent/DummyPerceptionComponent.java b/src/dummy/agent/DummyPerceptionComponent.java
index 753901e..7377b68 100644
--- a/src/dummy/agent/DummyPerceptionComponent.java
+++ b/src/dummy/agent/DummyPerceptionComponent.java
@@ -12,11 +12,9 @@
 import dummy.concept.Vehicle;
 import framework.agent.core.PerceptionComponent;
 import framework.concept.EnvironmentalState;
-import framework.concept.Feedback;
 import framework.concept.InternalState;
 import framework.concept.Option;
 import framework.concept.Task;
-import framework.environment.Environment;
 
 public class DummyPerceptionComponent implements PerceptionComponent {
 
@@ -56,9 +54,4 @@ public Set<Option> generateOptions(Task task, EnvironmentalState environmentalSt
 		return opts;
 	}
 
-	@Override
-	public Feedback getFeedback(Task task, Option pickedOption, Environment environment) {
-		return null;
-	}
-
 }
diff --git a/src/dummy/agent/StandardDummyAgent.java b/src/dummy/agent/StandardDummyAgent.java
index 68c61ea..787c7cc 100644
--- a/src/dummy/agent/StandardDummyAgent.java
+++ b/src/dummy/agent/StandardDummyAgent.java
@@ -114,29 +114,39 @@ protected DecisionComponent createDecisionComponent() {
 				this.attitudeWeight, this.socialWeight, this.affectWeight, this.intentionWeight, this.habitWeight);
 	}
 
+	/**
+	 * Expected utility per mode for each trip (task executing time -&gt; mode -&gt; EU),
+	 * as computed by this agent's decision component. Used by the reporter to
+	 * export the full decision, not just the chosen mode.
+	 */
+	public Map<Double, Map<String, Double>> getEuByTime() {
+		return ((DummyDecisionComponent) this.decisionComponent).getEuByTime();
+	}
+
 	/*******************************************************************************************/
 	private Determinant createBeliefDeterminant() {
-		// TODO Auto-generated method stub
-		return null;
+		// Belief: how reliably the agent expects this mode to work as intended
+		// (e.g. arriving on time, no breakdown/cancellation risk).
+		return new LeafDeterminant("belief", this.beliefWeight) {
+			@Override
+			protected double evalOpt(Option opt, Task task) {
+				return logged("BELIEF", opt, lookup(RELIABILITY, modeOf(opt)));
+			}
+		};
 	}
 
 	private Determinant createEvaluationDeterminant() {
 		ParentDeterminant evaluation = new ParentDeterminant("evaluation", this.evaluationWeight);
 		evaluation.addDeterminantChild(new LeafDeterminant("time", this.timeWeight) {
-
 			@Override
 			protected double evalOpt(Option opt, Task task) {
-				MobilityOption mobilityOpt = (MobilityOption) opt;
-				LOGGER.log(Level.DEBUG, "Evaluating TIME option " + mobilityOpt.getTime());
-				return mobilityOpt.getTime();
+				return logged("TIME", opt, ((MobilityOption) opt).getTime());
 			}
 		});
 		evaluation.addDeterminantChild(new LeafDeterminant("cost", this.costWeight) {
 			@Override
 			protected double evalOpt(Option opt, Task task) {
-				MobilityOption mobilityOption = (MobilityOption) opt;
-				LOGGER.log(Level.DEBUG, "Evaluating COST option " + mobilityOption.getCost());
-				return mobilityOption.getCost();
+				return logged("COST", opt, ((MobilityOption) opt).getCost());
 			}
 		});
 		LOGGER.log(Level.DEBUG, " Evalutation " + evaluation.toString());
@@ -234,6 +244,7 @@ private static double lookup(Map<String, Double> table, String mode) {
 	private static final Map<String, Double> EMISSIONS     = penalties(1, 2, 1, 3, 0, 0);
 	private static final Map<String, Double> DISCOMFORT    = penalties(1, 2, 1, 0, 3, 2);
 	private static final Map<String, Double> INCONVENIENCE = penalties(1, 2, 1, 0, 0, 0);
+	private static final Map<String, Double> RELIABILITY   = penalties(1, 2, 1, 1, 0, 0);
 
 	private static Map<String, Double> penalties(double train, double bus, double tram, double car, double walking,
 			double biking) {
diff --git a/src/dummy/report/DummyReporter.java b/src/dummy/report/DummyReporter.java
index aafa7e4..049c1ba 100644
--- a/src/dummy/report/DummyReporter.java
+++ b/src/dummy/report/DummyReporter.java
@@ -1,7 +1,14 @@
 package dummy.report;
 
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.HashMap;
 import java.util.Map;
 
+import org.apache.log4j.Level;
+import org.apache.log4j.Logger;
+
 import dummy.agent.StandardDummyAgent;
 import dummy.concept.MobilityOption;
 import dummy.concept.MobilityTask;
@@ -13,10 +20,12 @@
 
 /**
  * Decide output information of the simulator.
- * 
+ *
  * @author Khoa Nguyen
  */
 public class DummyReporter implements IReporter {
+
+	private static Logger LOGGER = Logger.getLogger(DummyReporter.class.getName());
 	private AgentContext agentContext;
 
 	public DummyReporter(AgentContext agentContext) {
@@ -37,7 +46,51 @@ public String printReport() {
 						+ mobilityTask.getDistance() + "," + mobilityOption.getMainVehicle().getName() + "\n";
 			}
 		}
-
+		writeDecisionsCsv();
 		return reportString;
 	}
+
+	/**
+	 * Write the full decision of every trip (expected utility of each option and
+	 * which one was chosen) to output/decisions.csv. This is the model's own
+	 * output; the analysis tools (analysis/plot_tib.py, analysis/tib_dashboard.html)
+	 * read it rather than recomputing the decision.
+	 */
+	private void writeDecisionsCsv() {
+		File dir = new File("output");
+		if (!dir.exists()) {
+			dir.mkdirs();
+		}
+		try (FileWriter w = new FileWriter(new File(dir, "decisions.csv"))) {
+			w.write("agent,location,start_time,km,mode,eu,chosen\n");
+			for (IAgent agent : this.agentContext) {
+				StandardDummyAgent a = (StandardDummyAgent) agent;
+				String location = ((Location) a.getLoc()).getName();
+				Map<Double, Map<String, Double>> euByTime = a.getEuByTime();
+
+				// From the chosen decisions: trip distance and the picked mode per trip.
+				Map<Double, Double> kmByTime = new HashMap<Double, Double>();
+				Map<Double, String> chosenByTime = new HashMap<Double, String>();
+				for (Map.Entry<Task, Option> e : a.getDecisionResults().entrySet()) {
+					MobilityTask t = (MobilityTask) e.getKey();
+					kmByTime.put(t.getExecutingTime(), t.getDistance());
+					chosenByTime.put(t.getExecutingTime(), ((MobilityOption) e.getValue()).getMainVehicle().getName());
+				}
+
+				for (Map.Entry<Double, Map<String, Double>> trip : euByTime.entrySet()) {
+					double time = trip.getKey();
+					Double km = kmByTime.get(time);
+					String chosen = chosenByTime.get(time);
+					for (Map.Entry<String, Double> mode : trip.getValue().entrySet()) {
+						w.write(agent.getID() + "," + location + "," + time + "," + (km == null ? "" : km) + ","
+								+ mode.getKey() + "," + mode.getValue() + ","
+								+ (mode.getKey().equals(chosen) ? "1" : "0") + "\n");
+					}
+				}
+			}
+			LOGGER.log(Level.DEBUG, "Wrote output/decisions.csv");
+		} catch (IOException ex) {
+			LOGGER.log(Level.WARN, "Could not write output/decisions.csv", ex);
+		}
+	}
 }
diff --git a/src/dummy/simulator/ThreadedAgentScheduler.java b/src/dummy/simulator/ThreadedAgentScheduler.java
index 6191773..5a1c83c 100644
--- a/src/dummy/simulator/ThreadedAgentScheduler.java
+++ b/src/dummy/simulator/ThreadedAgentScheduler.java
@@ -114,6 +114,19 @@ public void run() {
 
 		for (IAgent b : this.cc.getScheduledAgentList()) {
 
+			if (!b.isThreadable()) {
+				// Agents that opt out of threading (e.g. because they have inter-agent
+				// state, such as social-network influence) are stepped synchronously here,
+				// rather than being handed to a thread on a free CPU.
+				try {
+					b.step();
+				} catch (Exception ex) {
+					LOGGER.log(Level.FATAL, "ThreadedAgentScheduler caught an error, telling model to stop", ex);
+					ContextManager.stopSim(ex, this.getClass());
+				}
+				continue;
+			}
+
 			// Find a free cpu to exectue on
 			boolean foundFreeCPU = false;
 			// Determine if there are no free CPUs so thread can wait for one to
diff --git a/src/framework/agent/core/PerceptionComponent.java b/src/framework/agent/core/PerceptionComponent.java
index 6f6c869..9783349 100644
--- a/src/framework/agent/core/PerceptionComponent.java
+++ b/src/framework/agent/core/PerceptionComponent.java
@@ -3,11 +3,9 @@
 import java.util.Set;
 
 import framework.concept.EnvironmentalState;
-import framework.concept.Feedback;
 import framework.concept.InternalState;
 import framework.concept.Option;
 import framework.concept.Task;
-import framework.environment.Environment;
 
 public interface PerceptionComponent {
 
@@ -28,19 +26,4 @@ public interface PerceptionComponent {
 	 */
 	Set<Option> generateOptions(Task task, EnvironmentalState environmentalState,
 			InternalState internalState);
-	/**
-	 * Get feedback from the environment about the action performed. The
-	 * information/properties storing in Feedback can be included in the
-	 * implementation of Feedback.
-	 *
-	 * @param task
-	 *            The current task that the agent wants to perform.
-	 * @param pickedOption
-	 *            The action that was chosen by the agent.
-	 * @param environment
-	 *            The environment where the agent lives.
-	 * @return The feedback from the environment about the action performed. (To be
-	 *         implemented)
-	 */
-	Feedback getFeedback(Task task, Option pickedOption, Environment environment);
 }
diff --git a/src/framework/agent/core/TaskExecutionAgent.java b/src/framework/agent/core/TaskExecutionAgent.java
index 16e8b14..88efe18 100644
--- a/src/framework/agent/core/TaskExecutionAgent.java
+++ b/src/framework/agent/core/TaskExecutionAgent.java
@@ -89,6 +89,10 @@ public void step() throws Exception {
 		Set<Option> options = this.perceptionComponent.generateOptions(task, environmentalState, internalState);
 		Map<Double, Set<Option>> evaluatedOptions = this.decisionComponent.evaluateOptions(options, task);
 		Option pickedOption = this.communicationComponent.pickOption(evaluatedOptions);
+		if (pickedOption == null) {
+			LOGGER.log(Level.WARN, "Agent " + this.id + " had no viable option for task " + task + "; skipping.");
+			return;
+		}
 		Feedback feedback = this.communicationComponent.getFeedback(task, pickedOption, internalState, this.loc);
 		this.memoryComponent.updateInternalState(task, pickedOption, feedback);
 	}
@@ -131,7 +135,7 @@ public Map<Task, Option> getDecisionResults() {
 	}
 
 	@Override
-	public final boolean isThreadable() {
+	public boolean isThreadable() {
 		return true;
 	}
 
diff --git a/src/framework/agent/reasoning/TPBModel.java b/src/framework/agent/reasoning/TPBModel.java
index edcb27f..a409918 100644
--- a/src/framework/agent/reasoning/TPBModel.java
+++ b/src/framework/agent/reasoning/TPBModel.java
@@ -1,8 +1,7 @@
 package framework.agent.reasoning;
 
 public class TPBModel extends ParentDeterminant {
-	public TPBModel(Determinant attitude, Determinant norm, Determinant behaviouralControl, double attitudeWeight,
-			double behaviouralControlWeight, double normWeight, double intentionWeight) {
+	public TPBModel(Determinant attitude, Determinant norm, Determinant behaviouralControl, double intentionWeight) {
 		super("FishbeinAndAjzen", 1);
 		ParentDeterminant intention = new ParentDeterminant("intention", intentionWeight);
 
diff --git a/src/framework/exception/AgentCreationException.java b/src/framework/exception/AgentCreationException.java
deleted file mode 100644
index 19a1fc1..0000000
--- a/src/framework/exception/AgentCreationException.java
+++ /dev/null
@@ -1,15 +0,0 @@
-package framework.exception;
-
-public class AgentCreationException extends Exception {
-
-	private static final long serialVersionUID = 1L;
-
-	public AgentCreationException(String message) {
-		super(message);
-	}
-
-	public AgentCreationException(Throwable cause) {
-		super(cause);
-	}
-
-}
diff --git a/src/framework/exception/DuplicateIdentifierException.java b/src/framework/exception/DuplicateIdentifierException.java
deleted file mode 100644
index db17491..0000000
--- a/src/framework/exception/DuplicateIdentifierException.java
+++ /dev/null
@@ -1,11 +0,0 @@
-package framework.exception;
-
-public class DuplicateIdentifierException extends Exception {
-
-	private static final long serialVersionUID = 1L;
-
-	public DuplicateIdentifierException(String message) {
-		super(message);
-	}
-
-}
diff --git a/src/framework/exception/MissingElementException.java b/src/framework/exception/MissingElementException.java
deleted file mode 100644
index 401e47f..0000000
--- a/src/framework/exception/MissingElementException.java
+++ /dev/null
@@ -1,11 +0,0 @@
-package framework.exception;
-
-public class MissingElementException extends Exception {
-
-	private static final long serialVersionUID = 1L;
-
-	public MissingElementException(String message) {
-		super(message);
-	}
-
-}
diff --git a/src/framework/exception/NoIdentifierException.java b/src/framework/exception/NoIdentifierException.java
deleted file mode 100644
index 918a5f7..0000000
--- a/src/framework/exception/NoIdentifierException.java
+++ /dev/null
@@ -1,11 +0,0 @@
-package framework.exception;
-
-public class NoIdentifierException extends Exception {
-
-	private static final long serialVersionUID = 1L;
-
-	public NoIdentifierException(String message) {
-		super(message);
-	}
-
-}
diff --git a/src/framework/exception/ParameterNotFoundException.java b/src/framework/exception/ParameterNotFoundException.java
deleted file mode 100644
index f9821fe..0000000
--- a/src/framework/exception/ParameterNotFoundException.java
+++ /dev/null
@@ -1,11 +0,0 @@
-package framework.exception;
-
-public class ParameterNotFoundException extends Exception {
-
-	private static final long serialVersionUID = 1L;
-
-	public ParameterNotFoundException(String param) {
-		super("Could not find the Simphony parameter " + param + ". Has it been specified in parameters.xml ?");
-	}
-
-}

From e67b4d1fdbda9aecd620357b7f6cd5c824d46f47 Mon Sep 17 00:00:00 2001
From: Amy Liffey <amy.liffey@hes-so.ch>
Date: Mon, 6 Jul 2026 21:03:51 +0200
Subject: [PATCH 10/25] chore: improve workflow

---
 .github/workflows/ant.yml       | 33 ++++++++++-------
 analysis/summarize_decisions.py | 66 +++++++++++++++++++++++++++++++++
 2 files changed, 86 insertions(+), 13 deletions(-)
 create mode 100644 analysis/summarize_decisions.py

diff --git a/.github/workflows/ant.yml b/.github/workflows/ant.yml
index 63e4900..71f0322 100644
--- a/.github/workflows/ant.yml
+++ b/.github/workflows/ant.yml
@@ -1,4 +1,5 @@
-# This workflow will build a Java project with Ant
+# This workflow builds the Java project with Ant, runs the tests, then runs the
+# model headlessly and renders its real decision output onto the run summary.
 # For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-java-with-ant
 
 name: BedDeM CI
@@ -53,23 +54,29 @@ jobs:
         name: junit-report
         path: junit/
 
-  visualize:
-    # Fast, standalone job: renders the TIB decision charts from data/*.csv.
-    # No Repast needed, so it does not depend on the build job.
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
+    # ---- Run the model and show its real decision output ---------------------
+    # The batch (headless) run drives DummyReporter, which writes
+    # output/decisions.csv. output/ is gitignored, so this is produced fresh in
+    # the pipeline on every run -- nothing is committed.
+    - name: Run model (batch)
+      run: ant batch-model "-DECLIPSE_HOME=$(pwd)"
     - name: Set up Python
+      if: always()
       uses: actions/setup-python@v5
       with:
         python-version: '3.11'
-    - name: Render TIB decision charts
+    - name: Summarise decisions to run summary
+      if: always()          # still report (or note "no output") if the run failed
+      run: python analysis/summarize_decisions.py >> "$GITHUB_STEP_SUMMARY"
+    - name: Render decision chart
+      if: always()
       run: |
         pip install matplotlib
-        for a in 1 2 3 4; do python analysis/plot_tib.py $a 0; done
-    - name: Upload TIB charts
+        python analysis/plot_tib.py
+    - name: Upload decision chart
+      if: always()
       uses: actions/upload-artifact@v4
       with:
-        name: tib-charts
-        path: analysis/tib_decision_agent*.png
-
+        name: tib-decisions
+        path: analysis/tib_decisions.png
+        if-no-files-found: ignore
diff --git a/analysis/summarize_decisions.py b/analysis/summarize_decisions.py
new file mode 100644
index 0000000..a76c28c
--- /dev/null
+++ b/analysis/summarize_decisions.py
@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+"""Summarise the model's decision results as a Markdown table.
+
+Reads ``output/decisions.csv`` (written by DummyReporter during a simulation
+run) and prints a GitHub-flavoured Markdown table to stdout: one row per trip,
+listing every mode's expected utility (EU, lower = better) with the chosen mode
+highlighted. Intended to be appended to $GITHUB_STEP_SUMMARY in CI so the real
+decision output shows up on the workflow run, but it also just works locally.
+
+Usage:  python analysis/summarize_decisions.py
+"""
+import csv
+import os
+import sys
+from collections import defaultdict
+
+ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+CSV = os.path.join(ROOT, "output", "decisions.csv")
+LABEL = {"car": "Car", "train": "Train", "biking": "Bike",
+         "walking": "Walk", "bus": "Bus", "tram": "Tram"}
+
+
+def main():
+    if not os.path.exists(CSV):
+        print("> **No decision output found.** `output/decisions.csv` was not "
+              "produced by the run — nothing to summarise.")
+        return
+
+    rows = list(csv.DictReader(open(CSV, newline="")))
+    if not rows:
+        print("> **`output/decisions.csv` is empty** — nothing to summarise.")
+        return
+
+    loc = {}
+    # agent -> start_time -> {mode: (eu, chosen)}
+    trips = defaultdict(lambda: defaultdict(dict))
+    for r in rows:
+        loc[r["agent"]] = r["location"]
+        trips[r["agent"]][float(r["start_time"])][r["mode"]] = (
+            float(r["eu"]), r["chosen"] == "1")
+
+    print("## TIB decision results\n")
+    print("Expected utility per mode (**lower = chosen**), from the batch run's "
+          "`output/decisions.csv`.\n")
+    print("| Agent | Location | Trip start | Modes considered (EU) | Chosen |")
+    print("|:-----:|:---------|:----------:|:----------------------|:------:|")
+
+    for a in sorted(trips, key=lambda x: int(x)):
+        for t in sorted(trips[a]):
+            modes = trips[a][t]
+            chosen = next((m for m, (eu, c) in modes.items() if c), None)
+            ranked = sorted(modes.items(), key=lambda kv: kv[1][0])
+            cells = []
+            for m, (eu, c) in ranked:
+                name = LABEL.get(m, m)
+                cells.append("**%s %.2f**" % (name, eu) if c
+                             else "%s %.2f" % (name, eu))
+            chosen_lbl = LABEL.get(chosen, chosen) if chosen else "—"
+            print("| %s | %s | %g | %s | **%s** |"
+                  % (a, loc[a], t, ", ".join(cells), chosen_lbl))
+
+    print()
+
+
+if __name__ == "__main__":
+    main()

From d57b9eacb93c8c756b9602931edc81417c377ac6 Mon Sep 17 00:00:00 2001
From: Amy Liffey <amy.liffey@hes-so.ch>
Date: Mon, 6 Jul 2026 21:20:09 +0200
Subject: [PATCH 11/25] chore: imrpove

---
 .github/workflows/ant.yml       | 12 +++++-
 analysis/summarize_decisions.py | 73 ++++++++++++++++++++++-----------
 2 files changed, 60 insertions(+), 25 deletions(-)

diff --git a/.github/workflows/ant.yml b/.github/workflows/ant.yml
index 71f0322..bffaef7 100644
--- a/.github/workflows/ant.yml
+++ b/.github/workflows/ant.yml
@@ -65,9 +65,17 @@ jobs:
       uses: actions/setup-python@v5
       with:
         python-version: '3.11'
-    - name: Summarise decisions to run summary
+    - name: Summarise decisions
       if: always()          # still report (or note "no output") if the run failed
-      run: python analysis/summarize_decisions.py >> "$GITHUB_STEP_SUMMARY"
+      run: |
+        python analysis/summarize_decisions.py > decision_summary.md
+        cat decision_summary.md >> "$GITHUB_STEP_SUMMARY"
+    - name: Post decision results to PR
+      if: always() && github.event_name == 'pull_request'
+      uses: marocchino/sticky-pull-request-comment@v2
+      with:
+        header: tib-decisions          # one comment, updated on each run
+        path: decision_summary.md
     - name: Render decision chart
       if: always()
       run: |
diff --git a/analysis/summarize_decisions.py b/analysis/summarize_decisions.py
index a76c28c..7bd1dc5 100644
--- a/analysis/summarize_decisions.py
+++ b/analysis/summarize_decisions.py
@@ -1,11 +1,11 @@
 #!/usr/bin/env python3
-"""Summarise the model's decision results as a Markdown table.
+"""Summarise the model's decision results as Markdown (table + text bar charts).
 
 Reads ``output/decisions.csv`` (written by DummyReporter during a simulation
-run) and prints a GitHub-flavoured Markdown table to stdout: one row per trip,
-listing every mode's expected utility (EU, lower = better) with the chosen mode
-highlighted. Intended to be appended to $GITHUB_STEP_SUMMARY in CI so the real
-decision output shows up on the workflow run, but it also just works locally.
+run) and prints GitHub-flavoured Markdown to stdout: an overview table plus a
+per-trip Unicode bar chart of each mode's expected utility (EU, lower = better),
+with the chosen mode highlighted. Text bars render inline in a PR comment and in
+the workflow run summary, so no image hosting is needed.
 
 Usage:  python analysis/summarize_decisions.py
 """
@@ -18,19 +18,11 @@
 CSV = os.path.join(ROOT, "output", "decisions.csv")
 LABEL = {"car": "Car", "train": "Train", "biking": "Bike",
          "walking": "Walk", "bus": "Bus", "tram": "Tram"}
+BAR_WIDTH = 24   # max characters for the longest bar in a trip
 
 
-def main():
-    if not os.path.exists(CSV):
-        print("> **No decision output found.** `output/decisions.csv` was not "
-              "produced by the run — nothing to summarise.")
-        return
-
+def load():
     rows = list(csv.DictReader(open(CSV, newline="")))
-    if not rows:
-        print("> **`output/decisions.csv` is empty** — nothing to summarise.")
-        return
-
     loc = {}
     # agent -> start_time -> {mode: (eu, chosen)}
     trips = defaultdict(lambda: defaultdict(dict))
@@ -38,13 +30,12 @@ def main():
         loc[r["agent"]] = r["location"]
         trips[r["agent"]][float(r["start_time"])][r["mode"]] = (
             float(r["eu"]), r["chosen"] == "1")
+    return loc, trips
 
-    print("## TIB decision results\n")
-    print("Expected utility per mode (**lower = chosen**), from the batch run's "
-          "`output/decisions.csv`.\n")
-    print("| Agent | Location | Trip start | Modes considered (EU) | Chosen |")
-    print("|:-----:|:---------|:----------:|:----------------------|:------:|")
 
+def table(loc, trips):
+    out = ["| Agent | Location | Trip start | Modes considered (EU) | Chosen |",
+           "|:-----:|:---------|:----------:|:----------------------|:------:|"]
     for a in sorted(trips, key=lambda x: int(x)):
         for t in sorted(trips[a]):
             modes = trips[a][t]
@@ -56,10 +47,46 @@ def main():
                 cells.append("**%s %.2f**" % (name, eu) if c
                              else "%s %.2f" % (name, eu))
             chosen_lbl = LABEL.get(chosen, chosen) if chosen else "—"
-            print("| %s | %s | %g | %s | **%s** |"
-                  % (a, loc[a], t, ", ".join(cells), chosen_lbl))
+            out.append("| %s | %s | %g | %s | **%s** |"
+                       % (a, loc[a], t, ", ".join(cells), chosen_lbl))
+    return "\n".join(out)
+
 
-    print()
+def bars(loc, trips):
+    out = []
+    for a in sorted(trips, key=lambda x: int(x)):
+        for t in sorted(trips[a]):
+            modes = trips[a][t]
+            ranked = sorted(modes.items(), key=lambda kv: kv[1][0])
+            mx = max(eu for _, (eu, _) in ranked) or 1.0
+            out.append("Agent %s (%s) — trip start %g" % (a, loc[a], t))
+            for m, (eu, c) in ranked:
+                fill = max(1, round(eu / mx * BAR_WIDTH))
+                name = LABEL.get(m, m).ljust(5)
+                out.append("  %s %s %.2f%s"
+                           % (name, "█" * fill, eu, "  <- chosen" if c else ""))
+            out.append("")
+    return "```\n" + "\n".join(out).rstrip() + "\n```"
+
+
+def main():
+    if not os.path.exists(CSV):
+        print("> **No decision output found.** `output/decisions.csv` was not "
+              "produced by the run — nothing to summarise.")
+        return
+    loc, trips = load()
+    if not trips:
+        print("> **`output/decisions.csv` is empty** — nothing to summarise.")
+        return
+
+    print("## TIB decision results\n")
+    print("Expected utility per mode (**lower = chosen**), from the batch "
+          "run's `output/decisions.csv`.\n")
+    print(table(loc, trips))
+    print("\n### Decision charts (EU per mode, shorter = preferred)\n")
+    print(bars(loc, trips))
+    print("\n_A higher-resolution `tib_decisions.png` chart is attached to this "
+          "workflow run under **Artifacts**._")
 
 
 if __name__ == "__main__":

From 4d0891a3c3dfc31dc96cf56f5ee0fd0d1a7a0bde Mon Sep 17 00:00:00 2001
From: Amy Liffey <amy.liffey@hes-so.ch>
Date: Mon, 6 Jul 2026 21:39:26 +0200
Subject: [PATCH 12/25] chore: workflow

---
 .github/workflows/ant.yml | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/ant.yml b/.github/workflows/ant.yml
index bffaef7..fdb84de 100644
--- a/.github/workflows/ant.yml
+++ b/.github/workflows/ant.yml
@@ -19,6 +19,7 @@ jobs:
     permissions:
       checks: write
       pull-requests: write
+      issues: write
       contents: read
 
     steps:
@@ -71,7 +72,10 @@ jobs:
         python analysis/summarize_decisions.py > decision_summary.md
         cat decision_summary.md >> "$GITHUB_STEP_SUMMARY"
     - name: Post decision results to PR
-      if: always() && github.event_name == 'pull_request'
+      # Skipped automatically for PRs from forks (their token is read-only and
+      # cannot comment); the results still appear in the run summary + artifact.
+      if: always() && github.event_name == 'pull_request' && github.event.pull_request.head.repo.fork == false
+      continue-on-error: true          # never fail the build just over the comment
       uses: marocchino/sticky-pull-request-comment@v2
       with:
         header: tib-decisions          # one comment, updated on each run

From 08e5c21dbcce0bf895809ca14a01c9e406857435 Mon Sep 17 00:00:00 2001
From: Amy Liffey <amy.liffey@hes-so.ch>
Date: Mon, 6 Jul 2026 22:01:06 +0200
Subject: [PATCH 13/25] chore: fix tests

---
 .github/workflows/ant.yml              | 19 ++++++++++++++++++-
 test/beddem_simulator/ContextTest.java |  3 ++-
 2 files changed, 20 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/ant.yml b/.github/workflows/ant.yml
index fdb84de..b043409 100644
--- a/.github/workflows/ant.yml
+++ b/.github/workflows/ant.yml
@@ -60,7 +60,24 @@ jobs:
     # output/decisions.csv. output/ is gitignored, so this is produced fresh in
     # the pipeline on every run -- nothing is committed.
     - name: Run model (batch)
-      run: ant batch-model "-DECLIPSE_HOME=$(pwd)"
+      continue-on-error: true          # keep going so we can locate output + diagnose
+      run: |
+        rm -f output/decisions.csv
+        ant batch-model "-DECLIPSE_HOME=$(pwd)"
+    - name: Locate decision output
+      if: always()
+      # Repast's batch runner executes each run in its own instance directory, so
+      # DummyReporter's relative "output/decisions.csv" may land there rather than
+      # at the repo root. Find whatever the run produced and bring it back.
+      run: |
+        echo "Files produced by the run:"
+        find . -name 'decisions.csv' -o -name 'DummyOutput*.txt' 2>/dev/null || true
+        latest=$(find . -name 'decisions.csv' -printf '%T@ %p\n' 2>/dev/null | sort -nr | head -1 | cut -d' ' -f2-)
+        if [ -n "$latest" ] && [ "$latest" != "./output/decisions.csv" ]; then
+          mkdir -p output && cp "$latest" output/decisions.csv
+          echo "Copied $latest -> output/decisions.csv"
+        fi
+        echo "--- output/ ---"; ls -la output/ 2>&1 || echo "(no output dir)"
     - name: Set up Python
       if: always()
       uses: actions/setup-python@v5
diff --git a/test/beddem_simulator/ContextTest.java b/test/beddem_simulator/ContextTest.java
index 94c8b97..16c6d32 100644
--- a/test/beddem_simulator/ContextTest.java
+++ b/test/beddem_simulator/ContextTest.java
@@ -49,7 +49,8 @@ public void buildContextBuilder() {
 		// Return 3 contexts AgentContext, LocationContext, MainContext
 		assertEquals("Number of contexts", 3, returned_context.size());
 		assertEquals("Number of agents", 1, returned_context.getObjects(AgentContext.class).size());
-		assertEquals("Number of actionCounts", 3, RunEnvironment.getInstance().getCurrentSchedule().getActionCount());
+		// 4 agents x 2 trips scheduled + 1 reporter action = 9 (see data/schedule.0.csv).
+		assertEquals("Number of actionCounts", 9, RunEnvironment.getInstance().getCurrentSchedule().getActionCount());
 	}
 
 }

From cf6cbe0cd1dd52caf5a62a619f59fb161ec49e21 Mon Sep 17 00:00:00 2001
From: Amy Liffey <amy.liffey@hes-so.ch>
Date: Mon, 6 Jul 2026 22:08:27 +0200
Subject: [PATCH 14/25] chore: test

---
 .github/workflows/ant.yml | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/ant.yml b/.github/workflows/ant.yml
index b043409..0f5cbb5 100644
--- a/.github/workflows/ant.yml
+++ b/.github/workflows/ant.yml
@@ -61,9 +61,13 @@ jobs:
     # the pipeline on every run -- nothing is committed.
     - name: Run model (batch)
       continue-on-error: true          # keep going so we can locate output + diagnose
+      timeout-minutes: 10              # the batch GUI shouldn't idle; don't hang the job
       run: |
+        # Repast's batch runner opens a Swing window, which throws HeadlessException
+        # with no display. xvfb gives it a virtual X11 display so it can run in CI.
+        sudo apt-get update && sudo apt-get install -y xvfb
         rm -f output/decisions.csv
-        ant batch-model "-DECLIPSE_HOME=$(pwd)"
+        xvfb-run -a ant batch-model "-DECLIPSE_HOME=$(pwd)"
     - name: Locate decision output
       if: always()
       # Repast's batch runner executes each run in its own instance directory, so

From ef31de94fff780eb55c58d406ac5f26772433714 Mon Sep 17 00:00:00 2001
From: Amy Liffey <amy.liffey@hes-so.ch>
Date: Mon, 6 Jul 2026 22:28:43 +0200
Subject: [PATCH 15/25] chore: no ui

---
 .github/workflows/ant.yml | 11 +++++------
 build.xml                 |  9 +++++++++
 2 files changed, 14 insertions(+), 6 deletions(-)

diff --git a/.github/workflows/ant.yml b/.github/workflows/ant.yml
index 0f5cbb5..0a4d31d 100644
--- a/.github/workflows/ant.yml
+++ b/.github/workflows/ant.yml
@@ -59,15 +59,14 @@ jobs:
     # The batch (headless) run drives DummyReporter, which writes
     # output/decisions.csv. output/ is gitignored, so this is produced fresh in
     # the pipeline on every run -- nothing is committed.
-    - name: Run model (batch)
+    - name: Run model (headless batch)
       continue-on-error: true          # keep going so we can locate output + diagnose
-      timeout-minutes: 10              # the batch GUI shouldn't idle; don't hang the job
+      timeout-minutes: 10              # don't hang the job if the run stalls
       run: |
-        # Repast's batch runner opens a Swing window, which throws HeadlessException
-        # with no display. xvfb gives it a virtual X11 display so it can run in CI.
-        sudo apt-get update && sudo apt-get install -y xvfb
+        # Uses the batch-headless target (repast.simphony.batch.BatchMain), which
+        # runs with no Swing GUI -- so it works on the display-less CI runner.
         rm -f output/decisions.csv
-        xvfb-run -a ant batch-model "-DECLIPSE_HOME=$(pwd)"
+        ant batch-headless "-DECLIPSE_HOME=$(pwd)"
     - name: Locate decision output
       if: always()
       # Repast's batch runner executes each run in its own instance directory, so
diff --git a/build.xml b/build.xml
index a29a380..49803c3 100644
--- a/build.xml
+++ b/build.xml
@@ -395,6 +395,15 @@
             <classpath refid="run.Batch beddem_simulator Model.classpath"/>
         </java>
     </target>
+    <!-- Headless batch run for CI: uses BatchMain (no Swing GUI) so it works with
+         no display. Reuses the same classpath as the batch-model target. -->
+    <target name="batch-headless">
+        <java classname="repast.simphony.batch.BatchMain" failonerror="true" fork="yes">
+            <jvmarg line="-Djava.awt.headless=true -XX:+IgnoreUnrecognizedVMOptions --add-modules=ALL-SYSTEM --add-exports=java.base/jdk.internal.ref=ALL-UNNAMED"/>
+            <arg line="-pxml &quot;${workspace_loc:beddem_simulator}/batch/batch_params.xml&quot; &quot;${workspace_loc:beddem_simulator}/beddem_simulator.rs&quot;"/>
+            <classpath refid="run.Batch beddem_simulator Model.classpath"/>
+        </java>
+    </target>
     <target name="build-installer">
         <java classname="org.apache.tools.ant.launch.Launcher" failonerror="true" fork="yes">
             <jvmarg line="-XX:+IgnoreUnrecognizedVMOptions --add-modules=ALL-SYSTEM --add-exports=java.base/jdk.internal.ref=ALL-UNNAMED"/>

From 4c8deb638d676461c58e6d42f5d7169d1387f8a7 Mon Sep 17 00:00:00 2001
From: Amy Liffey <amy.liffey@hes-so.ch>
Date: Mon, 6 Jul 2026 22:54:49 +0200
Subject: [PATCH 16/25] chore: headless

---
 .github/workflows/ant.yml              |  9 +++--
 build.xml                              | 13 +++---
 test/beddem_simulator/HeadlessRun.java | 56 ++++++++++++++++++++++++++
 3 files changed, 67 insertions(+), 11 deletions(-)
 create mode 100644 test/beddem_simulator/HeadlessRun.java

diff --git a/.github/workflows/ant.yml b/.github/workflows/ant.yml
index 0a4d31d..9bd480d 100644
--- a/.github/workflows/ant.yml
+++ b/.github/workflows/ant.yml
@@ -59,14 +59,15 @@ jobs:
     # The batch (headless) run drives DummyReporter, which writes
     # output/decisions.csv. output/ is gitignored, so this is produced fresh in
     # the pipeline on every run -- nothing is committed.
-    - name: Run model (headless batch)
+    - name: Run model (headless)
       continue-on-error: true          # keep going so we can locate output + diagnose
       timeout-minutes: 10              # don't hang the job if the run stalls
       run: |
-        # Uses the batch-headless target (repast.simphony.batch.BatchMain), which
-        # runs with no Swing GUI -- so it works on the display-less CI runner.
+        # Runs the dummy (CSV) model headless via the run-headless target
+        # (beddem_simulator.HeadlessRun) -- no Swing GUI, so it works with no
+        # display. Produces output/decisions.csv.
         rm -f output/decisions.csv
-        ant batch-headless "-DECLIPSE_HOME=$(pwd)"
+        ant run-headless "-DECLIPSE_HOME=$(pwd)"
     - name: Locate decision output
       if: always()
       # Repast's batch runner executes each run in its own instance directory, so
diff --git a/build.xml b/build.xml
index 49803c3..7be9c82 100644
--- a/build.xml
+++ b/build.xml
@@ -395,13 +395,12 @@
             <classpath refid="run.Batch beddem_simulator Model.classpath"/>
         </java>
     </target>
-    <!-- Headless batch run for CI: uses BatchMain (no Swing GUI) so it works with
-         no display. Reuses the same classpath as the batch-model target. -->
-    <target name="batch-headless">
-        <java classname="repast.simphony.batch.BatchMain" failonerror="true" fork="yes">
-            <jvmarg line="-Djava.awt.headless=true -XX:+IgnoreUnrecognizedVMOptions --add-modules=ALL-SYSTEM --add-exports=java.base/jdk.internal.ref=ALL-UNNAMED"/>
-            <arg line="-pxml &quot;${workspace_loc:beddem_simulator}/batch/batch_params.xml&quot; &quot;${workspace_loc:beddem_simulator}/beddem_simulator.rs&quot;"/>
-            <classpath refid="run.Batch beddem_simulator Model.classpath"/>
+    <!-- Headless run for CI: runs the dummy (CSV) model with no Swing GUI, using
+         the same classpath as the JUnit tests. Produces output/decisions.csv. -->
+    <target name="run-headless">
+        <java classname="beddem_simulator.HeadlessRun" failonerror="true" fork="yes">
+            <jvmarg line="-ea -Djava.awt.headless=true -XX:+IgnoreUnrecognizedVMOptions --add-modules=ALL-SYSTEM --add-exports=java.base/jdk.internal.ref=ALL-UNNAMED"/>
+            <classpath refid="run.Test.classpath"/>
         </java>
     </target>
     <target name="build-installer">
diff --git a/test/beddem_simulator/HeadlessRun.java b/test/beddem_simulator/HeadlessRun.java
new file mode 100644
index 0000000..39e64ac
--- /dev/null
+++ b/test/beddem_simulator/HeadlessRun.java
@@ -0,0 +1,56 @@
+package beddem_simulator;
+
+import dummy.report.DummyReporter;
+import dummy.simulator.ContextManager;
+import repast.simphony.context.Context;
+import repast.simphony.context.DefaultContext;
+import repast.simphony.engine.environment.RunEnvironment;
+import repast.simphony.engine.environment.RunState;
+import repast.simphony.engine.schedule.ISchedule;
+import repast.simphony.engine.schedule.Schedule;
+import repast.simphony.parameter.DefaultParameters;
+
+/**
+ * Headless entry point for running the dummy (CSV-based) BedDeM model without the
+ * Repast GUI or the batch/SessionsDriver machinery.
+ *
+ * It sets up a minimal Repast RunEnvironment exactly like ContextTest, builds the
+ * context, runs the schedule to completion, and then invokes the reporter, which
+ * writes output/decisions.csv. This is what CI runs to produce the decision output.
+ */
+public class HeadlessRun {
+
+	public static void main(String[] args) {
+		Schedule schedule = new Schedule();
+
+		DefaultParameters parm = new DefaultParameters();
+		parm.addParameter("checkpoints_in_simulate", "Checkpoints in Simulate", Integer.class, 10, true);
+		parm.addParameter("periods_to_checkpoint", "Periods to checkpoint", Integer.class, 1, true);
+		parm.addParameter("agent_made_probabilistic_decision", "Agent made probabilistic decision", Integer.class, 0,
+				true);
+		parm.addParameter("properties_file_name", "Properties file name", String.class,
+				"beddem_simpleScenario.properties", true);
+
+		RunEnvironment.init(schedule, null, parm, false);
+		RunState.init().setMasterContext(new DefaultContext<Object>());
+
+		ContextManager builder = new ContextManager();
+		Context<Object> context = builder.build(new DefaultContext<Object>());
+
+		// Run the schedule to completion. updateSchedule re-schedules itself each
+		// period until the checkpoints are exhausted, so the schedule drains on its
+		// own; the guard is just a safety stop against an unexpected infinite loop.
+		ISchedule sched = RunEnvironment.getInstance().getCurrentSchedule();
+		int guard = 0;
+		while (sched.getActionCount() > 0 && guard++ < 1_000_000) {
+			sched.execute();
+		}
+		System.out.println("Schedule finished after " + sched.getTickCount() + " ticks.");
+
+		// Trigger the reporter -> writes output/decisions.csv (and prints the report).
+		for (Object o : context.getObjects(DummyReporter.class)) {
+			System.out.println(((DummyReporter) o).printReport());
+		}
+		System.out.println("Headless run complete.");
+	}
+}

From 5da35c0531171c04e2e1cc42dd739e2d0824a74e Mon Sep 17 00:00:00 2001
From: Amy Liffey <amy.liffey@hes-so.ch>
Date: Mon, 6 Jul 2026 23:03:03 +0200
Subject: [PATCH 17/25] chore: one day

---
 test/beddem_simulator/HeadlessRun.java | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/test/beddem_simulator/HeadlessRun.java b/test/beddem_simulator/HeadlessRun.java
index 39e64ac..350214b 100644
--- a/test/beddem_simulator/HeadlessRun.java
+++ b/test/beddem_simulator/HeadlessRun.java
@@ -24,7 +24,10 @@ public static void main(String[] args) {
 		Schedule schedule = new Schedule();
 
 		DefaultParameters parm = new DefaultParameters();
-		parm.addParameter("checkpoints_in_simulate", "Checkpoints in Simulate", Integer.class, 10, true);
+		// Number of days simulated. Each checkpoint replays the daily schedule
+		// (data/schedule.0.csv) offset by +24h, so trips per agent = daily trips x
+		// this value. 1 = a single day; raise it to show multi-day habit dynamics.
+		parm.addParameter("checkpoints_in_simulate", "Checkpoints in Simulate", Integer.class, 1, true);
 		parm.addParameter("periods_to_checkpoint", "Periods to checkpoint", Integer.class, 1, true);
 		parm.addParameter("agent_made_probabilistic_decision", "Agent made probabilistic decision", Integer.class, 0,
 				true);

From 5df982bc42b7ca0896191ae7e40f0d7b3003a7f9 Mon Sep 17 00:00:00 2001
From: Amy Liffey <amy.liffey@hes-so.ch>
Date: Tue, 7 Jul 2026 12:24:29 +0200
Subject: [PATCH 18/25] chore: adjust schedule

---
 analysis/summarize_decisions.py               | 32 ++++++++++-------
 data/schedule.0.csv                           | 18 +++++-----
 src/dummy/agent/DummyPerceptionComponent.java |  5 +--
 src/dummy/concept/MobilityTask.java           | 30 ++++++++++++++--
 src/dummy/database/CSVReader.java             | 34 ++++++++++++++-----
 src/dummy/environment/Location.java           |  4 +++
 src/dummy/report/DummyReporter.java           | 22 +++++++-----
 src/dummy/simulator/ContextManager.java       |  2 +-
 8 files changed, 103 insertions(+), 44 deletions(-)

diff --git a/analysis/summarize_decisions.py b/analysis/summarize_decisions.py
index 7bd1dc5..9475235 100644
--- a/analysis/summarize_decisions.py
+++ b/analysis/summarize_decisions.py
@@ -26,16 +26,19 @@ def load():
     loc = {}
     # agent -> start_time -> {mode: (eu, chosen)}
     trips = defaultdict(lambda: defaultdict(dict))
+    route = defaultdict(dict)   # agent -> start_time -> "From -> To"
     for r in rows:
         loc[r["agent"]] = r["location"]
-        trips[r["agent"]][float(r["start_time"])][r["mode"]] = (
-            float(r["eu"]), r["chosen"] == "1")
-    return loc, trips
+        t = float(r["start_time"])
+        trips[r["agent"]][t][r["mode"]] = (float(r["eu"]), r["chosen"] == "1")
+        if r.get("from") and r.get("to"):
+            route[r["agent"]][t] = "%s → %s" % (r["from"], r["to"])
+    return loc, trips, route
 
 
-def table(loc, trips):
-    out = ["| Agent | Location | Trip start | Modes considered (EU) | Chosen |",
-           "|:-----:|:---------|:----------:|:----------------------|:------:|"]
+def table(loc, trips, route):
+    out = ["| Agent | Home | Route | Trip start | Modes considered (EU) | Chosen |",
+           "|:-----:|:-----|:------|:----------:|:----------------------|:------:|"]
     for a in sorted(trips, key=lambda x: int(x)):
         for t in sorted(trips[a]):
             modes = trips[a][t]
@@ -47,19 +50,22 @@ def table(loc, trips):
                 cells.append("**%s %.2f**" % (name, eu) if c
                              else "%s %.2f" % (name, eu))
             chosen_lbl = LABEL.get(chosen, chosen) if chosen else "—"
-            out.append("| %s | %s | %g | %s | **%s** |"
-                       % (a, loc[a], t, ", ".join(cells), chosen_lbl))
+            r = route.get(a, {}).get(t, "—")
+            out.append("| %s | %s | %s | %g | %s | **%s** |"
+                       % (a, loc[a], r, t, ", ".join(cells), chosen_lbl))
     return "\n".join(out)
 
 
-def bars(loc, trips):
+def bars(loc, trips, route):
     out = []
     for a in sorted(trips, key=lambda x: int(x)):
         for t in sorted(trips[a]):
             modes = trips[a][t]
             ranked = sorted(modes.items(), key=lambda kv: kv[1][0])
             mx = max(eu for _, (eu, _) in ranked) or 1.0
-            out.append("Agent %s (%s) — trip start %g" % (a, loc[a], t))
+            r = route.get(a, {}).get(t)
+            head = "Agent %s (%s)" % (a, r) if r else "Agent %s (%s)" % (a, loc[a])
+            out.append("%s — trip start %g" % (head, t))
             for m, (eu, c) in ranked:
                 fill = max(1, round(eu / mx * BAR_WIDTH))
                 name = LABEL.get(m, m).ljust(5)
@@ -74,7 +80,7 @@ def main():
         print("> **No decision output found.** `output/decisions.csv` was not "
               "produced by the run — nothing to summarise.")
         return
-    loc, trips = load()
+    loc, trips, route = load()
     if not trips:
         print("> **`output/decisions.csv` is empty** — nothing to summarise.")
         return
@@ -82,9 +88,9 @@ def main():
     print("## TIB decision results\n")
     print("Expected utility per mode (**lower = chosen**), from the batch "
           "run's `output/decisions.csv`.\n")
-    print(table(loc, trips))
+    print(table(loc, trips, route))
     print("\n### Decision charts (EU per mode, shorter = preferred)\n")
-    print(bars(loc, trips))
+    print(bars(loc, trips, route))
     print("\n_A higher-resolution `tib_decisions.png` chart is attached to this "
           "workflow run under **Artifacts**._")
 
diff --git a/data/schedule.0.csv b/data/schedule.0.csv
index a4b5155..494f32f 100644
--- a/data/schedule.0.csv
+++ b/data/schedule.0.csv
@@ -1,9 +1,9 @@
-agent_id,start,km,time_limit,purpose
-1,8,18,2.5,2
-1,17,18,2.5,11
-2,8,18,2.5,2
-2,18,18,2.5,11
-3,7,18,3,2
-3,17,18,3,11
-4,8,18,2.5,2
-4,17,18,2.5,11
+agent_id,start,from_loc,to_loc,km,time_limit,purpose
+1,8,1,2,18,2.5,2
+1,17,2,1,18,2.5,11
+2,8,1,2,18,2.5,2
+2,18,2,1,18,2.5,11
+3,7,2,1,18,3,2
+3,17,1,2,18,3,11
+4,8,2,1,18,2.5,2
+4,17,1,2,18,2.5,11
diff --git a/src/dummy/agent/DummyPerceptionComponent.java b/src/dummy/agent/DummyPerceptionComponent.java
index 7377b68..dc05737 100644
--- a/src/dummy/agent/DummyPerceptionComponent.java
+++ b/src/dummy/agent/DummyPerceptionComponent.java
@@ -30,8 +30,9 @@ public DummyPerceptionComponent(String agentID) {
 	public Set<Option> generateOptions(Task task, EnvironmentalState environmentalState, InternalState internalState) {
 		Set<Vehicle> accessileVehicles = new HashSet<Vehicle>();
 		MobilityTask mobilityTask = (MobilityTask) task;
-		MobilityEnvironmentalState mobilityEnvStat = (MobilityEnvironmentalState) environmentalState;
-		accessileVehicles.addAll(mobilityEnvStat.getPublicTransports());
+		// Public transport available at the trip's ORIGIN (from_loc), not the
+		// agent's home location, so an evening return boards where it starts.
+		accessileVehicles.addAll(mobilityTask.getOriginTransports());
 		MobilityInternalState mobilityInternalStat = (MobilityInternalState) internalState;
 		accessileVehicles.addAll(mobilityInternalStat.getOwnVehicles());
 		String debugStr = "Task for agent" + this.agentID + "Task distance: " + mobilityTask.getDistance()
diff --git a/src/dummy/concept/MobilityTask.java b/src/dummy/concept/MobilityTask.java
index fe33aa2..33647c6 100644
--- a/src/dummy/concept/MobilityTask.java
+++ b/src/dummy/concept/MobilityTask.java
@@ -1,5 +1,8 @@
 package dummy.concept;
 
+import java.util.HashSet;
+import java.util.Set;
+
 import org.apache.log4j.Level;
 import org.apache.log4j.Logger;
 
@@ -12,10 +15,17 @@ public class MobilityTask extends Task {
 	private double distance;
 	private double timeStart;
 	private double purpose;
+	private String fromLoc;
+	private String toLoc;
+	private Set<Vehicle> originTransports;
 
-	public MobilityTask(double executingTime, double timeStart, double distance, double purpose, double timeLimit) {
+	public MobilityTask(double executingTime, double timeStart, String fromLoc, String toLoc,
+			Set<Vehicle> originTransports, double distance, double purpose, double timeLimit) {
 		super(executingTime);
 		this.timeStart = timeStart;
+		this.fromLoc = fromLoc;
+		this.toLoc = toLoc;
+		this.originTransports = (originTransports == null) ? new HashSet<Vehicle>() : originTransports;
 		this.purpose = purpose;
 		this.timeLimit = timeLimit;
 		this.distance = distance;
@@ -40,10 +50,24 @@ public double getTimeStart() {
 		return this.timeStart;
 	}
 
+	/** Origin location of the trip. */
+	public String getFromLoc() {
+		return this.fromLoc;
+	}
+
+	/** Destination location of the trip. */
+	public String getToLoc() {
+		return this.toLoc;
+	}
+
+	/** Public transport available at the trip's origin. */
+	public Set<Vehicle> getOriginTransports() {
+		return this.originTransports;
+	}
+
 	@Override
 	public String toString() {
-		String result = "TransportTask, starting time: " + this.executingTime;
-		return result;
+		return "TransportTask " + this.fromLoc + " -> " + this.toLoc + ", starting time: " + this.executingTime;
 	}
 
 	@Override
diff --git a/src/dummy/database/CSVReader.java b/src/dummy/database/CSVReader.java
index a5d73b4..9edf09a 100644
--- a/src/dummy/database/CSVReader.java
+++ b/src/dummy/database/CSVReader.java
@@ -163,7 +163,8 @@ public void createAgents(AgentContext agentContext, HashMap<String, Environment>
 
 	}
 
-	public void createSchedule(Map<String, IAgent> idToAgentMap, int periodNum, int checkpointNum) throws IOException {
+	public void createSchedule(Map<String, IAgent> idToAgentMap, HashMap<String, Environment> idToLocationMap,
+			int periodNum, int checkpointNum) throws IOException {
 		try {
 			String csvDataDir = ContextManager.getProperty(GlobalVars.CSVDataDirectory);
 			String scheduleFile = csvDataDir + ContextManager.getProperty(GlobalVars.ScheduleCSVfile) + "." + periodNum
@@ -173,19 +174,24 @@ public void createSchedule(Map<String, IAgent> idToAgentMap, int periodNum, int
 			String line;
 			br.readLine();
 
+			// Columns: agent_id, start, from_loc, to_loc, km, time_limit, purpose
 			while ((line = br.readLine()) != null) {
 				String[] inputs = line.split(",");
 				String agentId = inputs[0];
-				double time = Double.parseDouble(inputs[1]);
-				double distance = Double.parseDouble(inputs[2]);
-				double timeLimit = Double.parseDouble(inputs[3]);
-				double purpose = Double.parseDouble(inputs[4]);
-
-				time += GlobalVars.SIMULATION_PARAMS.TIME_STEPS_IN_PERIOD * periodNum
+				double timeStart = Double.parseDouble(inputs[1]);
+				String fromLoc = locationName(idToLocationMap, inputs[2]);
+				String toLoc = locationName(idToLocationMap, inputs[3]);
+				Set<Vehicle> originTransports = locationTransports(idToLocationMap, inputs[2]);
+				double distance = Double.parseDouble(inputs[4]);
+				double timeLimit = Double.parseDouble(inputs[5]);
+				double purpose = Double.parseDouble(inputs[6]);
+
+				double time = timeStart + GlobalVars.SIMULATION_PARAMS.TIME_STEPS_IN_PERIOD * periodNum
 						+ GlobalVars.SIMULATION_PARAMS.TIME_STEPS_IN_PERIOD
 								* GlobalVars.SIMULATION_PARAMS.getPeriodToNextCheckNum() * checkpointNum;
 				LOGGER.debug("Create schedule time:  " + time);
-				MobilityTask task = new MobilityTask(time, Double.parseDouble(inputs[1]), distance, purpose, timeLimit);
+				MobilityTask task = new MobilityTask(time, timeStart, fromLoc, toLoc, originTransports, distance, purpose,
+						timeLimit);
 				StandardDummyAgent agent = (StandardDummyAgent) idToAgentMap.get(agentId);
 				agent.addToSchedule(task);
 				// agent.rememberLastTask(task);
@@ -200,6 +206,18 @@ public void createSchedule(Map<String, IAgent> idToAgentMap, int periodNum, int
 		}
 	}
 
+	/** Resolve a location id to its name; falls back to the id if unknown. */
+	private static String locationName(HashMap<String, Environment> idToLocationMap, String locId) {
+		Environment loc = idToLocationMap.get(locId);
+		return (loc instanceof Location) ? ((Location) loc).getName() : locId;
+	}
+
+	/** Public transport available at a location; empty if the location is unknown. */
+	private static Set<Vehicle> locationTransports(HashMap<String, Environment> idToLocationMap, String locId) {
+		Environment loc = idToLocationMap.get(locId);
+		return (loc instanceof Location) ? ((Location) loc).getPublicTransports() : new HashSet<Vehicle>();
+	}
+
 	public IReporter createDummyReporter(AgentContext agentContext) {
 		return new DummyReporter(agentContext);
 	}
diff --git a/src/dummy/environment/Location.java b/src/dummy/environment/Location.java
index 0decb2d..90a09bf 100644
--- a/src/dummy/environment/Location.java
+++ b/src/dummy/environment/Location.java
@@ -32,4 +32,8 @@ public String getName() {
 		return this.name;
 	}
 
+	public Set<Vehicle> getPublicTransports() {
+		return this.publicTransports;
+	}
+
 }
diff --git a/src/dummy/report/DummyReporter.java b/src/dummy/report/DummyReporter.java
index 049c1ba..3a505e5 100644
--- a/src/dummy/report/DummyReporter.java
+++ b/src/dummy/report/DummyReporter.java
@@ -34,16 +34,16 @@ public DummyReporter(AgentContext agentContext) {
 
 	@Override
 	public String printReport() {
-		String reportString = "\nagentID,location,start_time,km,vehicle\n";
+		String reportString = "\nagentID,from,to,start_time,km,vehicle\n";
 		for (IAgent agent : this.agentContext) {
 			StandardDummyAgent mobilityAgent = (StandardDummyAgent) agent;
-			String location = ((Location) mobilityAgent.getLoc()).getName();
 			Map<Task, Option> results = mobilityAgent.getDecisionResults();
 			for (Task task : results.keySet()) {
 				MobilityOption mobilityOption = (MobilityOption) results.get(task);
 				MobilityTask mobilityTask = (MobilityTask) task;
-				reportString += agent.getID() + "," + location + "," + mobilityTask.getExecutingTime() + ","
-						+ mobilityTask.getDistance() + "," + mobilityOption.getMainVehicle().getName() + "\n";
+				reportString += agent.getID() + "," + mobilityTask.getFromLoc() + "," + mobilityTask.getToLoc() + ","
+						+ mobilityTask.getExecutingTime() + "," + mobilityTask.getDistance() + ","
+						+ mobilityOption.getMainVehicle().getName() + "\n";
 			}
 		}
 		writeDecisionsCsv();
@@ -62,28 +62,34 @@ private void writeDecisionsCsv() {
 			dir.mkdirs();
 		}
 		try (FileWriter w = new FileWriter(new File(dir, "decisions.csv"))) {
-			w.write("agent,location,start_time,km,mode,eu,chosen\n");
+			w.write("agent,location,from,to,start_time,km,mode,eu,chosen\n");
 			for (IAgent agent : this.agentContext) {
 				StandardDummyAgent a = (StandardDummyAgent) agent;
 				String location = ((Location) a.getLoc()).getName();
 				Map<Double, Map<String, Double>> euByTime = a.getEuByTime();
 
-				// From the chosen decisions: trip distance and the picked mode per trip.
+				// From the chosen decisions: trip distance, route and the picked mode per trip.
 				Map<Double, Double> kmByTime = new HashMap<Double, Double>();
 				Map<Double, String> chosenByTime = new HashMap<Double, String>();
+				Map<Double, String> fromByTime = new HashMap<Double, String>();
+				Map<Double, String> toByTime = new HashMap<Double, String>();
 				for (Map.Entry<Task, Option> e : a.getDecisionResults().entrySet()) {
 					MobilityTask t = (MobilityTask) e.getKey();
 					kmByTime.put(t.getExecutingTime(), t.getDistance());
 					chosenByTime.put(t.getExecutingTime(), ((MobilityOption) e.getValue()).getMainVehicle().getName());
+					fromByTime.put(t.getExecutingTime(), t.getFromLoc());
+					toByTime.put(t.getExecutingTime(), t.getToLoc());
 				}
 
 				for (Map.Entry<Double, Map<String, Double>> trip : euByTime.entrySet()) {
 					double time = trip.getKey();
 					Double km = kmByTime.get(time);
 					String chosen = chosenByTime.get(time);
+					String from = fromByTime.getOrDefault(time, "");
+					String to = toByTime.getOrDefault(time, "");
 					for (Map.Entry<String, Double> mode : trip.getValue().entrySet()) {
-						w.write(agent.getID() + "," + location + "," + time + "," + (km == null ? "" : km) + ","
-								+ mode.getKey() + "," + mode.getValue() + ","
+						w.write(agent.getID() + "," + location + "," + from + "," + to + "," + time + ","
+								+ (km == null ? "" : km) + "," + mode.getKey() + "," + mode.getValue() + ","
 								+ (mode.getKey().equals(chosen) ? "1" : "0") + "\n");
 					}
 				}
diff --git a/src/dummy/simulator/ContextManager.java b/src/dummy/simulator/ContextManager.java
index c91e317..5baf9ee 100644
--- a/src/dummy/simulator/ContextManager.java
+++ b/src/dummy/simulator/ContextManager.java
@@ -145,7 +145,7 @@ public void updateSchedule() {
 				// Add tasks to the agent's schedule.
 
 				try {
-					generator.createSchedule(idToAgentMap, periodNum, checkpointNum);
+					generator.createSchedule(idToAgentMap, idToLocationMap, periodNum, checkpointNum);
 				} catch (IOException e) {
 					// TODO Auto-generated catch block
 					e.printStackTrace();

From 4d9c2d53ce31c7d014203832c4bed9aec0a9fef1 Mon Sep 17 00:00:00 2001
From: Amy Liffey <amy.liffey@hes-so.ch>
Date: Tue, 7 Jul 2026 12:32:18 +0200
Subject: [PATCH 19/25] feat: add agentblocks example

---
 .github/workflows/agentblocks.yml |  34 +++++
 agentblocks/TIB_BedDeM.java       | 218 ++++++++++++++++++++++++++++++
 2 files changed, 252 insertions(+)
 create mode 100644 .github/workflows/agentblocks.yml
 create mode 100644 agentblocks/TIB_BedDeM.java

diff --git a/.github/workflows/agentblocks.yml b/.github/workflows/agentblocks.yml
new file mode 100644
index 0000000..07f31b7
--- /dev/null
+++ b/.github/workflows/agentblocks.yml
@@ -0,0 +1,34 @@
+# Standalone check for the AgentBlocks TIB reference implementation.
+# This is the self-contained Java block from the RBB (agentblocks/TIB_BedDeM.java):
+# no Repast, no Postgres, no build.xml -- just javac + java. It compiles the block
+# and runs the example, and writes the output to the run summary.
+
+name: AgentBlocks TIB example
+
+on:
+  push:
+    branches: [ "master" ]
+    paths: [ "agentblocks/**", ".github/workflows/agentblocks.yml" ]
+  pull_request:
+    branches: [ "master" ]
+    paths: [ "agentblocks/**", ".github/workflows/agentblocks.yml" ]
+
+jobs:
+  tib-example:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up JDK
+      uses: actions/setup-java@v4
+      with:
+        java-version: '21'
+        distribution: 'temurin'
+    - name: Compile and run the TIB block
+      run: |
+        set -e
+        mkdir -p out
+        javac -encoding UTF-8 -d out agentblocks/TIB_BedDeM.java
+        echo "## AgentBlocks TIB example output" >> "$GITHUB_STEP_SUMMARY"
+        echo '```' >> "$GITHUB_STEP_SUMMARY"
+        java -cp out agentblocks.tib.TIBExample | tee -a "$GITHUB_STEP_SUMMARY"
+        echo '```' >> "$GITHUB_STEP_SUMMARY"
diff --git a/agentblocks/TIB_BedDeM.java b/agentblocks/TIB_BedDeM.java
new file mode 100644
index 0000000..ccc234e
--- /dev/null
+++ b/agentblocks/TIB_BedDeM.java
@@ -0,0 +1,218 @@
+/**
+ * TIB Agent Block: self-contained, illustrative reimplementation of the BedDeM
+ * TIB decision block. It mirrors the determinant hierarchy and the minimum-
+ * expected-utility choice rule of framework.agent.reasoning.TIBModel, and it
+ * implements the RBB's expected-utility equation:
+ *
+ *     EU_d(option) = Σ_a ( EU_a(option) / Σ_o EU_a(o) ) · w_a
+ *
+ * i.e. every determinant's value is normalised across all options BEFORE it is
+ * weighted into its parent. This normalisation is applied at every level, exactly
+ * as the production engine does via Determinant.rankOptions().
+ *
+ * Reference: https://github.com/SiLab-group/beddem_simulator
+ */
+package agentblocks.tib;
+
+import java.util.*;
+
+interface Option {
+    String getName();
+    double getProperty(String propertyName);
+}
+
+class SimpleOption implements Option {
+    private final String name;
+    private final Map<String, Double> properties = new HashMap<>();
+    public SimpleOption(String name) { this.name = name; }
+    public String getName() { return name; }
+    public double getProperty(String propertyName) {
+        return properties.getOrDefault(propertyName, 0.0);
+    }
+    public void setProperty(String propertyName, double value) {
+        properties.put(propertyName, value);
+    }
+}
+
+interface Determinant {
+    String getName();
+    double getWeight();
+    void setWeight(double weight);
+    /**
+     * Evaluate every option at this determinant and return its NORMALISED score
+     * (each option's share of the total across all options). Normalising here, at
+     * every level, is the Σ_o EU_a(o) term of the EU equation.
+     */
+    Map<Option, Double> evaluate(List<? extends Option> options);
+}
+
+abstract class AbstractDeterminant implements Determinant {
+    protected final String name;
+    protected double weight;
+    protected AbstractDeterminant(String name, double weight) {
+        this.name = name; this.weight = weight;
+    }
+    public String getName() { return name; }
+    public double getWeight() { return weight; }
+    public void setWeight(double weight) { this.weight = weight; }
+
+    /** Divide each option's raw value by the sum across all options. */
+    protected static Map<Option, Double> normalise(Map<Option, Double> raw) {
+        double sum = 0.0;
+        for (double v : raw.values()) sum += v;
+        Map<Option, Double> out = new HashMap<>();
+        for (Map.Entry<Option, Double> e : raw.entrySet())
+            out.put(e.getKey(), sum > 0 ? e.getValue() / sum : 0.0);
+        return out;
+    }
+}
+
+/** Base determinant: reads one property off each option. */
+class LeafDeterminant extends AbstractDeterminant {
+    public LeafDeterminant(String name, double weight) { super(name, weight); }
+    @Override
+    public Map<Option, Double> evaluate(List<? extends Option> options) {
+        Map<Option, Double> raw = new HashMap<>();
+        for (Option opt : options) raw.put(opt, opt.getProperty(name));
+        return normalise(raw);
+    }
+}
+
+/** Aggregates children: Σ_child ( normalised child score · child weight ), then normalises. */
+class ParentDeterminant extends AbstractDeterminant {
+    private final List<Determinant> children = new ArrayList<>();
+    public ParentDeterminant(String name, double weight) { super(name, weight); }
+    public void addDeterminantChild(Determinant child) { children.add(child); }
+    public List<Determinant> getChildren() { return children; }
+    @Override
+    public Map<Option, Double> evaluate(List<? extends Option> options) {
+        Map<Option, Double> agg = new HashMap<>();
+        for (Option opt : options) agg.put(opt, 0.0);
+        for (Determinant child : children) {
+            Map<Option, Double> childScores = child.evaluate(options);
+            for (Option opt : options)
+                agg.put(opt, agg.get(opt) + child.getWeight() * childScores.get(opt));
+        }
+        return normalise(agg);
+    }
+}
+
+/**
+ * Triandis' TIB decision model. Provide the eight base determinants and the five
+ * aggregate weights; the hierarchy below is wired exactly as in BedDeM. To model
+ * additional psychology, subclass and add determinants to the tree.
+ */
+class TIBModel extends ParentDeterminant {
+    public TIBModel(Determinant belief, Determinant evaluation, Determinant norm, Determinant role,
+                    Determinant self_concept, Determinant emotion, Determinant facilitatingCond, Determinant freq,
+                    double attitudeWeight, double socialWeight, double affectWeight, double intentionWeight,
+                    double habitWeight) {
+        super("Triandis", 1);
+        ParentDeterminant intention = new ParentDeterminant("intention", intentionWeight);
+        ParentDeterminant habits    = new ParentDeterminant("habits", habitWeight);
+        ParentDeterminant attitude  = new ParentDeterminant("attitude", attitudeWeight);
+        ParentDeterminant social    = new ParentDeterminant("social", socialWeight);
+        ParentDeterminant affect    = new ParentDeterminant("affect", affectWeight);
+
+        addDeterminantChild(intention);
+        addDeterminantChild(habits);
+        addDeterminantChild(facilitatingCond);
+
+        habits.addDeterminantChild(freq);
+        intention.addDeterminantChild(affect);
+        intention.addDeterminantChild(social);
+        intention.addDeterminantChild(attitude);
+        affect.addDeterminantChild(emotion);
+        social.addDeterminantChild(norm);
+        social.addDeterminantChild(role);
+        social.addDeterminantChild(self_concept);
+        attitude.addDeterminantChild(belief);
+        attitude.addDeterminantChild(evaluation);
+    }
+
+    /** Expected utility per option (normalised). */
+    public Map<Option, Double> evaluateOptions(List<? extends Option> options) {
+        return evaluate(options);
+    }
+
+    /** Select the option with the minimum expected utility, as in BedDeM. */
+    public Option selectOption(List<? extends Option> options) {
+        if (options == null || options.isEmpty())
+            throw new IllegalArgumentException("Options list cannot be empty");
+        Map<Option, Double> eu = evaluate(options);
+        Option best = null; double min = Double.MAX_VALUE;
+        for (Option opt : options) {
+            double u = eu.get(opt);
+            if (u < min) { min = u; best = opt; }
+        }
+        return best;
+    }
+}
+
+/** Convenience builder for the eight base determinants and five aggregate weights. */
+class TIBBuilder {
+    private final Map<String, Double> base = new HashMap<>();
+    private final Map<String, Double> agg  = new HashMap<>();
+    private static final String[] BASE = {
+        "belief","evaluation","norm","role","selfConcept","emotion","facilitating","frequency" };
+
+    public TIBBuilder() {
+        for (String b : BASE) base.put(b, 1.0);
+        agg.put("attitude", 2.0); agg.put("social", 3.0); agg.put("affect", 2.5);
+        agg.put("intention", 4.0); agg.put("habit", 1.5);
+    }
+    /** Set one of the eight known base-determinant weights. */
+    public TIBBuilder setBaseWeight(String determinant, double weight) {
+        if (!base.containsKey(determinant))
+            throw new IllegalArgumentException("Unknown base determinant: " + determinant);
+        base.put(determinant, weight); return this;
+    }
+    public TIBBuilder setAggregateWeight(String determinant, double weight) {
+        if (!agg.containsKey(determinant))
+            throw new IllegalArgumentException("Unknown aggregate determinant: " + determinant);
+        agg.put(determinant, weight); return this;
+    }
+    public TIBModel build() {
+        return new TIBModel(
+            new LeafDeterminant("belief",      base.get("belief")),
+            new LeafDeterminant("evaluation",  base.get("evaluation")),
+            new LeafDeterminant("norm",        base.get("norm")),
+            new LeafDeterminant("role",        base.get("role")),
+            new LeafDeterminant("selfConcept", base.get("selfConcept")),
+            new LeafDeterminant("emotion",     base.get("emotion")),
+            new LeafDeterminant("facilitating",base.get("facilitating")),
+            new LeafDeterminant("frequency",   base.get("frequency")),
+            agg.get("attitude"), agg.get("social"), agg.get("affect"),
+            agg.get("intention"), agg.get("habit"));
+    }
+}
+
+class TIBExample {
+    public static void main(String[] args) {
+        TIBModel tib = new TIBBuilder()
+            .setAggregateWeight("attitude", 2.0)
+            .setAggregateWeight("social", 3.0)
+            .setAggregateWeight("affect", 2.5)
+            .setAggregateWeight("intention", 4.0)
+            .setAggregateWeight("habit", 1.5)
+            .build();
+
+        String[] p = {"belief","evaluation","norm","role","selfConcept","emotion","facilitating","frequency"};
+        SimpleOption car   = option("car",   p, new double[]{1.0, 4.0, 2.0, 3.0, 2.0, 4.0, 1.0, 10.0});
+        SimpleOption train = option("train", p, new double[]{0.9, 3.0, 1.0, 2.0, 1.0, 3.5, 1.0,  5.0});
+        SimpleOption bike  = option("bike",  p, new double[]{1.1, 0.0, 3.0, 1.0, 3.0, 3.0, 0.8,  2.0});
+
+        List<Option> options = Arrays.asList(car, train, bike);
+        System.out.println("Chosen: " + tib.selectOption(options).getName());
+        Map<Option, Double> eu = tib.evaluateOptions(options);
+        System.out.println("Expected utilities (lower = better):");
+        for (Option o : options)
+            System.out.printf("  %s: %.3f%n", o.getName(), eu.get(o));
+    }
+
+    private static SimpleOption option(String name, String[] props, double[] vals) {
+        SimpleOption o = new SimpleOption(name);
+        for (int i = 0; i < props.length; i++) o.setProperty(props[i], vals[i]);
+        return o;
+    }
+}

From 881aa4af712a8dee949f84396b98a786d37687db Mon Sep 17 00:00:00 2001
From: Amy Liffey <amy.liffey@hes-so.ch>
Date: Tue, 7 Jul 2026 12:57:48 +0200
Subject: [PATCH 20/25] chore: add real example

---
 agentblocks/TIB_BedDeM.java | 47 ++++++++++++++++++++++++++++---------
 1 file changed, 36 insertions(+), 11 deletions(-)

diff --git a/agentblocks/TIB_BedDeM.java b/agentblocks/TIB_BedDeM.java
index ccc234e..3b0b1ac 100644
--- a/agentblocks/TIB_BedDeM.java
+++ b/agentblocks/TIB_BedDeM.java
@@ -188,26 +188,51 @@ public TIBModel build() {
 }
 
 class TIBExample {
+    // Sion -> Sierre (18 km), Car / Train / Bike. We only set the weights and the
+    // per-option determinant values; the agent block itself (TIBModel) does the
+    // whole calculation -- normalising each determinant across options, weighting,
+    // aggregating up the tree, and selecting the minimum-EU option.
+    //
+    // The block's two attitude determinants are named "belief" and "evaluation";
+    // here they carry the mobility values price and time (belief=price,
+    // evaluation=time, selfConcept=self, frequency=freq).
     public static void main(String[] args) {
         TIBModel tib = new TIBBuilder()
-            .setAggregateWeight("attitude", 2.0)
-            .setAggregateWeight("social", 3.0)
-            .setAggregateWeight("affect", 2.5)
+            .setBaseWeight("belief", 2.0)        // price
+            .setBaseWeight("evaluation", 4.0)    // time
+            .setBaseWeight("norm", 3.0)
+            .setBaseWeight("role", 2.0)
+            .setBaseWeight("selfConcept", 3.0)   // self
+            .setBaseWeight("emotion", 1.0)
+            .setBaseWeight("facilitating", 2.0)
+            .setBaseWeight("frequency", 3.0)     // freq
+            .setAggregateWeight("attitude", 4.0)
+            .setAggregateWeight("social", 2.0)
+            .setAggregateWeight("affect", 2.0)
             .setAggregateWeight("intention", 4.0)
-            .setAggregateWeight("habit", 1.5)
+            .setAggregateWeight("habit", 3.0)
             .build();
 
         String[] p = {"belief","evaluation","norm","role","selfConcept","emotion","facilitating","frequency"};
-        SimpleOption car   = option("car",   p, new double[]{1.0, 4.0, 2.0, 3.0, 2.0, 4.0, 1.0, 10.0});
-        SimpleOption train = option("train", p, new double[]{0.9, 3.0, 1.0, 2.0, 1.0, 3.5, 1.0,  5.0});
-        SimpleOption bike  = option("bike",  p, new double[]{1.1, 0.0, 3.0, 1.0, 3.0, 3.0, 0.8,  2.0});
-
+        //                          price time norm role self emo facil freq
+        SimpleOption car   = option("Car",   p, new double[]{4.0, 0.3, 2, 3, 1, 1, 0, 0});
+        SimpleOption train = option("Train", p, new double[]{3.0, 0.2, 1, 2, 2, 2, 1, 0});
+        SimpleOption bike  = option("Bike",  p, new double[]{0.0, 1.0, 3, 1, 3, 3, 0, 1});
         List<Option> options = Arrays.asList(car, train, bike);
-        System.out.println("Chosen: " + tib.selectOption(options).getName());
+
+        // Inputs
+        System.out.println("Sion -> Sierre (18 km): Car / Train / Bike\n");
+        System.out.printf("  %-14s%8s%8s%8s%n", "determinant", "Car", "Train", "Bike");
+        for (String d : p)
+            System.out.printf("  %-14s%8.2f%8.2f%8.2f%n", d,
+                car.getProperty(d), train.getProperty(d), bike.getProperty(d));
+
+        // Let the block do the calculation.
         Map<Option, Double> eu = tib.evaluateOptions(options);
-        System.out.println("Expected utilities (lower = better):");
+        System.out.println("\nExpected utility (computed by the TIB block):");
         for (Option o : options)
-            System.out.printf("  %s: %.3f%n", o.getName(), eu.get(o));
+            System.out.printf("  %-6s %.4f%n", o.getName() + ":", eu.get(o));
+        System.out.println("\nChosen: " + tib.selectOption(options).getName());
     }
 
     private static SimpleOption option(String name, String[] props, double[] vals) {

From 4c689d7cd419ca966105168ec19a95e3a08f470f Mon Sep 17 00:00:00 2001
From: Amy Liffey <amy.liffey@hes-so.ch>
Date: Tue, 7 Jul 2026 15:04:36 +0200
Subject: [PATCH 21/25] chore: fix the agentblock

---
 agentblocks/TIB_BedDeM.java | 89 +++++++++++--------------------------
 1 file changed, 26 insertions(+), 63 deletions(-)

diff --git a/agentblocks/TIB_BedDeM.java b/agentblocks/TIB_BedDeM.java
index 3b0b1ac..8e587e6 100644
--- a/agentblocks/TIB_BedDeM.java
+++ b/agentblocks/TIB_BedDeM.java
@@ -149,71 +149,34 @@ public Option selectOption(List<? extends Option> options) {
     }
 }
 
-/** Convenience builder for the eight base determinants and five aggregate weights. */
-class TIBBuilder {
-    private final Map<String, Double> base = new HashMap<>();
-    private final Map<String, Double> agg  = new HashMap<>();
-    private static final String[] BASE = {
-        "belief","evaluation","norm","role","selfConcept","emotion","facilitating","frequency" };
-
-    public TIBBuilder() {
-        for (String b : BASE) base.put(b, 1.0);
-        agg.put("attitude", 2.0); agg.put("social", 3.0); agg.put("affect", 2.5);
-        agg.put("intention", 4.0); agg.put("habit", 1.5);
-    }
-    /** Set one of the eight known base-determinant weights. */
-    public TIBBuilder setBaseWeight(String determinant, double weight) {
-        if (!base.containsKey(determinant))
-            throw new IllegalArgumentException("Unknown base determinant: " + determinant);
-        base.put(determinant, weight); return this;
-    }
-    public TIBBuilder setAggregateWeight(String determinant, double weight) {
-        if (!agg.containsKey(determinant))
-            throw new IllegalArgumentException("Unknown aggregate determinant: " + determinant);
-        agg.put(determinant, weight); return this;
-    }
-    public TIBModel build() {
-        return new TIBModel(
-            new LeafDeterminant("belief",      base.get("belief")),
-            new LeafDeterminant("evaluation",  base.get("evaluation")),
-            new LeafDeterminant("norm",        base.get("norm")),
-            new LeafDeterminant("role",        base.get("role")),
-            new LeafDeterminant("selfConcept", base.get("selfConcept")),
-            new LeafDeterminant("emotion",     base.get("emotion")),
-            new LeafDeterminant("facilitating",base.get("facilitating")),
-            new LeafDeterminant("frequency",   base.get("frequency")),
-            agg.get("attitude"), agg.get("social"), agg.get("affect"),
-            agg.get("intention"), agg.get("habit"));
-    }
-}
-
 class TIBExample {
-    // Sion -> Sierre (18 km), Car / Train / Bike. We only set the weights and the
-    // per-option determinant values; the agent block itself (TIBModel) does the
-    // whole calculation -- normalising each determinant across options, weighting,
-    // aggregating up the tree, and selecting the minimum-EU option.
-    //
-    // The block's two attitude determinants are named "belief" and "evaluation";
-    // here they carry the mobility values price and time (belief=price,
-    // evaluation=time, selfConcept=self, frequency=freq).
+    // Sion -> Sierre (18 km), Car / Train / Bike.
+    // All 13 weights are supplied from outside, exactly as in the BedDeM model:
+    // the eight base determinants are each constructed with their weight, and the
+    // five aggregate weights are passed straight into the TIBModel constructor.
+    // We only set weights + per-option values; TIBModel does the whole calculation
+    // (normalise each determinant, weight, aggregate up the tree, pick minimum EU).
     public static void main(String[] args) {
-        TIBModel tib = new TIBBuilder()
-            .setBaseWeight("belief", 2.0)        // price
-            .setBaseWeight("evaluation", 4.0)    // time
-            .setBaseWeight("norm", 3.0)
-            .setBaseWeight("role", 2.0)
-            .setBaseWeight("selfConcept", 3.0)   // self
-            .setBaseWeight("emotion", 1.0)
-            .setBaseWeight("facilitating", 2.0)
-            .setBaseWeight("frequency", 3.0)     // freq
-            .setAggregateWeight("attitude", 4.0)
-            .setAggregateWeight("social", 2.0)
-            .setAggregateWeight("affect", 2.0)
-            .setAggregateWeight("intention", 4.0)
-            .setAggregateWeight("habit", 3.0)
-            .build();
-
-        String[] p = {"belief","evaluation","norm","role","selfConcept","emotion","facilitating","frequency"};
+        // Base determinants (leaf), each carrying its own weight.
+        LeafDeterminant price = new LeafDeterminant("price", 2.0);
+        LeafDeterminant time  = new LeafDeterminant("time", 4.0);
+        LeafDeterminant norm  = new LeafDeterminant("norm", 3.0);
+        LeafDeterminant role  = new LeafDeterminant("role", 2.0);
+        LeafDeterminant self  = new LeafDeterminant("self", 3.0);
+        LeafDeterminant emotion = new LeafDeterminant("emotion", 1.0);
+        LeafDeterminant facilitating = new LeafDeterminant("facilitating", 2.0);
+        LeafDeterminant freq  = new LeafDeterminant("freq", 3.0);
+
+        // Aggregate weights, also supplied from outside.
+        TIBModel tib = new TIBModel(
+            price, time, norm, role, self, emotion, facilitating, freq,
+            4.0,   // attitude
+            2.0,   // social
+            2.0,   // affect
+            4.0,   // intention
+            3.0);  // habit
+
+        String[] p = {"price","time","norm","role","self","emotion","facilitating","freq"};
         //                          price time norm role self emo facil freq
         SimpleOption car   = option("Car",   p, new double[]{4.0, 0.3, 2, 3, 1, 1, 0, 0});
         SimpleOption train = option("Train", p, new double[]{3.0, 0.2, 1, 2, 2, 2, 1, 0});

From 5326bcc4d91d1ffcbe251567950b7f8f00c6e149 Mon Sep 17 00:00:00 2001
From: Amy Liffey <amy.liffey@hes-so.ch>
Date: Tue, 7 Jul 2026 15:31:13 +0200
Subject: [PATCH 22/25] fix: aggregation

---
 agentblocks/TIB_BedDeM.java                   | 34 ++++++++++++++-----
 .../agent/DummyCommunicationComponent.java    |  5 ++-
 src/dummy/agent/DummyDecisionComponent.java   |  9 +++--
 .../agent/reasoning/Determinant.java          |  8 +++--
 4 files changed, 41 insertions(+), 15 deletions(-)

diff --git a/agentblocks/TIB_BedDeM.java b/agentblocks/TIB_BedDeM.java
index 8e587e6..0f466bb 100644
--- a/agentblocks/TIB_BedDeM.java
+++ b/agentblocks/TIB_BedDeM.java
@@ -7,8 +7,9 @@
  *     EU_d(option) = Σ_a ( EU_a(option) / Σ_o EU_a(o) ) · w_a
  *
  * i.e. every determinant's value is normalised across all options BEFORE it is
- * weighted into its parent. This normalisation is applied at every level, exactly
- * as the production engine does via Determinant.rankOptions().
+ * weighted into its parent (the Σ_o EU_a(o) term). The behaviour output itself
+ * is the raw weighted aggregate and is NOT re-normalised, matching the thesis
+ * (Nguyen 2023, Eq. 4.7 and Table 4.2).
  *
  * Reference: https://github.com/SiLab-group/beddem_simulator
  */
@@ -78,14 +79,19 @@ public Map<Option, Double> evaluate(List<? extends Option> options) {
     }
 }
 
-/** Aggregates children: Σ_child ( normalised child score · child weight ), then normalises. */
+/** Aggregates children: Σ_child ( normalised child score · child weight ). */
 class ParentDeterminant extends AbstractDeterminant {
     private final List<Determinant> children = new ArrayList<>();
     public ParentDeterminant(String name, double weight) { super(name, weight); }
     public void addDeterminantChild(Determinant child) { children.add(child); }
     public List<Determinant> getChildren() { return children; }
-    @Override
-    public Map<Option, Double> evaluate(List<? extends Option> options) {
+
+    /**
+     * Raw weighted aggregate of the (already-normalised) children. This is
+     * U_o(d) in the EU equation; it is NOT normalised here. A parent normalises
+     * its children, not its own output.
+     */
+    protected Map<Option, Double> aggregate(List<? extends Option> options) {
         Map<Option, Double> agg = new HashMap<>();
         for (Option opt : options) agg.put(opt, 0.0);
         for (Determinant child : children) {
@@ -93,7 +99,13 @@ public Map<Option, Double> evaluate(List<? extends Option> options) {
             for (Option opt : options)
                 agg.put(opt, agg.get(opt) + child.getWeight() * childScores.get(opt));
         }
-        return normalise(agg);
+        return agg;
+    }
+
+    @Override
+    public Map<Option, Double> evaluate(List<? extends Option> options) {
+        // Normalised so this node can, in turn, be a normalised child of its parent.
+        return normalise(aggregate(options));
     }
 }
 
@@ -130,16 +142,20 @@ public TIBModel(Determinant belief, Determinant evaluation, Determinant norm, De
         attitude.addDeterminantChild(evaluation);
     }
 
-    /** Expected utility per option (normalised). */
+    /**
+     * Behaviour-output expected utility per option. This is the raw aggregate
+     * of the (normalised) top-level determinants; the thesis does NOT
+     * re-normalise the behaviour output, so we use aggregate(), not evaluate().
+     */
     public Map<Option, Double> evaluateOptions(List<? extends Option> options) {
-        return evaluate(options);
+        return aggregate(options);
     }
 
     /** Select the option with the minimum expected utility, as in BedDeM. */
     public Option selectOption(List<? extends Option> options) {
         if (options == null || options.isEmpty())
             throw new IllegalArgumentException("Options list cannot be empty");
-        Map<Option, Double> eu = evaluate(options);
+        Map<Option, Double> eu = aggregate(options);
         Option best = null; double min = Double.MAX_VALUE;
         for (Option opt : options) {
             double u = eu.get(opt);
diff --git a/src/dummy/agent/DummyCommunicationComponent.java b/src/dummy/agent/DummyCommunicationComponent.java
index 094d03d..12a8fb5 100644
--- a/src/dummy/agent/DummyCommunicationComponent.java
+++ b/src/dummy/agent/DummyCommunicationComponent.java
@@ -35,7 +35,10 @@ public Option pickOption(Map<Double, Set<Option>> evaluatedOptions) {
 
 	private Option pickBestOpt(Map<Double, Set<Option>> evaluatedOptions) {
 		if (evaluatedOptions.size() != 0) {
-			double bestVal = 1;
+			// The behaviour-output utilities are no longer normalised to <= 1
+			// (see DummyDecisionComponent), so start from +infinity and keep the
+			// minimum (U is a cost function: lowest is preferred).
+			double bestVal = Double.MAX_VALUE;
 			for (Double val : evaluatedOptions.keySet()) {
 				if (val < bestVal) {
 					bestVal = val;
diff --git a/src/dummy/agent/DummyDecisionComponent.java b/src/dummy/agent/DummyDecisionComponent.java
index cfb0061..ad8d7fd 100644
--- a/src/dummy/agent/DummyDecisionComponent.java
+++ b/src/dummy/agent/DummyDecisionComponent.java
@@ -34,9 +34,12 @@ public DummyDecisionComponent(Determinant belief, Determinant evaluation, Determ
 
 	@Override
 	public Map<Double, Set<Option>> evaluateOptions(Set<Option> options, Task task) {
-		// Get the list of all ranked options from agent's decision making model.
-		LOGGER.log(Level.DEBUG, "Rank options" + options.toString());
-		Map<Double, Set<Option>> result = rankOptions(options, task);
+		// The behaviour-output utility per option. We use evalOpts (the raw
+		// aggregate) rather than rankOptions here: children are already
+		// normalised at every level inside the tree, and the thesis does NOT
+		// apply a further normalisation to the top-level behaviour output.
+		LOGGER.log(Level.DEBUG, "Evaluate options " + options.toString());
+		Map<Double, Set<Option>> result = evalOpts(options, task);
 		// Record the expected utility (map key) of each option for this trip.
 		Map<String, Double> perMode = new HashMap<String, Double>();
 		for (Map.Entry<Double, Set<Option>> entry : result.entrySet()) {
diff --git a/src/framework/agent/reasoning/Determinant.java b/src/framework/agent/reasoning/Determinant.java
index bdeab3c..bede381 100644
--- a/src/framework/agent/reasoning/Determinant.java
+++ b/src/framework/agent/reasoning/Determinant.java
@@ -42,9 +42,13 @@ public Determinant(String id, double weight) {
 	public Map<Double, Set<Option>> rankOptions(Set<Option> inputOpts, Task task) {
 		Map<Double, Set<Option>> rankingResult = new HashMap<Double, Set<Option>>();
 		Map<Double, Set<Option>> valueToOptsMap = evalOpts(inputOpts, task);
+		// Normalise by the sum over ALL options (thesis Eq. 4.7: Sum_o U_o(c)),
+		// counting each distinct value once per option that holds it. (The
+		// earlier version summed distinct values only, which diverged whenever
+		// two options shared a value.)
 		double sumValue = 0;
-		for (Double v : valueToOptsMap.keySet()) {
-			sumValue += v;
+		for (Map.Entry<Double, Set<Option>> entry : valueToOptsMap.entrySet()) {
+			sumValue += entry.getKey() * entry.getValue().size();
 		}
 		if (Double.compare(sumValue, 0.0) == 0)
 			sumValue = 1;

From a62af5eac82dd2ab0362ac3ebba3ae48878bb297 Mon Sep 17 00:00:00 2001
From: Amy Liffey <amy.liffey@hes-so.ch>
Date: Tue, 7 Jul 2026 15:38:16 +0200
Subject: [PATCH 23/25] chore: clean up

---
 agentblocks/TIB_BedDeM.java                   | 21 ++++++-------------
 .../agent/DummyCommunicationComponent.java    |  4 +---
 src/dummy/agent/DummyDecisionComponent.java   |  6 ++----
 src/dummy/agent/DummyPerceptionComponent.java |  3 +--
 src/dummy/agent/StandardDummyAgent.java       |  6 ++----
 .../agent/reasoning/Determinant.java          |  5 +----
 6 files changed, 13 insertions(+), 32 deletions(-)

diff --git a/agentblocks/TIB_BedDeM.java b/agentblocks/TIB_BedDeM.java
index 0f466bb..b3eb6cf 100644
--- a/agentblocks/TIB_BedDeM.java
+++ b/agentblocks/TIB_BedDeM.java
@@ -6,10 +6,9 @@
  *
  *     EU_d(option) = Σ_a ( EU_a(option) / Σ_o EU_a(o) ) · w_a
  *
- * i.e. every determinant's value is normalised across all options BEFORE it is
- * weighted into its parent (the Σ_o EU_a(o) term). The behaviour output itself
- * is the raw weighted aggregate and is NOT re-normalised, matching the thesis
- * (Nguyen 2023, Eq. 4.7 and Table 4.2).
+ * Each determinant's value is normalised across all options, then weighted into
+ * its parent. The behaviour output is the weighted aggregate of the top-level
+ * determinants (Nguyen 2023, Eq. 4.7 and Table 4.2).
  *
  * Reference: https://github.com/SiLab-group/beddem_simulator
  */
@@ -86,11 +85,7 @@ class ParentDeterminant extends AbstractDeterminant {
     public void addDeterminantChild(Determinant child) { children.add(child); }
     public List<Determinant> getChildren() { return children; }
 
-    /**
-     * Raw weighted aggregate of the (already-normalised) children. This is
-     * U_o(d) in the EU equation; it is NOT normalised here. A parent normalises
-     * its children, not its own output.
-     */
+    /** Weighted sum of the normalised children (U_o(d) in the EU equation). */
     protected Map<Option, Double> aggregate(List<? extends Option> options) {
         Map<Option, Double> agg = new HashMap<>();
         for (Option opt : options) agg.put(opt, 0.0);
@@ -104,7 +99,7 @@ protected Map<Option, Double> aggregate(List<? extends Option> options) {
 
     @Override
     public Map<Option, Double> evaluate(List<? extends Option> options) {
-        // Normalised so this node can, in turn, be a normalised child of its parent.
+        // Normalised aggregate, used when this node is a child of another.
         return normalise(aggregate(options));
     }
 }
@@ -142,11 +137,7 @@ public TIBModel(Determinant belief, Determinant evaluation, Determinant norm, De
         attitude.addDeterminantChild(evaluation);
     }
 
-    /**
-     * Behaviour-output expected utility per option. This is the raw aggregate
-     * of the (normalised) top-level determinants; the thesis does NOT
-     * re-normalise the behaviour output, so we use aggregate(), not evaluate().
-     */
+    /** Behaviour-output utility per option: the aggregate of the top-level determinants. */
     public Map<Option, Double> evaluateOptions(List<? extends Option> options) {
         return aggregate(options);
     }
diff --git a/src/dummy/agent/DummyCommunicationComponent.java b/src/dummy/agent/DummyCommunicationComponent.java
index 12a8fb5..37ff5c4 100644
--- a/src/dummy/agent/DummyCommunicationComponent.java
+++ b/src/dummy/agent/DummyCommunicationComponent.java
@@ -35,9 +35,7 @@ public Option pickOption(Map<Double, Set<Option>> evaluatedOptions) {
 
 	private Option pickBestOpt(Map<Double, Set<Option>> evaluatedOptions) {
 		if (evaluatedOptions.size() != 0) {
-			// The behaviour-output utilities are no longer normalised to <= 1
-			// (see DummyDecisionComponent), so start from +infinity and keep the
-			// minimum (U is a cost function: lowest is preferred).
+			// Keep the option with the smallest utility.
 			double bestVal = Double.MAX_VALUE;
 			for (Double val : evaluatedOptions.keySet()) {
 				if (val < bestVal) {
diff --git a/src/dummy/agent/DummyDecisionComponent.java b/src/dummy/agent/DummyDecisionComponent.java
index ad8d7fd..fe247e8 100644
--- a/src/dummy/agent/DummyDecisionComponent.java
+++ b/src/dummy/agent/DummyDecisionComponent.java
@@ -34,10 +34,8 @@ public DummyDecisionComponent(Determinant belief, Determinant evaluation, Determ
 
 	@Override
 	public Map<Double, Set<Option>> evaluateOptions(Set<Option> options, Task task) {
-		// The behaviour-output utility per option. We use evalOpts (the raw
-		// aggregate) rather than rankOptions here: children are already
-		// normalised at every level inside the tree, and the thesis does NOT
-		// apply a further normalisation to the top-level behaviour output.
+		// Aggregated utility per option. Children are normalised at each level;
+		// the top level is the weighted aggregate.
 		LOGGER.log(Level.DEBUG, "Evaluate options " + options.toString());
 		Map<Double, Set<Option>> result = evalOpts(options, task);
 		// Record the expected utility (map key) of each option for this trip.
diff --git a/src/dummy/agent/DummyPerceptionComponent.java b/src/dummy/agent/DummyPerceptionComponent.java
index dc05737..3e7ad82 100644
--- a/src/dummy/agent/DummyPerceptionComponent.java
+++ b/src/dummy/agent/DummyPerceptionComponent.java
@@ -30,8 +30,7 @@ public DummyPerceptionComponent(String agentID) {
 	public Set<Option> generateOptions(Task task, EnvironmentalState environmentalState, InternalState internalState) {
 		Set<Vehicle> accessileVehicles = new HashSet<Vehicle>();
 		MobilityTask mobilityTask = (MobilityTask) task;
-		// Public transport available at the trip's ORIGIN (from_loc), not the
-		// agent's home location, so an evening return boards where it starts.
+		// Public transport available at the trip's origin.
 		accessileVehicles.addAll(mobilityTask.getOriginTransports());
 		MobilityInternalState mobilityInternalStat = (MobilityInternalState) internalState;
 		accessileVehicles.addAll(mobilityInternalStat.getOwnVehicles());
diff --git a/src/dummy/agent/StandardDummyAgent.java b/src/dummy/agent/StandardDummyAgent.java
index 787c7cc..7cce85d 100644
--- a/src/dummy/agent/StandardDummyAgent.java
+++ b/src/dummy/agent/StandardDummyAgent.java
@@ -219,10 +219,8 @@ protected double evalOpt(Option opt, Task task) {
 	}
 
 	/*
-	 * Helper penalty tables. Every determinant above returns a cost-like value in
-	 * which LOWER == more preferred, matching the engine's selection rule
-	 * (DummyCommunicationComponent picks the option with the lowest EU). The six
-	 * columns are the modes defined in data/vehicle.csv.
+	 * Helper penalty tables. Each determinant returns a cost value (a lower value
+	 * is preferred). The six columns are the modes defined in data/vehicle.csv.
 	 */
 	private static String modeOf(Option opt) {
 		return ((MobilityOption) opt).getMainVehicle().getName().toLowerCase();
diff --git a/src/framework/agent/reasoning/Determinant.java b/src/framework/agent/reasoning/Determinant.java
index bede381..fc8111c 100644
--- a/src/framework/agent/reasoning/Determinant.java
+++ b/src/framework/agent/reasoning/Determinant.java
@@ -42,10 +42,7 @@ public Determinant(String id, double weight) {
 	public Map<Double, Set<Option>> rankOptions(Set<Option> inputOpts, Task task) {
 		Map<Double, Set<Option>> rankingResult = new HashMap<Double, Set<Option>>();
 		Map<Double, Set<Option>> valueToOptsMap = evalOpts(inputOpts, task);
-		// Normalise by the sum over ALL options (thesis Eq. 4.7: Sum_o U_o(c)),
-		// counting each distinct value once per option that holds it. (The
-		// earlier version summed distinct values only, which diverged whenever
-		// two options shared a value.)
+		// Sum of the values over all options.
 		double sumValue = 0;
 		for (Map.Entry<Double, Set<Option>> entry : valueToOptsMap.entrySet()) {
 			sumValue += entry.getKey() * entry.getValue().size();

From edba9519a5f6fe6265420f3cb8df1ba650b29875 Mon Sep 17 00:00:00 2001
From: Amy Liffey <amy.liffey@hes-so.ch>
Date: Tue, 7 Jul 2026 16:01:45 +0200
Subject: [PATCH 24/25] fix: adjust agent values

---
 data/agent.csv | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/data/agent.csv b/data/agent.csv
index d9814e4..1330809 100644
--- a/data/agent.csv
+++ b/data/agent.csv
@@ -1,5 +1,5 @@
 id,loc_id,funding,resources,time_weight,cost_weight,norm_weight,role_weight,self_weight,emotion_weight,facilitating_weight,frequency_weight,attitude_weight,social_weight,affect_weight,intention_weight,habit_weight
-1,1,100,4;5;6,1,5,1,1,1,1,1,1,1,1,1,1,1
+1,1,100,4;5;6,4,2,3,2,3,1,2,3,4,2,2,4,3
 2,1,150,4;5,5,1,2,1,1,3,1,1,1,1,1,1,1
 3,2,90,5;6,2,1,2,5,2,1,1,1,1,1,1,1,1
 4,2,200,4,3,2,1,1,1,2,1,4,1,1,1,1,1

From 2844103607c052e13c9c2cad3daccea09cbfb21a Mon Sep 17 00:00:00 2001
From: Amy Liffey <amy.liffey@hes-so.ch>
Date: Wed, 8 Jul 2026 11:59:46 +0200
Subject: [PATCH 25/25] chore: guards

---
 data/vehicle.csv                                 |  6 +++---
 src/dummy/agent/DummyPerceptionComponent.java    |  1 -
 src/dummy/agent/StandardDummyAgent.java          | 14 +++++++-------
 src/dummy/concept/MobilityTask.java              | 15 +++++++++------
 src/framework/agent/core/TaskExecutionAgent.java |  3 +++
 5 files changed, 22 insertions(+), 17 deletions(-)

diff --git a/data/vehicle.csv b/data/vehicle.csv
index 6f41190..053a8a5 100644
--- a/data/vehicle.csv
+++ b/data/vehicle.csv
@@ -1,7 +1,7 @@
 vehicle_id,name,speed_km_per_hr,cost_per_km
-1,train,20,4.5
+1,train,90,0.1667
 2,bus,7,2
 3,tram,12,2.5
-4,car,50,2.7
+4,car,60,0.2222
 5,walking,4,0
-6,biking,8,0
+6,biking,18,0
diff --git a/src/dummy/agent/DummyPerceptionComponent.java b/src/dummy/agent/DummyPerceptionComponent.java
index 3e7ad82..0be83b7 100644
--- a/src/dummy/agent/DummyPerceptionComponent.java
+++ b/src/dummy/agent/DummyPerceptionComponent.java
@@ -5,7 +5,6 @@
 import org.apache.log4j.Level;
 import org.apache.log4j.Logger;
 
-import dummy.concept.MobilityEnvironmentalState;
 import dummy.concept.MobilityInternalState;
 import dummy.concept.MobilityOption;
 import dummy.concept.MobilityTask;
diff --git a/src/dummy/agent/StandardDummyAgent.java b/src/dummy/agent/StandardDummyAgent.java
index 7cce85d..75c7396 100644
--- a/src/dummy/agent/StandardDummyAgent.java
+++ b/src/dummy/agent/StandardDummyAgent.java
@@ -174,12 +174,11 @@ protected double evalOpt(Option opt, Task task) {
 	}
 
 	private Determinant createSelfDeterminant() {
-		// Self-concept: the agent identifies with the modes it owns.
+		// Self-concept: preference ranking per mode.
 		return new LeafDeterminant("self", this.selfWeight) {
 			@Override
 			protected double evalOpt(Option opt, Task task) {
-				Vehicle v = ((MobilityOption) opt).getMainVehicle();
-				return logged("SELF", opt, StandardDummyAgent.this.ownVehicles.contains(v) ? 0.0 : 2.0);
+				return logged("SELF", opt, lookup(SELF_CONCEPT, modeOf(opt)));
 			}
 		};
 	}
@@ -238,10 +237,11 @@ private static double lookup(Map<String, Double> table, String mode) {
 	}
 
 	//                                             train  bus  tram  car  walking  biking
-	private static final Map<String, Double> SOCIAL_NORM   = penalties(1, 1, 1, 2, 1, 1);
-	private static final Map<String, Double> EMISSIONS     = penalties(1, 2, 1, 3, 0, 0);
-	private static final Map<String, Double> DISCOMFORT    = penalties(1, 2, 1, 0, 3, 2);
-	private static final Map<String, Double> INCONVENIENCE = penalties(1, 2, 1, 0, 0, 0);
+	private static final Map<String, Double> SOCIAL_NORM   = penalties(1, 1, 1, 2, 1, 3);
+	private static final Map<String, Double> EMISSIONS     = penalties(2, 2, 1, 3, 0, 1);
+	private static final Map<String, Double> DISCOMFORT    = penalties(2, 2, 1, 1, 3, 3);
+	private static final Map<String, Double> INCONVENIENCE = penalties(0, 2, 1, 0, 0, 0);
+	private static final Map<String, Double> SELF_CONCEPT  = penalties(2, 2, 2, 1, 3, 3);
 	private static final Map<String, Double> RELIABILITY   = penalties(1, 2, 1, 1, 0, 0);
 
 	private static Map<String, Double> penalties(double train, double bus, double tram, double car, double walking,
diff --git a/src/dummy/concept/MobilityTask.java b/src/dummy/concept/MobilityTask.java
index 33647c6..3e9e182 100644
--- a/src/dummy/concept/MobilityTask.java
+++ b/src/dummy/concept/MobilityTask.java
@@ -1,6 +1,7 @@
 package dummy.concept;
 
 import java.util.HashSet;
+import java.util.Objects;
 import java.util.Set;
 
 import org.apache.log4j.Level;
@@ -74,13 +75,15 @@ public String toString() {
 	public boolean equals(Object other) {
 		if (this == other)
 			return true;
-		if (other == null)
+		if (!(other instanceof MobilityTask))
 			return false;
-		if (other instanceof MobilityTask) {
-			MobilityTask otherTask = (MobilityTask) other;
-			return this.timeStart == otherTask.getTimeStart();
-		}
-		return false;
+		MobilityTask o = (MobilityTask) other;
+		return this.timeStart == o.timeStart && this.distance == o.distance
+				&& Objects.equals(this.fromLoc, o.fromLoc) && Objects.equals(this.toLoc, o.toLoc);
+	}
 
+	@Override
+	public int hashCode() {
+		return Objects.hash(this.timeStart, this.distance, this.fromLoc, this.toLoc);
 	}
 }
diff --git a/src/framework/agent/core/TaskExecutionAgent.java b/src/framework/agent/core/TaskExecutionAgent.java
index 88efe18..51669a3 100644
--- a/src/framework/agent/core/TaskExecutionAgent.java
+++ b/src/framework/agent/core/TaskExecutionAgent.java
@@ -82,6 +82,9 @@ protected void setupOverrides() {
 	@Override
 	public void step() throws Exception {
 		LOGGER.log(Level.DEBUG, "Agent " + this.id + " is stepping.");
+		if (schedule.isEmpty()) {
+			return;
+		}
 		// Get the next event from schedule.
 		Task task = schedule.remove(0);
 		EnvironmentalState environmentalState = loc.getEnvironmentalState();