@agentprojectcontext/apx 1.81.0 → 1.89.1

package/src/interfaces/android/app/src/main/res/values-v31/styles.xml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <style name="AppTheme" parent="android:style/Theme.Material.NoActionBar">
+        <item name="android:fontFamily">sans</item>
+        <item name="android:colorAccent">@color/apx_green</item>
+        <item name="android:navigationBarColor">@color/apx_dark</item>
+        <item name="android:statusBarColor">@color/apx_dark</item>
+        <item name="android:windowLightStatusBar">false</item>
+        <item name="android:windowBackground">@drawable/app_background</item>
+        <item name="android:windowSplashScreenBackground">@color/apx_dark</item>
+        <item name="android:windowSplashScreenAnimatedIcon">@mipmap/ic_launcher</item>
+        <item name="android:windowSplashScreenIconBackgroundColor">@color/apx_dark</item>
+    </style>
+</resources>

package/src/interfaces/android/app/src/main/res/xml/automotive_app_desc.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<automotiveApp>
+    <!-- The card APX already posted for chat messages. -->
+    <uses name="notification" />
+    <!-- The chip: a real screen on the head unit, drawn by ApxCarAppService.
+         It is what lets a proximity alert show four answers, which a
+         notification on this surface never can. -->
+    <uses name="template" />
+</automotiveApp>

package/src/interfaces/android/app/src/main/res/xml/network_security_config.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<network-security-config>
+    <!-- APX daemons commonly run over a trusted private LAN using HTTP. -->
+    <base-config cleartextTrafficPermitted="true">
+        <trust-anchors>
+            <certificates src="system" />
+            <certificates src="user" />
+        </trust-anchors>
+    </base-config>
+</network-security-config>

package/src/interfaces/android/app/src/test/java/dev/agentprojectcontext/apx/AndroidAutoDetectorTest.java

@@ -0,0 +1,85 @@
+package dev.agentprojectcontext.apx;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+/**
+ * The line this detector has to hold: Android Auto talks to the phone both
+ * when it is running and when it wants to be. Only the first is a trip.
+ */
+public final class AndroidAutoDetectorTest {
+    @Test
+    public void recognisesARunningProjectionSession() {
+        assertTrue(AndroidAutoDetector.isProjectionActive(
+            AndroidAutoDetector.AUTO_PACKAGE, true, "Android Auto", "Android Auto está en ejecución"
+        ));
+        assertTrue(AndroidAutoDetector.isProjectionActive(
+            AndroidAutoDetector.AUTO_PACKAGE, true, "Android Auto", "Android Auto is running"
+        ));
+    }
+
+    @Test
+    public void ignoresAnInvitationToSetAndroidAutoUp() {
+        assertFalse(AndroidAutoDetector.isProjectionActive(
+            AndroidAutoDetector.AUTO_PACKAGE, true, "Android Auto", "Tocá para configurar Android Auto"
+        ));
+        assertFalse(AndroidAutoDetector.isProjectionActive(
+            AndroidAutoDetector.AUTO_PACKAGE, true, "Android Auto", "Tap to set up Android Auto"
+        ));
+        assertFalse(AndroidAutoDetector.isProjectionActive(
+            AndroidAutoDetector.AUTO_PACKAGE, true, "Android Auto disponible", "Conectá tu teléfono al auto"
+        ));
+    }
+
+    @Test
+    public void aDismissibleNotificationIsNeverASession() {
+        // A live projection posts a foreground-service notification, which the
+        // user cannot swipe away. Anything dismissible is an announcement.
+        assertFalse(AndroidAutoDetector.isProjectionActive(
+            AndroidAutoDetector.AUTO_PACKAGE, false, "Android Auto", "Android Auto está en ejecución"
+        ));
+    }
+
+    @Test
+    public void recognisesWhatARealHeadUnitSessionActuallyPosts() {
+        // Verbatim from a Galaxy A55 projecting to a head unit. It arrives with
+        // FLAG_NO_CLEAR | FLAG_FOREGROUND_SERVICE and NO FLAG_ONGOING_EVENT,
+        // which is why the caller must fold both flags into `persistent`.
+        assertTrue(AndroidAutoDetector.isProjectionActive(
+            AndroidAutoDetector.AUTO_PACKAGE, true, "Android Auto", "Conectado al vehículo"
+        ));
+    }
+
+    @Test
+    public void theDeveloperHeadUnitServerIsNotACar() {
+        // Developer mode posts this while the DHU port is open. A server
+        // waiting for a head unit would otherwise pin the phone in a trip for
+        // as long as developer mode stays on.
+        assertFalse(AndroidAutoDetector.isProjectionActive(
+            AndroidAutoDetector.AUTO_PACKAGE,
+            true,
+            "Programador de Android Auto",
+            "Servidor de unidad principal en ejecución"
+        ));
+    }
+
+    @Test
+    public void otherAppsAreNeverAndroidAuto() {
+        assertFalse(AndroidAutoDetector.isAutoPackage(MapsNavigationDetector.MAPS_PACKAGE));
+        assertFalse(AndroidAutoDetector.isProjectionActive(
+            MapsNavigationDetector.MAPS_PACKAGE, true, "Navegando", "Android Auto está en ejecución"
+        ));
+    }
+
+    @Test
+    public void anOngoingSessionInAnUntranslatedLocaleStillCounts() {
+        // The running-terms list cannot cover every language Android Auto
+        // ships in; an ongoing notification from the projection app that is
+        // not an offer is a session in all of them.
+        assertTrue(AndroidAutoDetector.isProjectionActive(
+            AndroidAutoDetector.AUTO_PACKAGE, true, "Android Auto", "自動車モードで実行中"
+        ));
+    }
+}

