feat: resolve mobile Tomorrow plan conflicts (Closes #1164)

tests/e2e/test_mobile_tomorrow_conflict_release.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+import json
+import os
+import threading
+from pathlib import Path
+
+import pytest
+
+if os.getenv("STACKCHAIN_RUN_RELEASE_E2E") != "1":
+    pytest.skip("packaged Tomorrow conflict journey runs only in its gated CI job", allow_module_level=True)
+pytest.importorskip("playwright.sync_api")
+from playwright.sync_api import expect, sync_playwright
+
+from fake_gitea import FakeGiteaServer
+from test_mobile_offline_issue_release import ACCESS_TOKEN, ROOT, release_server
+
+
+@pytest.mark.parametrize(("width", "height"), [(320, 568), (390, 844)])
+def test_release_artifact_resolves_cross_device_tomorrow_conflicts_on_mobile(
+    tmp_path: Path, width: int, height: int
+):
+    archives = sorted((ROOT / "dist").glob("stackchain-dashboard-*.tar.gz"))
+    assert len(archives) == 1, "browser job must download exactly one assembled release archive"
+
+    fake = FakeGiteaServer(("127.0.0.1", 0))
+    fake_thread = threading.Thread(target=fake.serve_forever, daemon=True)
+    fake_thread.start()
+    fake_url = f"http://127.0.0.1:{fake.server_port}"
+    put_bodies: list[dict] = []
+
+    try:
+        with release_server(archives[0], tmp_path, fake_url) as origin, sync_playwright() as playwright:
+            browser = playwright.chromium.launch(args=["--ignore-certificate-errors"])
+            context = browser.new_context(
+                viewport={"width": width, "height": height}, ignore_https_errors=True
+            )
+            page = context.new_page()
+
+            def tomorrow_route(route):
+                if route.request.method == "PUT":
+                    body = json.loads(route.request.post_data or "{}")
+                    put_bodies.append(body)
+                    if body.get("base_revision") != 12:
+                        route.fulfill(status=409, content_type="application/json", body='{"detail":"changed elsewhere"}')
+                        return
+                    route.fulfill(
+                        status=200,
+                        content_type="application/json",
+                        body=json.dumps({"revision": 13, **body}),
+                    )
+                    return
+                route.fulfill(
+                    status=200,
+                    content_type="application/json",
+                    body=json.dumps(
+                        {
+                            "revision": 12,
+                            "ids": ["issue:acme/mobile:server:"],
+                            "capacity_minutes": 60,
+                            "estimates": {"issue:acme/mobile:server:": 30},
+                            "plan_date": "2026-08-21",
+                            "timezone": "UTC",
+                        }
+                    ),
+                )
+
+            page.route("**/api/v1/tomorrow", tomorrow_route)
+            page.goto(origin + "/", wait_until="networkidle")
+            page.locator('input[name="device_label"]').fill("Tomorrow conflict release phone")
+            page.locator('input[name="access_token"]').fill(ACCESS_TOKEN)
+            page.locator("#submit-sign-in").click()
+            page.wait_for_url(origin + "/", wait_until="networkidle")
+
+            def stage_phone_plan():
+                page.evaluate(
+                    """() => {
+                      localStorage.setItem('stackchain.tomorrow-sync.v1.timmy', JSON.stringify({
+                        base_revision:11, revision:11,
+                        ids:['issue:acme/mobile:phone:'], capacity_minutes:90,
+                        estimates:{'issue:acme/mobile:phone:':45},
+                        plan_date:'2026-08-21', timezone:'UTC', sync_pending:true,
+                      }));
+                      window.dispatchEvent(new Event('online'));
+                    }"""
+                )
+                expect(page.locator("#mobile-tomorrow-summary")).to_have_text(
+                    "Conflict · review required"
+                )
+
+            def open_conflict():
+                queue_sheet = page.locator("#mobile-queue-sheet")
+                if not queue_sheet.evaluate("element => element.open"):
+                    page.locator('[data-mobile-task="queues"]').click()
+                page.locator('[data-mobile-queue="tomorrow"]').click()
+                review = page.locator("#tomorrow-conflict-review")
+                expect(review).to_be_visible()
+                expect(page.locator("#plan-today-title")).to_have_text(
+                    "Resolve Tomorrow conflict"
+                )
+                expect(page.locator("#tomorrow-conflict-phone-plan")).to_contain_text(
+                    "issue:acme/mobile:phone:"
+                )
+                expect(page.locator("#tomorrow-conflict-phone-plan")).to_contain_text(
+                    "45 min"
+                )
+                expect(page.locator("#tomorrow-conflict-server-plan")).to_contain_text(
+                    "issue:acme/mobile:server:"
+                )
+                expect(page.locator("#tomorrow-conflict-server-plan")).to_contain_text(
+                    "30 min"
+                )
+                expect(page.locator("#keep-phone-tomorrow")).to_be_focused()
+                for selector in ("#keep-phone-tomorrow", "#use-server-tomorrow"):
+                    bounds = page.locator(selector).bounding_box()
+                    assert bounds and bounds["height"] >= 44
+                assert page.evaluate("document.documentElement.scrollWidth <= window.innerWidth")
+
+            stage_phone_plan()
+            open_conflict()
+            initial_puts = len(put_bodies)
+            page.locator("#use-server-tomorrow").click()
+            expect(page.locator("#plan-today-sheet")).to_be_hidden()
+            expect(page.locator("#mobile-tomorrow-summary")).to_contain_text("1 planned")
+            assert len(put_bodies) == initial_puts
+
+            stage_phone_plan()
+            open_conflict()
+            page.locator("#keep-phone-tomorrow").click()
+            expect(page.locator("#plan-today-sheet")).to_be_hidden()
+            expect(page.locator("#mobile-tomorrow-summary")).to_contain_text("1 planned · 45 of 90 min")
+            assert put_bodies[-1]["base_revision"] == 12
+            assert put_bodies[-1]["ids"] == ["issue:acme/mobile:phone:"]
+            assert page.evaluate(
+                "localStorage.getItem('stackchain.tomorrow-sync.v1.timmy')"
+            ) is None
+            assert page.evaluate("document.documentElement.scrollWidth <= window.innerWidth")
+            browser.close()
+    finally:
+        fake.shutdown()
+        fake.server_close()
+        fake_thread.join(timeout=5)

tests/test_tomorrow_plan_frontend.py

@@ -110,6 +110,63 @@ console.log(JSON.stringify({requests,message,pending:planner.pending(),conflict:
     assert result["conflict"]["remote"]["revision"] == 12
 
 
+def test_tomorrow_planner_keeps_phone_plan_by_rebasing_once_onto_conflict_revision():
+    result = run_controller("""
+const values=new Map();
+const storage={getItem:key=>values.get(key)||null,setItem:(key,value)=>values.set(key,value),removeItem:key=>values.delete(key)};
+const requests=[];
+let puts=0;
+const fetchJson=async (_url,options={})=>{
+  requests.push({method:options.method||'GET',body:options.body?JSON.parse(options.body):null});
+  if(options.method==='PUT'&&puts++===0){const error=new Error('changed elsewhere');error.status=409;throw error;}
+  if(options.method==='PUT') return {revision:13,...JSON.parse(options.body)};
+  return {revision:12,ids:['issue:r:server:'],capacity_minutes:60,estimates:{'issue:r:server:':30},plan_date:'2026-08-20',timezone:'UTC'};
+};
+const planner=createTomorrowPlan({storage,getLogin:()=> 'timmy',fetchJson,
+  localDate:()=> '2026-08-19',timeZone:()=> 'UTC'});
+planner.adopt({revision:11,ids:[],capacity_minutes:null,estimates:{}});
+planner.stage({ids:['issue:r:phone:'],capacity_minutes:90,estimates:{'issue:r:phone:':45}});
+try { await planner.flush(); } catch(_error) {}
+const saved=await planner.keepLocal();
+console.log(JSON.stringify({saved,requests,pending:planner.pending(),conflict:planner.conflict(),state:planner.state()}));
+""")
+
+    assert [request["method"] for request in result["requests"]] == ["PUT", "GET", "PUT"]
+    assert result["requests"][2]["body"]["base_revision"] == 12
+    assert result["requests"][2]["body"]["ids"] == ["issue:r:phone:"]
+    assert result["saved"]["revision"] == 13
+    assert result["pending"] is False
+    assert result["conflict"] is None
+    assert result["state"]["ids"] == ["issue:r:phone:"]
+
+
+def test_tomorrow_planner_uses_server_plan_without_a_second_write():
+    result = run_controller("""
+const values=new Map();
+const storage={getItem:key=>values.get(key)||null,setItem:(key,value)=>values.set(key,value),removeItem:key=>values.delete(key)};
+const requests=[];
+const fetchJson=async (_url,options={})=>{
+  requests.push(options.method||'GET');
+  if(options.method==='PUT'){const error=new Error('changed elsewhere');error.status=409;throw error;}
+  return {revision:12,ids:['issue:r:server:'],capacity_minutes:60,estimates:{'issue:r:server:':30},plan_date:'2026-08-20',timezone:'UTC'};
+};
+const planner=createTomorrowPlan({storage,getLogin:()=> 'timmy',fetchJson,
+  localDate:()=> '2026-08-19',timeZone:()=> 'UTC'});
+planner.adopt({revision:11,ids:[],capacity_minutes:null,estimates:{}});
+planner.stage({ids:['issue:r:phone:'],capacity_minutes:90,estimates:{'issue:r:phone:':45}});
+try { await planner.flush(); } catch(_error) {}
+const adopted=planner.useRemote();
+console.log(JSON.stringify({adopted,requests,pending:planner.pending(),conflict:planner.conflict(),state:planner.state()}));
+""")
+
+    assert result["requests"] == ["PUT", "GET"]
+    assert result["adopted"]["revision"] == 12
+    assert result["adopted"]["ids"] == ["issue:r:server:"]
+    assert result["pending"] is False
+    assert result["conflict"] is None
+    assert result["state"] == result["adopted"]
+
+
 def test_tomorrow_planner_loads_and_saves_independently_from_today():
     result = run_controller("""
 const requests=[];
@@ -269,6 +326,23 @@ console.log(JSON.stringify({empty,planned,unestimated,pending}));
     }
 
 
+def test_mobile_tomorrow_conflict_review_exposes_two_touch_safe_resolution_paths():
+    index = INDEX.read_text()
+    css = CSS.read_text()
+    dashboard = (FRONTEND / "dashboard.js").read_text()
+
+    assert 'id="tomorrow-conflict-review"' in index
+    assert 'id="tomorrow-conflict-phone-plan"' in index
+    assert 'id="tomorrow-conflict-server-plan"' in index
+    assert 'id="keep-phone-tomorrow"' in index
+    assert 'id="use-server-tomorrow"' in index
+    assert "Conflict · review required" in dashboard
+    assert "if (tomorrowPlan.conflict())" in dashboard
+    assert "tomorrowPlan.keepLocal()" in dashboard
+    assert "tomorrowPlan.useRemote()" in dashboard
+    assert ".tomorrow-conflict-actions button { min-height:44px;" in css
+
+
 def test_mobile_tomorrow_save_is_admitted_before_background_delivery():
     dashboard = (FRONTEND / "dashboard.js").read_text()