Meddy files 6 source 74932ca

Meddy Debug and Release phone install tooling

Explicit signed phone updates through make install and make install-release, with no automatic launch or physical Watch installation.

At a glance

  • Automatic selection excludes simulators, iPads, Watches and unavailable historical pairings. Ambiguity stops before building; DEVICE_ID or DEVICE_MODEL chooses explicitly.

  • Existing bundle/team/container/signing settings remain. A temporary source copy omits embedded Watch content, using the established phone packaging adjustment.

  • Build failure, wrong phone identity, embedded Watch content or invalid signature stops installation. No uninstall/reset, account provisioning registration or app launch is performed.

Verdict

Ready to push

Four source-review perspectives completed without blockers. Four synthetic tooling contracts, real read-only discovery/dry-run, strict SwiftLint and whitespace passed. Debug and Release signed phone builds passed with installation explicitly skipped. No broad suite or physical install was run for this tooling-only change.

Review findings

2 raised · 1 fixed · 1 skipped

Jump to findings →

Tests

Pass rate: 100% (4 of 4)

New tests: 0

Diff coverage: n/a

Jump to tests →

Three-level explanation

make install builds the Debug phone app; make install-release uses Release. Connect your iPhone, then run one command to update Meddy in place. If several phones match, make devices helps you choose one. No Watch is installed and the app is not launched.

The Release target reuses the same Python helper through recursive Make. Discovery reads devicectl JSON only at recipe time and selects one physical iPhone. The staged project uses existing signing and omits only the Watch embed entry. Build logs preserve the actual builder exit status; validation precedes devicectl installation.

DEVICE_ID matches UDID/CoreDevice identifier and takes precedence; DEVICE_MODEL matches exact name/model/product type/UDID. Default discovery excludes unavailable pairings but accepts paired disconnected wireless devices. Paths and selectors pass as subprocess argument arrays rather than shell interpolation. Both stock Make 3.81 and GNU Make 4 dry-run/error contracts pass. The phone app bundle identifier, Watch absence and codesign verification gate installation. The Watch dependency can compile/sign as part of Xcode’s existing graph, but its content is not embedded or installed. Fresh absolute stage paths can reduce incremental cache reuse. Real install/data/CloudKit acceptance remain untested.

Completeness assessment

Both requested commands, device overrides, help/docs and focused error paths are implemented. Both signed configurations build successfully. Actual installation is reserved for the owner; no personal data preservation or CloudKit delivery claim is made.

Important changes — detailed

Explicit install recipes preserve simulator tooling

Makefile

Why it matters. Provide the requested simple entry points without running discovery at Make parse time.

What to look at. install, install-release and devices

Takeaway. Use recursive Make to share Debug/Release behavior.
Rationale. Owner requested the established Asterism build/install commands.

Select and validate one physical iPhone

scripts/install-phone.py

Why it matters. Avoid simulated devices and stale/unavailable phone pairings, and stop on ambiguity.

What to look at. select_phone and main

Takeaway. Read hardware UDID and pass it as an argument to build and install.
Rationale. Actual discovery includes simulators, Watch, iPad and historical phone pairings.

Preserve project and exclude physical Watch installation

scripts/install-phone.py

Why it matters. Existing phone scheme embeds Watch; its physical installation remains deferred.

What to look at. stage_phone_project

Takeaway. Apply the established one-line packaging omission only to a temporary source copy.
Rationale. Owner requires phone updates while physical Watch work stays excluded.

Review findings

SeverityAreaFindingResolution
minorUnavailable historical phone pairingsActual discovery initially found three paired phones, including two unavailable old devices.Default selection excludes unavailable pairings; explicit overrides remain possible. Focused contracts and real dry run passed.
minorFresh staged pathsFresh source-stage paths may reduce incremental reuse despite retained device cache.Documented trade-off; source copy is small, and fresh staging isolates builds without changing repository project settings.

Tests