package/src/interfaces/android/app/src/test/java/dev/agentprojectcontext/apx/CarAlertStoreTest.java

@@ -0,0 +1,104 @@
+package dev.agentprojectcontext.apx;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.List;
+
+/**
+ * What the head unit is showing, and what it must stop showing.
+ *
+ * The screens themselves need the template host to draw, so this covers the
+ * half that does not: which alerts are live, in what order, and that answering
+ * one anywhere takes it off the car.
+ */
+public final class CarAlertStoreTest {
+
+    private static MessageFrameParser.MobilityAlert alert(String id, String title) {
+        return new MessageFrameParser.MobilityAlert(
+            id, title, "Farmacia", "Av. San Martin 1234", title + " cerca", "1.4 km", "Comprar algo",
+            -41.13, -71.31, "https://maps/nav", "https://maps/stop",
+            List.of(new MessageFrameParser.Action("navigate", "Navegar ahora"))
+        );
+    }
+
+    @Before
+    public void reset() {
+        CarAlertStore.clear();
+    }
+
+    @Test
+    public void keepsAlertsNewestLast() {
+        CarAlertStore.put(alert("a", "Farmacia"));
+        CarAlertStore.put(alert("b", "Ferretería"));
+        assertEquals(List.of("a", "b"), CarAlertStore.all().stream()
+            .map(MessageFrameParser.MobilityAlert::id).toList());
+    }
+
+    @Test
+    public void reSendingAnAlertReplacesItInsteadOfDuplicatingIt() {
+        // The daemon can re-push a card — a phone that reconnects mid-drive
+        // gets the live set again. Two rows for one place would read as two
+        // errands at the same shop.
+        CarAlertStore.put(alert("a", "Farmacia"));
+        CarAlertStore.put(alert("a", "Farmacia del Puente"));
+        assertEquals(1, CarAlertStore.all().size());
+        assertEquals("Farmacia del Puente", CarAlertStore.all().get(0).title());
+    }
+
+    @Test
+    public void dropsTheOldestPastTheCap() {
+        // A car screen is read at speed. Past a handful nobody is choosing, and
+        // nothing here would ever forget on its own during a long drive.
+        for (int i = 0; i < 8; i++) CarAlertStore.put(alert("a" + i, "Lugar " + i));
+        List<String> ids = CarAlertStore.all().stream()
+            .map(MessageFrameParser.MobilityAlert::id).toList();
+        assertEquals(5, ids.size());
+        assertEquals(List.of("a3", "a4", "a5", "a6", "a7"), ids);
+    }
+
+    @Test
+    public void answeringAnywhereTakesItOffTheCar() {
+        CarAlertStore.put(alert("a", "Farmacia"));
+        CarAlertStore.remove("a");
+        assertTrue(CarAlertStore.all().isEmpty());
+        assertNull(CarAlertStore.get("a"));
+    }
+
+    @Test
+    public void theTripEndingClearsEverything() {
+        CarAlertStore.put(alert("a", "Farmacia"));
+        CarAlertStore.put(alert("b", "Ferretería"));
+        CarAlertStore.clear();
+        assertTrue(CarAlertStore.all().isEmpty());
+    }
+
+    @Test
+    public void aScreenIsToldWhenTheSetMoves() {
+        int[] calls = {0};
+        Runnable listener = () -> calls[0]++;
+        CarAlertStore.addListener(listener);
+        CarAlertStore.put(alert("a", "Farmacia"));
+        CarAlertStore.remove("a");
+        assertEquals(2, calls[0]);
+
+        // A screen that has gone away must stop being called, or the store
+        // holds a dead Screen for the rest of the drive.
+        CarAlertStore.removeListener(listener);
+        CarAlertStore.put(alert("b", "Ferretería"));
+        assertEquals(2, calls[0]);
+    }
+
+    @Test
+    public void removingSomethingThatIsNotThereTellsNobody() {
+        int[] calls = {0};
+        CarAlertStore.addListener(() -> calls[0]++);
+        CarAlertStore.remove("never-existed");
+        CarAlertStore.clear();          // already empty
+        assertEquals(0, calls[0]);
+    }
+}

package/src/interfaces/android/app/src/test/java/dev/agentprojectcontext/apx/DaemonAddressTest.java

@@ -0,0 +1,23 @@
+package dev.agentprojectcontext.apx;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThrows;
+
+import org.junit.Test;
+
+public final class DaemonAddressTest {
+    @Test
+    public void normalizesLanAddress() {
+        assertEquals("http://192.0.2.20:7430", DaemonAddress.normalize("192.0.2.20:7430/mobile"));
+    }
+
+    @Test
+    public void keepsHttpsAddress() {
+        assertEquals("https://apx.example.com", DaemonAddress.normalize("https://apx.example.com/mobile"));
+    }
+
+    @Test
+    public void rejectsUnsupportedScheme() {
+        assertThrows(IllegalArgumentException.class, () -> DaemonAddress.normalize("ftp://example.com"));
+    }
+}

package/src/interfaces/android/app/src/test/java/dev/agentprojectcontext/apx/MapsNavigationDetectorTest.java

@@ -0,0 +1,69 @@
+package dev.agentprojectcontext.apx;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+public final class MapsNavigationDetectorTest {
+    @Test
+    public void acceptsMapsNavigationCategory() {
+        assertTrue(MapsNavigationDetector.isLikelyNavigation(
+            MapsNavigationDetector.MAPS_PACKAGE,
+            "navigation",
+            true,
+            "Google Maps",
+            "Ruta activa"
+        ));
+    }
+
+    @Test
+    public void acceptsSpanishTurnGuidanceWithoutCategory() {
+        assertTrue(MapsNavigationDetector.isLikelyNavigation(
+            MapsNavigationDetector.MAPS_PACKAGE,
+            null,
+            true,
+            "Continúa por Avenida Belgrano",
+            "Gira a la derecha en 500 m"
+        ));
+    }
+
+    @Test
+    public void rejectsOtherAppsAndNonOngoingMapsNotices() {
+        assertFalse(MapsNavigationDetector.isLikelyNavigation(
+            "org.example.maps",
+            "navigation",
+            true,
+            "Navegando",
+            "5 min"
+        ));
+        assertFalse(MapsNavigationDetector.isLikelyNavigation(
+            MapsNavigationDetector.MAPS_PACKAGE,
+            null,
+            false,
+            "Nuevo lugar recomendado",
+            "Cerca tuyo"
+        ));
+    }
+
+    @Test
+    public void extractsSamsungNavigationDestination() {
+        assertTrue(MapsNavigationDetector.destinationFrom(
+            "en dirección a Parque Nacional Laguna Blanca"
+        ).equals("Parque Nacional Laguna Blanca"));
+        assertTrue(MapsNavigationDetector.destinationFrom(
+            "heading to Central Station"
+        ).equals("Central Station"));
+        assertTrue(MapsNavigationDetector.destinationFrom(
+            "Estoy yendo a La Anónima km 4"
+        ).equals("La Anónima km 4"));
+    }
+
+    @Test
+    public void rejectsHonorTurnInstructionAsDestination() {
+        assertTrue(MapsNavigationDetector.destinationFrom(
+            "Dirígete hacia Parque Nacional Laguna Blanca",
+            "Llegada: 5:55 p. m."
+        ).isBlank());
+    }
+}