Source: local run at 2026-10-08T21:18:01.031633+00:00 · snapshot 74932cab39bf318316344955f40d936c4f25280b

Baseline: none

Execution: passed · JUnit: 1 file · Coverage: none · Baseline: absent

Coverage scope: as the project configures it

Totals: 4 passed · 0 failed · 0 skipped · 0 errored · 0 flaky

New and removed tests

Derived by declaration name, from the diff (no baseline run).

No new or removed test declarations.

Blast radius

Files that import a changed file on the left, changed files in the centre, files a changed file imports on the right. Snapshot working-tree against base e43249e96937394f331d1d7c82e03ee3485c7a25.

addedmodifieddeletedrenamedunchangedcollapsed package group or +N more⚑N test files with an edge to the node

Per-file diffs

6 files: 3 code · 3 docs. Click to expand.

Code (3)

Makefile Modified
diff --git a/Makefile b/Makefileindex 02d8415..026cbdb 100644--- a/Makefile+++ b/Makefile@@ -17,8 +17,14 @@ UI_TEST ?= UI_TEST_TIMEOUTS ?= YES SWIFTLINT ?= swiftlint SWIFTLINT_CACHE ?= $(CURDIR)/build/swiftlint-cache+DEVICE_ID ?=+DEVICE_MODEL ?=+DEVICE_DERIVED_DATA ?= $(CURDIR)/DerivedData/device+INSTALL_DRY_RUN ?= 0+XCRUN ?= xcrun+export DEVICE_ID DEVICE_MODEL DEVICE_DERIVED_DATA INSTALL_DRY_RUN XCRUN XCODEBUILD RESULTS_DIR -.PHONY: lint lint-fix help build build-watch check simulators test-quick test-domain test-watch test-ui test-ui-smoke test-ui-all test pre-push+.PHONY: install install-release devices lint lint-fix help build build-watch check simulators test-quick test-domain test-watch test-ui test-ui-smoke test-ui-all test pre-push  help: ## Show development commands; no build or device action 	@printf '%s\n' \@@ -30,6 +36,10 @@ help: ## Show development commands; no build or device action 	  '  test-watch      Watch domain tests on a simulator' \ 	  '  test-ui         One explicit UI_TEST=MeddyUITests/Class/Method or class' \ 	  '  test-ui-smoke   Only the recording and whole-routine smoke journeys' \+	  'Physical iPhone:' \+	  '  install         Signed Debug build and in-place phone update; no launch' \+	  '  install-release Signed Release build and in-place phone update; no launch' \+	  '  devices         List known devices; select DEVICE_ID or DEVICE_MODEL' \ 	  'Before pushing:' \ 	  '  pre-push        Strict lint, then serial phone domain, Watch domain, and phone UI gates' \ 	  '  test            Alias of pre-push; not the development inner loop' \@@ -41,7 +51,7 @@ help: ## Show development commands; no build or device action 	  '' \ 	  'Override PHONE_DESTINATION/WATCH_DESTINATION with platform=... Simulator,id=...' \ 	  'Logs and unique .xcresult bundles: build/results; caches: DerivedData.' \-	  'Coordinate the shared heavy-work slot before builds/tests. No install/reset targets.'+	  'Coordinate the shared heavy-work slot before builds/tests. No reset or physical Watch targets.'  # Keep failures visible through tee. No command or device discovery runs at Make parse time. # Each invocation gets a new result directory; existing results are never removed.@@ -106,3 +116,13 @@ check: ## Lightweight whitespace validator  simulators: ## Read-only simulator discovery 	xcrun simctl list devices available++# Discovery happens only when explicitly requested; make -n never discovers or installs.+install: ## Build/sign using existing project settings and update one physical iPhone+	@python3 scripts/install-phone.py --configuration "$(CONFIG)"++install-release: ## Reuse the phone path with Release configuration+	$(MAKE) install CONFIG=Release++devices: ## Read-only device discovery; no build, pairing, install or launch+	"$(XCRUN)" devicectl list devices
scripts/install-phone.py Added
diff --git a/scripts/install-phone.py b/scripts/install-phone.pynew file mode 100644index 0000000..df401e0--- /dev/null+++ b/scripts/install-phone.py@@ -0,0 +1,124 @@+#!/usr/bin/env python3+"""Build/install the existing phone identity; never launch, reset or install Watch."""+import argparse+import json+import os+from pathlib import Path+import plistlib+import re+import shlex+import shutil+import subprocess+import sys+import tempfile+++def select_phone(data, device_id='', model=''):+    phones = []+    for device in data['result']['devices']:+        hardware = device.get('hardwareProperties', {})+        connection = device.get('connectionProperties', {})+        if (connection.get('pairingState') != 'paired'+                or hardware.get('reality') != 'physical'+                or hardware.get('platform') != 'iOS'+                or not hardware.get('productType', '').startswith('iPhone')):+            continue+        if not device_id and not model and connection.get('tunnelState') == 'unavailable':+            continue+        identity = hardware.get('udid')+        if not identity:+            continue+        values = [identity, device.get('identifier'), hardware.get('marketingName'),+                  hardware.get('productType'), device.get('deviceProperties', {}).get('name')]+        if device_id and device_id not in [identity, device.get('identifier')]:+            continue+        if not device_id and model and model not in values:+            continue+        phones.append(identity)+    if len(phones) != 1:+        raise ValueError('Expected one paired physical iPhone, found %d. Run make devices; '+                         'set DEVICE_ID=<UDID> or DEVICE_MODEL="device name or model".' % len(phones))+    return phones[0]+++def stage_phone_project(repo, run_dir):+    source = run_dir / 'source' / 'Meddy'+    shutil.copytree(repo / 'Meddy', source, ignore=shutil.ignore_patterns('xcuserdata', '*.xcuserstate'))+    project = source / 'Meddy.xcodeproj'+    definition = project / 'project.pbxproj'+    text = definition.read_text()+    # Same packaging omission used for the previous signed phone installation.+    # Only the temporary copy changes; dependencies and signing remain intact.+    text, count = re.subn(r'^\s*[A-F0-9]+ /\* MeddyWatch\.app in Embed Watch Content \*/,\n',+                         '', text, flags=re.MULTILINE)+    if count != 1:+        raise ValueError('Expected exactly one embedded Watch entry; project layout needs review.')+    definition.write_text(text)+    return project+++def build(command, log_path):+    with log_path.open('w') as log:+        with subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,+                              text=True) as process:+            for line in process.stdout:+                sys.stdout.write(line)+                log.write(line)+            result = process.wait()+    if result:+        raise subprocess.CalledProcessError(result, command)+++def main():+    parser = argparse.ArgumentParser(description=__doc__)+    parser.add_argument('--configuration', choices=['Debug', 'Release'], default='Debug')+    parser.add_argument('--dry-run', action='store_true', help='Discover/stage/print; no build or install')+    parser.add_argument('--build-only', action='store_true', help='Validate signed build; do not install')+    args = parser.parse_args()+    repo = Path(__file__).resolve().parent.parent+    results = Path(os.environ.get('RESULTS_DIR', str(repo / 'build/results'))).resolve()+    results.mkdir(parents=True, exist_ok=True)+    run_dir = Path(tempfile.mkdtemp(prefix='install-phone.', dir=results))+    xcrun = os.environ.get('XCRUN', 'xcrun')+    device_json = run_dir / 'devices.json'+    subprocess.run([xcrun, 'devicectl', 'list', 'devices', '--json-output', str(device_json)],+                   check=True, stdout=subprocess.DEVNULL)+    try:+        device = select_phone(json.loads(device_json.read_text()), os.environ.get('DEVICE_ID', ''),+                              os.environ.get('DEVICE_MODEL', ''))+    finally:+        # Device names/identifiers are local diagnostics, not repository artifacts.+        device_json.unlink(missing_ok=True)+    project = stage_phone_project(repo, run_dir)+    derived = Path(os.environ.get('DEVICE_DERIVED_DATA', str(repo / 'DerivedData/device'))).resolve()+    app = derived / 'Build/Products' / (args.configuration + '-iphoneos') / 'Meddy.app'+    command = [os.environ.get('XCODEBUILD', 'xcodebuild'), 'build', '-project', str(project),+               '-scheme', 'Meddy', '-configuration', args.configuration,+               '-destination', 'platform=iOS,id=' + device, '-destination-timeout', '20',+               '-derivedDataPath', str(derived)]+    install = [xcrun, 'devicectl', 'device', 'install', 'app', '--device', device, str(app)]+    print('Results: ' + str(run_dir), flush=True)+    print('Build: ' + shlex.join(command), flush=True)+    print('Install: ' + shlex.join(install), flush=True)+    if args.dry_run or os.environ.get('INSTALL_DRY_RUN', '0') == '1':+        print('Dry run: no build, signing or installation performed.')+        return+    build(command, run_dir / 'xcodebuild.log')+    with (app / 'Info.plist').open('rb') as handle:+        identity = plistlib.load(handle)['CFBundleIdentifier']+    if identity != 'me.nore.ig.meddy' or (app / 'Watch').exists():+        raise ValueError('Expected existing Meddy phone identity with no embedded Watch content.')+    subprocess.run(['codesign', '--verify', '--deep', '--strict', str(app)], check=True)+    if args.build_only:+        print('Signed phone build verified; installation skipped.')+        return+    subprocess.run(install, check=True)+    print('Phone update accepted. The app was not launched; no uninstall/reset was performed.')+++if __name__ == '__main__':+    try:+        main()+    except (ValueError, KeyError, OSError, subprocess.CalledProcessError) as error:+        print('install-phone: ' + str(error), file=sys.stderr)+        sys.exit(1)
scripts/test-install-phone.py Added
diff --git a/scripts/test-install-phone.py b/scripts/test-install-phone.pynew file mode 100644index 0000000..5f24ee4--- /dev/null+++ b/scripts/test-install-phone.py@@ -0,0 +1,112 @@+#!/usr/bin/env python3+"""Focused tooling contracts; all device/build/install commands are synthetic."""+import importlib.util+import json+import os+from pathlib import Path+import subprocess+import tempfile+import unittest++ROOT = Path(__file__).resolve().parent.parent+spec = importlib.util.spec_from_file_location('install_phone', ROOT / 'scripts/install-phone.py')+helper = importlib.util.module_from_spec(spec)+spec.loader.exec_module(helper)+++def phone(udid='synthetic-phone', **hardware):+    return {'identifier': 'synthetic-core-' + udid,+            'connectionProperties': {'pairingState': 'paired', 'tunnelState': 'disconnected'},+            'hardwareProperties': dict(udid=udid, reality='physical', platform='iOS',+                                       productType='iPhone18,1', **hardware),+            'deviceProperties': {'name': 'Synthetic phone'}}+++class InstallContracts(unittest.TestCase):+    def test_selection_excludes_other_platforms_and_simulators(self):+        base = phone()+        others = []+        for field, value in [('reality', 'simulated'), ('platform', 'watchOS'),+                             ('productType', 'iPad16,5')]:+            item = json.loads(json.dumps(base))+            item['hardwareProperties'][field] = value+            others.append(item)+        unavailable = phone('old-unavailable-phone')+        unavailable['connectionProperties']['tunnelState'] = 'unavailable'+        self.assertEqual(helper.select_phone({'result': {'devices': others + [unavailable, base]}}), 'synthetic-phone')+        self.assertEqual(helper.select_phone({'result': {'devices': [unavailable, base]}},+                                             'old-unavailable-phone'), 'old-unavailable-phone')++    def test_ambiguous_missing_and_explicit_selection(self):+        data = {'result': {'devices': [phone('one'), phone('two')]}}+        with self.assertRaises(ValueError):+            helper.select_phone(data)+        with self.assertRaises(ValueError):+            helper.select_phone(data, 'missing')+        self.assertEqual(helper.select_phone(data, 'synthetic-core-two'), 'two')+        self.assertEqual(helper.select_phone(data, model='one'), 'one')++    def test_stage_preserves_repository_and_signing(self):+        original = ROOT / 'Meddy/Meddy.xcodeproj/project.pbxproj'+        before = original.read_bytes()+        with tempfile.TemporaryDirectory() as directory:+            project = helper.stage_phone_project(ROOT, Path(directory))+            staged = (project / 'project.pbxproj').read_text()+        self.assertEqual(original.read_bytes(), before)+        self.assertEqual(staged, before.decode().replace(+            '\t\t\t\tD4E6899B3073A6010095AE3C /* MeddyWatch.app in Embed Watch Content */,\n', ''))++    def test_make_debug_release_dry_run_and_failures(self):+        with tempfile.TemporaryDirectory(prefix='meddy install contracts ') as directory:+            temp = Path(directory)+            fake = temp / 'fake-tool'+            calls = temp / 'calls.jsonl'+            fake.write_text('''#!/usr/bin/env python3+import json,os,sys+from pathlib import Path+args=sys.argv[1:]+with open(os.environ['CALLS'],'a') as f:f.write(json.dumps(args)+'\\n')+if args[:3]==['devicectl','list','devices']:+ Path(args[args.index('--json-output')+1]).write_text(os.environ['DEVICES'])+ sys.exit(0)+if args[0]=='build':+ sys.exit(int(os.environ.get('BUILD_EXIT','0')))+raise SystemExit('Unexpected command; no device action allowed')+''')+            fake.chmod(0o755)+            env = dict(os.environ, CALLS=str(calls), DEVICES=json.dumps({'result': {'devices': [phone()]}}),+                       PYTHONDONTWRITEBYTECODE='1')+            overrides = ['XCRUN=' + str(fake), 'XCODEBUILD=' + str(fake),+                         'RESULTS_DIR=' + str(temp / 'results with spaces'),+                         'DEVICE_DERIVED_DATA=' + str(temp / 'derived with spaces')]+            for make in ['/usr/bin/make', '/opt/homebrew/bin/gmake']:+                for target, config in [('install', 'Debug'), ('install-release', 'Release')]:+                    calls.unlink(missing_ok=True)+                    run = subprocess.run([make, target, 'INSTALL_DRY_RUN=1', *overrides],+                                         cwd=ROOT, env=env, capture_output=True, text=True)+                    self.assertEqual(run.returncode, 0, run.stderr)+                    self.assertIn('-configuration ' + config, run.stdout)+                    self.assertEqual(len(calls.read_text().splitlines()), 1)+                    calls.unlink()+                    run = subprocess.run([make, '-n', target, *overrides], cwd=ROOT, env=env,+                                         capture_output=True, text=True)+                    self.assertEqual(run.returncode, 0, run.stderr)+                    self.assertFalse(calls.exists())+            calls.unlink(missing_ok=True)+            run = subprocess.run(['/usr/bin/make', 'install', *overrides], cwd=ROOT,+                                 env=dict(env, BUILD_EXIT='19'), capture_output=True, text=True)+            self.assertNotEqual(run.returncode, 0)+            recorded = [json.loads(line) for line in calls.read_text().splitlines()]+            self.assertEqual(len(recorded), 2)+            self.assertEqual(recorded[1][0], 'build')+            self.assertIn(str((temp / 'derived with spaces').resolve()), recorded[1])+            self.assertNotIn('CODE_SIGNING_ALLOWED=NO', recorded[1])+            calls.unlink()+            run = subprocess.run(['/usr/bin/make', 'install', 'DEVICE_ID=missing', *overrides],+                                 cwd=ROOT, env=env, capture_output=True, text=True)+            self.assertNotEqual(run.returncode, 0)+            self.assertEqual(len(calls.read_text().splitlines()), 1)+++if __name__ == '__main__':+    unittest.main()