package/src/interfaces/android/app/src/test/java/dev/agentprojectcontext/apx/MapsShareIntentParserTest.java

@@ -0,0 +1,31 @@
+package dev.agentprojectcontext.apx;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+public final class MapsShareIntentParserTest {
+    @Test
+    public void extractsDestinationFromMapsDirectionsUrl() {
+        String shared = "Mirá mi viaje https://www.google.com/maps/dir/?api=1&destination=La+Anonima+Km+4&travelmode=driving";
+
+        assertTrue(MapsShareIntentParser.isGoogleMapsShare(shared));
+        assertEquals("La Anonima Km 4", MapsShareIntentParser.destinationFrom(shared));
+    }
+
+    @Test
+    public void keepsLiveMapsShortLinkWhenDestinationIsOpaque() {
+        String shared = "Estoy en camino. Consulta el progreso de mi viaje y la hora de llegada en Maps: https://maps.app.goo.gl/AbCdEf123";
+
+        assertTrue(MapsShareIntentParser.isGoogleMapsShare(shared));
+        assertEquals("https://maps.app.goo.gl/AbCdEf123", MapsShareIntentParser.destinationFrom(shared));
+    }
+
+    @Test
+    public void rejectsGenericTextShares() {
+        assertFalse(MapsShareIntentParser.isGoogleMapsShare("comprar cartulina"));
+        assertEquals("", MapsShareIntentParser.destinationFrom("comprar cartulina"));
+    }
+}

package/src/interfaces/android/app/src/test/java/dev/agentprojectcontext/apx/MessageFrameParserTest.java

@@ -0,0 +1,180 @@
+package dev.agentprojectcontext.apx;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+import java.util.List;
+
+public final class MessageFrameParserTest {
+    /** The lines alone, for the assertions that are about wording. */
+    private static List<String> lines(String frame) {
+        return MessageFrameParser.notices(frame).stream().map(MessageFrameParser.Notice::text).toList();
+    }
+
+    @Test
+    public void prefersDaemonNotificationsAndTreatsEmptyAsNoNews() {
+        String ready = """
+            {"type":"messages","notifications":["sofia respondió en Telegram"],"events":[
+              {"direction":"in","channel":"telegram"}
+            ]}
+            """;
+        assertEquals(List.of("sofia respondió en Telegram"), lines(ready));
+
+        String ownerSend = """
+            {"type":"messages","notifications":[],"events":[
+              {"direction":"in","channel":"telegram","type":"user"}
+            ]}
+            """;
+        assertTrue(MessageFrameParser.notices(ownerSend).isEmpty());
+    }
+
+    @Test
+    public void readsTheChannelEachNoticeIsAboutWhenTheDaemonTagsThem() {
+        String frame = """
+            {"type":"messages","notices":[
+              {"text":"Roby respondió en Telegram","channel":"telegram"},
+              {"text":"Pasá por La Anónima","channel":"mobility"}
+            ],"notifications":["Roby respondió en Telegram","Pasá por La Anónima"],"events":[]}
+            """;
+
+        assertEquals(
+            List.of(
+                new MessageFrameParser.Notice("Roby respondió en Telegram", "telegram"),
+                new MessageFrameParser.Notice("Pasá por La Anónima", "mobility")
+            ),
+            MessageFrameParser.notices(frame)
+        );
+    }
+
+    @Test
+    public void anUntaggedLineFromAnOlderDaemonHasNoChannelAndSoAlwaysRings() {
+        String frame = """
+            {"type":"messages","notifications":["sofia respondió en Telegram"],"events":[]}
+            """;
+
+        List<MessageFrameParser.Notice> notices = MessageFrameParser.notices(frame);
+        assertEquals(1, notices.size());
+        assertEquals(null, notices.get(0).channel());
+        assertFalse(NotifyChannels.known(notices.get(0).channel()));
+    }
+
+    @Test
+    public void ignoresOwnerSendAndBubblesAgentFinalsWhenDaemonOmitsTheField() {
+        String frame = """
+            {"type":"messages","events":[
+              {"direction":"in","channel":"telegram","type":"user"},
+              {"direction":"in","channel":"group","type":"user"},
+              {"direction":"out","channel":"telegram","type":"agent","streamed":true,"author":"Roby"},
+              {"direction":"out","channel":"telegram","type":"agent","author":"Roby","agent_slug":"super_agent"},
+              {"direction":"out","channel":"group","type":"agent","author":"sofia","agent_slug":"sofia"},
+              {"direction":"out","channel":"a2a","type":"agent","author":"martin","agent_slug":"martin"},
+              {"direction":"in","channel":"a2a","type":"agent","author":"martin"}
+            ]}
+            """;
+
+        assertEquals(
+            List.of(
+                new MessageFrameParser.Notice("Roby respondió en Telegram", "telegram"),
+                new MessageFrameParser.Notice("sofia respondió en Grupo", "group"),
+                new MessageFrameParser.Notice("martin respondió en A2A", "a2a")
+            ),
+            MessageFrameParser.notices(frame)
+        );
+    }
+
+    @Test
+    public void rejectsMalformedFrames() {
+        assertTrue(MessageFrameParser.notices("not json").isEmpty());
+    }
+
+    @Test
+    public void readsAvatarFromHelloAndSettingsFrames() {
+        assertEquals("coral", MessageFrameParser.avatar("{\"type\":\"hello\",\"settings\":{\"super_agent\":{\"icon\":\"coral\"}}}"));
+        assertEquals("zafiro", MessageFrameParser.avatar("{\"type\":\"settings\",\"settings\":{\"super_agent\":{\"icon\":\"zafiro\"}}}"));
+        assertEquals(null, MessageFrameParser.avatar("{\"type\":\"messages\",\"events\":[]}"));
+    }
+
+    @Test
+    public void surfacesMobilityDeliveryFromRobyAsApxNotification() {
+        String frame = """
+            {"type":"messages","events":[
+              {"direction":"out","channel":"telegram","via":"mobility_delivery","notify":"Pasá por La Anónima"}
+            ]}
+            """;
+
+        // Filed on Telegram, tagged mobility: muting Telegram must not silence
+        // the car.
+        assertEquals(
+            List.of(new MessageFrameParser.Notice("Pasá por La Anónima", "mobility")),
+            MessageFrameParser.notices(frame)
+        );
+    }
+
+    // ── the proximity card ──────────────────────────────────────────────────
+    // The frame the head unit and the phone both draw. It carries its whole
+    // payload, unlike the "go re-fetch" notices above: a phone in a tunnel
+    // cannot ask, and the card has to become four buttons within a second.
+
+    private static final String ALERT_FRAME = """
+        {"type":"mobility_alert","alert":{
+          "id":"mb1234","title":"Farmacia del Puente",
+          "address":"Av. San Martin 1234, Bariloche",
+          "body":"Estas cerca de Farmacia del Puente (1.4 km). Direccion: Av. San Martin 1234, Bariloche. Tarea: Comprar ibuprofeno",
+          "distance_label":"1.4 km","task":"Comprar ibuprofeno",
+          "latitude":-41.13,"longitude":-71.31,
+          "navigate_url":"https://maps.example/nav","add_stop_url":"https://maps.example/stop",
+          "actions":[{"id":"navigate","label":"Navegar ahora"},{"id":"add_stop","label":"Sumar a la ruta"},
+                     {"id":"next","label":"Para despues"},{"id":"skip","label":"No ahora"}]}}
+        """;
+
+    @Test
+    public void readsTheWholeCardIncludingTheAddress() {
+        MessageFrameParser.MobilityAlert alert = MessageFrameParser.mobilityAlert(ALERT_FRAME);
+        assertEquals("mb1234", alert.id());
+        assertEquals("Farmacia del Puente", alert.title());
+        assertEquals("Av. San Martin 1234, Bariloche", alert.address());
+        assertEquals("1.4 km", alert.distanceLabel());
+        assertEquals("Comprar ibuprofeno", alert.task());
+        assertEquals("https://maps.example/nav", alert.navigateUrl());
+        assertEquals("https://maps.example/stop", alert.addStopUrl());
+    }
+
+    @Test
+    public void keepsTheFourAnswersInTheOrderTheDaemonSentThem() {
+        // Android renders what it is given rather than holding its own copy of
+        // the list — a fifth answer must never need a new APK.
+        MessageFrameParser.MobilityAlert alert = MessageFrameParser.mobilityAlert(ALERT_FRAME);
+        assertEquals(
+            List.of("navigate", "add_stop", "next", "skip"),
+            alert.actions().stream().map(MessageFrameParser.Action::id).toList()
+        );
+        assertEquals("Navegar ahora", alert.actions().get(0).label());
+        assertEquals("No ahora", alert.actions().get(3).label());
+    }
+
+    @Test
+    public void missingOptionalFieldsAreNullRatherThanEmptyStrings() {
+        // The daemon omits what it does not know. A blank address rendered as
+        // "" would draw an empty line on the head unit under every place.
+        String frame = "{\"type\":\"mobility_alert\",\"alert\":{\"id\":\"mb2\",\"title\":\"Kiosco\",\"body\":\"Kiosco\"}}";
+        MessageFrameParser.MobilityAlert alert = MessageFrameParser.mobilityAlert(frame);
+        assertNull(alert.address());
+        assertNull(alert.task());
+        assertNull(alert.navigateUrl());
+        assertTrue(alert.actions().isEmpty());
+    }
+
+    @Test
+    public void anythingThatIsNotAnAlertFrameIsNull() {
+        assertNull(MessageFrameParser.mobilityAlert("{\"type\":\"messages\",\"notices\":[]}"));
+        assertNull(MessageFrameParser.mobilityAlert("{\"type\":\"mobility_alert\"}"));
+        // An alert with no id could never be answered — refuse it rather than
+        // drawing four buttons that go nowhere.
+        assertNull(MessageFrameParser.mobilityAlert("{\"type\":\"mobility_alert\",\"alert\":{\"title\":\"x\"}}"));
+        assertNull(MessageFrameParser.mobilityAlert("no json at all"));
+    }
+}