Docs (3)

AGENTS.md Modified
diff --git a/AGENTS.md b/AGENTS.mdindex 5132623..ae9d44b 100644--- a/AGENTS.md+++ b/AGENTS.md@@ -16,6 +16,7 @@ Meddy is a personal SwiftUI iPhone app with a Watch companion. The Xcode project Use the root Makefile for development tooling; `make` shows help. GNU Make 4.4.1 is installed as `gmake` on this Mac. See `docs/development.md` for destination/cache/result overrides.  - `make build` / `make build-watch`: unsigned simulator builds.+- `make install` / `make install-release`: signed Debug/Release in-place iPhone updates, no launch. Owner-only explicit install; never invoke during tooling validation. `make devices` lists devices; `DEVICE_ID`/`DEVICE_MODEL` select one physical iPhone. - `make test-quick`: phone domain tests with no UI; `make test-domain DOMAIN_TEST=MeddyTests/Suite` narrows the affected suite. - `make test-watch`: Watch domain tests on the Watch simulator. - `make test-ui UI_TEST=MeddyUITests/Class/Method`: explicit affected UI scenario; omit the method only when the whole class is relevant.
CHANGELOG.md Modified
diff --git a/CHANGELOG.md b/CHANGELOG.mdindex 559026b..40538d3 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -15,6 +15,7 @@ - T2413: Keep notification snoozes at their chosen 15-minute deadline, cancel queued originals, suppress elapsed replay and await background scheduling completion.  ### Added+- `make install` and `make install-release` for signed, in-place Debug/Release iPhone updates, with explicit device overrides and phone-only packaging. - Optional medication prescription date, doctor/clinic, user-entered supply-duration days and repeats left; profile-scoped editor/detail/export with explicit decrement and guarded Undo. - T2426: Short completion chime and longer per-round feedback: a two-pulse iPhone haptic pattern and two Watch notification pulses, subject to device sound/haptic settings. - T2423: Repository agent guide covering simulator tooling, recalled knowledge, synthetic stores, captured care/profile ownership and truthful initialization provenance.
docs/development.md Modified
diff --git a/docs/development.md b/docs/development.mdindex a0cb1c6..87c472f 100644--- a/docs/development.md+++ b/docs/development.md@@ -1,6 +1,6 @@ # Meddy development commands -Run `make` for help (`gmake` is also available on this Mac). All build/test targets use simulators, disable signing, retain full logs and write a unique `.xcresult` under ignored `build/results/`. Phone and Watch caches are separate under ignored `DerivedData/`. No target installs, launches against live data, resets a device/store, changes accounts or pushes Git branches. Coordinate the shared heavy-work slot before running builds or tests.+Run `make` for help (`gmake` is also available on this Mac). The existing build/test targets use simulators, disable signing, retain full logs and write a unique `.xcresult` under ignored `build/results/`. Phone and Watch caches are separate under ignored `DerivedData/`. The explicit phone install targets below build/sign and update the installed app. No target launches against live data, resets a device/store, changes accounts or pushes Git branches. Coordinate the shared heavy-work slot before running builds or tests.  For day-to-day work, use `make build`, `make test-quick`, or narrow the domain bundle with `make test-domain DOMAIN_TEST=MeddyTests/MeddyAsNeededLimitTests`. These phone tests depend on iOS APIs, so the fast target uses the iOS simulator rather than inventing a macOS test destination. The shared schemes set `MEDDY_TESTING=1`; tests use isolated synthetic stores and fake clients. @@ -23,6 +23,29 @@ Run `make lint` for strict checks and `make lint-fix` for explicit corrections,  Avoid a blanket suppression to pass lint. Prefer descriptive names, named edit/fixture values and focused helpers. The one-line `redundant_discardable_let` exception in `AsNeededLimitViews` protects its SwiftUI observation declaration from an autofix known to produce expensive result-builder type checking. +## Install on your iPhone++```sh+make install          # Debug+make install-release  # Release+```++These follow Asterism’s signed-build → `devicectl device install app` path, using Meddy’s existing bundle/team/container settings and local signing assets. Plug in, trust and unlock your iPhone; Developer Mode and working Xcode signing are required. One available paired physical iPhone is selected automatically, including a paired wireless phone whose tunnel is currently disconnected. Simulators, iPads, Watches and unavailable old pairings are excluded from automatic selection. An explicit override may select an unavailable phone, whose connection/build error remains visible. Multiple matches stop before building; select explicitly:++```sh+make devices+make install DEVICE_ID=YOUR_PHONE_UDID+make install-release 'DEVICE_MODEL=Your iPhone name'+make install INSTALL_DRY_RUN=1  # Discover/stage/print; no build or install+make -n install-release        # Print recipes only; no discovery or install+```++`DEVICE_MODEL` accepts the exact device name, marketing name, product type or UDID. `DEVICE_ID` accepts its UDID or CoreDevice identifier and takes precedence. `CONFIG=Release` also works with `install`; `install-release` always selects Release. Device caches use `DerivedData/device`; override `DEVICE_DERIVED_DATA` or `RESULTS_DIR` if needed.++A temporary source copy under ignored `build/results/install-phone.*` omits only embedded Watch content, using the same packaging adjustment as the previous phone installation. The repository project, scheme, dependency/signing settings and entitlements stay intact. The built phone identity and absence of Watch content are checked before installation. This path never installs a physical Watch, uninstalls/resets the phone app, selects test-store launch flags or launches the app. A successful install is acceptance of an in-place update, not independent proof of personal-record preservation or CloudKit synchronization. Signing/provisioning failures stop before installation; configure existing signing through Xcode rather than expecting automatic account/profile registration. Complete build logs remain in the reported result directory. Each invocation uses a fresh source-stage path, so warm incremental reuse may be reduced even when the device cache is retained.++Run `PYTHONDONTWRITEBYTECODE=1 python3 scripts/test-install-phone.py` for focused synthetic tooling contracts; these never build or install a real app. Verification at `e4996ef` passed all four contracts, including stock Make/GNU Make Debug/Release wiring, recipe-only dry run, build failure propagation, path spacing, device filtering/ambiguity and exact staging preservation. Real read-only discovery/dry run and strict SwiftLint (111 files, zero violations) passed. Both signed phone configurations built and passed identity/no-Watch/signature checks with `--build-only`: Debug exit 0 in 24.502 seconds, Release exit 0 in 51.698 seconds. No installation, app launch, broad suite, account/profile registration or project-setting change ran during validation. Owned build groups drained and the heavy lane was released.+ ## UI runner diagnostics  The first full gate passed 186 phone domain tests and 13 Watch tests, but UI cases repeatedly completed their assertions then exceeded their teardown deadlines. A saved runner sample showed `XCTCrashLogTracker.waitForPendingCrashlogs()` during one inspected teardown wait. The same background-publication runtime warning appears in a prior passing editor log, so its presence alone does not establish a cleanup regression or the cause of the wait. No relevant Meddy crash report was found in the inspected Mac diagnostic-report location.

Things to double-check

Validation scope

User explicitly requested focused tooling/lint/dry-run/error validation, not another broad suite. No app/shared/domain/Watch source, schema, signing setting or entitlement changed. Four contract tests use synthetic tools; Debug/Release signed artifacts are separately validated by real builds. Device installation and launch never ran.

Outgoing privacy

Outgoing changes contain generic examples and synthetic test identities. No actual device names/UDIDs, build logs, personal health data or account credentials are committed. Real discovery and build logs remain local ignored evidence.