package/src/interfaces/android/app/src/test/java/dev/agentprojectcontext/apx/TravelEventGateTest.java

@@ -0,0 +1,64 @@
+package dev.agentprojectcontext.apx;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+public final class TravelEventGateTest {
+    @Test
+    public void waitsForKnownDestinationToRemainStable() {
+        assertEquals(
+            TravelEventGate.KNOWN_DESTINATION_SETTLE_MS,
+            TravelEventGate.delayMs(1_000L, "Onelli 444", 0L, "")
+        );
+    }
+
+    @Test
+    public void waitsTenMinutesBeforeUnknownTripPrompt() {
+        assertEquals(
+            TravelEventGate.UNKNOWN_DESTINATION_SETTLE_MS,
+            TravelEventGate.delayMs(1_000L, "", 0L, "")
+        );
+    }
+
+    @Test
+    public void suppressesRepeatedSameDestinationForThirtyMinutes() {
+        long sentAt = 10_000L;
+        assertTrue(TravelEventGate.coolingDown(sentAt + 60_000L, "Onelli 444", sentAt, "onelli 444"));
+        assertFalse(TravelEventGate.coolingDown(
+            sentAt + TravelEventGate.SAME_DESTINATION_COOLDOWN_MS,
+            "Onelli 444",
+            sentAt,
+            "Onelli 444"
+        ));
+    }
+
+    @Test
+    public void appliesGlobalCooldownToDifferentDestination() {
+        long sentAt = 10_000L;
+        assertEquals(
+            TravelEventGate.DIFFERENT_DESTINATION_COOLDOWN_MS - 60_000L,
+            TravelEventGate.delayMs(sentAt + 60_000L, "Albarracín 601", sentAt, "Onelli 444")
+        );
+    }
+
+    @Test
+    public void theUnknownDestinationWaitIsShortEnoughToStillBeUseful() {
+        // Ten minutes put the trip-start message half way through a short
+        // drive. What the long wait was protecting — a destination arriving
+        // late — is handled by the listener rescheduling at 45 s when it
+        // resolves, so the settle never had to cover it.
+        assertEquals(3 * 60_000L, TravelEventGate.UNKNOWN_DESTINATION_SETTLE_MS);
+        assertTrue(
+            "an unknown destination still waits longer than a known one",
+            TravelEventGate.UNKNOWN_DESTINATION_SETTLE_MS > TravelEventGate.KNOWN_DESTINATION_SETTLE_MS
+        );
+        // And it stays under the cooldown that follows a send, so shortening it
+        // cannot turn into two cards for one drive.
+        assertTrue(
+            TravelEventGate.UNKNOWN_DESTINATION_SETTLE_MS < TravelEventGate.DIFFERENT_DESTINATION_COOLDOWN_MS
+        );
+    }
+}

package/src/interfaces/android/app/src/test/java/dev/agentprojectcontext/apx/TripPlacesSheetTest.java

@@ -0,0 +1,66 @@
+package dev.agentprojectcontext.apx;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+/**
+ * The words on the errand cards. Only the pure label logic is covered here —
+ * assembling the views needs a Context, which a plain JVM test does not have —
+ * but the labels are where the lying happens, so they are the part worth
+ * pinning down.
+ */
+public class TripPlacesSheetTest {
+
+    @Test
+    public void readsDistanceInTheUnitTheDriverThinksIn() {
+        assertEquals("820 m", TripPlacesSheet.distanceLabel(820));
+        assertEquals("1,2 km", TripPlacesSheet.distanceLabel(1_200).replace('.', ','));
+        // Unknown is blank, never "0 m": claiming the shop is underfoot is
+        // worse than saying nothing about how far it is.
+        assertEquals("", TripPlacesSheet.distanceLabel(-1));
+    }
+
+    @Test
+    public void headlineIsThePlaceThenHowFar() {
+        assertEquals("La Anónima · 1.2 km".replace('.', ','),
+            TripPlacesSheet.headline("La Anónima", 1_200).replace('.', ','));
+        assertEquals("La Anónima", TripPlacesSheet.headline("La Anónima", -1));
+    }
+
+    @Test
+    public void anUnsettledErrandSaysItIsStillAChoice() {
+        // Bread can be bought at three supermarkets. Showing the nearest one
+        // without saying so would claim a decision APX has not made.
+        String line = TripPlacesSheet.stateLine("", false, 3);
+        assertTrue(line, line.startsWith("3 lugares posibles"));
+        // One candidate is the decision — nothing to disclose.
+        assertEquals("", TripPlacesSheet.stateLine("", false, 1));
+        assertEquals("Lugar elegido", TripPlacesSheet.stateLine("", true, 3));
+    }
+
+    @Test
+    public void anAnsweredErrandShowsTheAnswerAndNotTheOptions() {
+        assertEquals("Dijiste que vas", TripPlacesSheet.stateLine("go", true, 3));
+        assertEquals("Lo dejaste para otro día", TripPlacesSheet.stateLine("skip", false, 3));
+        // Declining a shop is not dropping the errand: the line has to say the
+        // difference, or the list reads as if the task were closed.
+        assertEquals("Te aviso en la siguiente", TripPlacesSheet.stateLine("next", false, 3));
+    }
+
+    @Test
+    public void theChipsCarryNoEmoji() throws Exception {
+        // The same labels reach a car head unit, where the Assistant reads them
+        // aloud — and a pin emoji comes out as its Unicode name mid-sentence.
+        String source = new String(java.nio.file.Files.readAllBytes(java.nio.file.Paths.get(
+            "src/main/java/dev/agentprojectcontext/apx/TripPlacesSheet.java")),
+            java.nio.charset.StandardCharsets.UTF_8);
+        for (String label : new String[] { "Navegar", "Sumar a la ruta", "Voy", "En la siguiente" }) {
+            int at = source.indexOf("\"" + label + "\"");
+            assertTrue("chip label missing: " + label, at > 0);
+        }
+        assertTrue("a chip label must not carry an emoji",
+            !source.contains("\"🧭") && !source.contains("\"✅") && !source.contains("\"❌") && !source.contains("\"➕"));
+    }
+}

package/src/interfaces/android/build.gradle

@@ -0,0 +1,3 @@
+plugins {
+    id "com.android.application" version "8.7.3" apply false
+}