Wave Summary

Field Value
purpose use a real cross-language repository as a compact end-to-end demonstration of planning, dispatch, dependency-aware execution, gating, and merge
integration window July 27, 2026; the completion checkpoint was recorded at 2026-07-28T00:55Z
scope one macOS tray foundation, seven demo feature requests, and three adjacent CLI/API notes
result the factory reported all 11 TTRAC notes done and merged (ys-fac-1wha, ys-fac-v7bg)
principal proof Yesod coordinated Python API work with Swift client work, including rework and merge ordering, instead of treating a green Python test run as the whole product gate
exit state the demo slice was merged; a TTRAC-specific composite gate was added, while generalized dependency scheduling and broader Swift-lane support remained follow-up work

Wave 4 was about giving work a safe place to accumulate away from main. Wave 5 was smaller and more concrete: run that factory against a product that was itself heterogeneous. TTRAC combines a FastAPI/Postgres service with a macOS Swift tray application. The demo therefore tested the factory at the seam where repository identity, feature dependencies, model routing, platform tooling, and merge discipline all meet.

This was not a new platform subsystem. It was a dogfood slice with a useful stopping condition: build enough of the tray application to demonstrate a real workflow, put every change through the refinery, and record what the exercise reveals about the factory.

The Demo Had a Real Dependency Shape

The foundation note, ys-ttr-e252, created the macOS application scaffold: MenuBarExtra, the API client and Codable models, the client selector, daily and weekly totals, quick actions, and the initial TimerManager state. The remaining seven UI notes then filled in a coherent demo surface:

  • idle and display-sleep detection, with timer suppression and wake recovery (ys-ttr-e1e0);
  • preferences (ys-ttr-vkiv) and a report window (ys-ttr-2q48);
  • five-minute ScreenCaptureKit screenshots with upload and local backup (ys-ttr-q08k);
  • a six-minute confirmation popup (ys-ttr-qoxc);
  • quick note entry (ys-ttr-9ttq); and
  • an invoice wizard (ys-ttr-rpmv).

The plans were not merely a list of independent screens. The planner verified the existing API contracts and made the dependency order explicit. The timer core followed e252 → e1e0 → q08k → qoxc; the window work shared the foundation but used separate presentation decisions, including client-side PDFKit for the report and API-side ReportLab for invoices (ys-fac-jcnf, ys-fac-a1ik).

That shape mattered to the factory. A screenshot worker cannot safely extend a TimerManager that another worker is changing without either a dependency boundary or a rework path. The demo made that interaction visible instead of leaving it as an assumption in a plan.

Dispatch Became Observable Product Behavior

The dispatcher armed all seven feature notes after planning, with model lanes chosen by expected difficulty: easy work went to Kimi, medium work to DeepSeek, and advanced work to Claude Opus (ys-fac-24yh). The foundation was handled first because the other workers needed its Swift project, API client, and timer seam.

The run also showed that “parallel” does not mean “uncoordinated.” The factory handled three rework cycles, including a ttracApp.swift conflict in the quick note path and a TimerManager.swift conflict in screenshot work (ys-fac-vskg). Those were not invisible model retries. They became part of the operational record and were resolved through the same refinery path as the initial work.

The final completion record included the adjacent support changes that made the demo easier to operate: ttrac --version, ttrac-migrate --version, and a retroactive screenshot-to-time-entry update endpoint. The result was reported as 11 of 11 TTRAC notes merged, rather than merely seven agents having been started (ys-fac-1wha, ys-fac-v7bg).

The Demo Found a Gate That Was Too Narrow

The most valuable discovery was a failure in the definition of green. TTRAC’s refinery profile ran pytest, but TTRAC also contained a Swift package. A Swift 6 compile error could therefore pass the Python gate and enter main. The issue was captured as ys-yes-6lfp / bead yes-7hgw, and the profile was changed to a composite command:

uv run pytest -q -p no:cacheprovider && swift build --package-path mac

The implementation landed in the default profile and in an idempotent profile migration (805b3fd4, 824b602f, e5b4f4cd), with regression coverage proving that both halves of the gate are present (69312146). The repository path was seeded with the profile as well, so a fresh database and an existing factory agree about which TTRAC checkout they are gating.

This is the central lesson of the wave. A repository is not defined by the language of its largest directory. The gate has to describe the product’s buildable surface. TTRAC made that rule unavoidable because the Python half and the Swift half were both part of the feature being demonstrated.

Operations Were Part of the Proof

The demo also exercised the less glamorous parts of the factory:

  • a launchd environment override forced the wrong gate backend and had to be corrected before the local flow could proceed;
  • a slow gate held the dependent TTRAC chain, making the ordering constraint visible to the dispatcher;
  • orphaned and stale queue work required re-arming and re-gating rather than assuming that an earlier worker’s state was still authoritative; and
  • parallel Swift edits produced real merge conflicts, which the dispatcher tracked as rework rather than silently discarding.

The factory notes record both the friction and the recovery. That is more useful than a clean demo transcript: the system was judged on whether it could explain why work waited, repair the queue state, and eventually produce a merged result. The follow-up dependency note, ys-yes-daf7, captures the generalization still needed: enforce one dependency layer per concern and make readiness efficient enough that a small demo does not require manual queue archaeology.

What Shipped, and What Stayed Out

Area Shipped result Boundary at wave exit
product slice tray foundation, idle suppression, preferences, report, screenshots, popup, quick notes, and invoice flow this was a demonstration surface, not a claim of production-ready macOS distribution
factory use seven dependent UI notes planned, routed, reworked, gated, and merged dependency ordering was partly planner- and dispatcher-mediated; a general dependency scheduler remained future work
validation TTRAC’s profile chained Python tests with the Swift build the composite gate was TTRAC-specific; other mixed-language repositories still need explicit profiles
operations stale backend configuration, queue delay, orphan work, and merge conflicts were recovered in the run recovery was demonstrated, not yet reduced to a single automatic repair policy
completion evidence 11/11 TTRAC notes reported done and merged no deployment or end-user rollout was implied by source integration

The New Exit Criterion

Wave 4 asked whether an epic could accumulate safely without forcing every intermediate state onto main. Wave 5 asked whether the factory could carry a small, real, cross-language product slice from plan to merged result.

The answer was yes, with an important qualification: the factory’s correctness boundary is only as complete as the repository profile behind it. The demo finished not when the agents had produced plausible Swift files, but when the Python tests, Swift build, dependency order, conflict repairs, and queue state all agreed that the result was mergeable.

The durable lesson is that dogfooding is a form of systems testing. A compact demo can expose a missing gate dimension, an implicit dependency, or a queue repair gap faster than a broad roadmap can. TTRAC gave Yesod a product small enough to finish in one wave and heterogeneous enough to make the factory’s assumptions visible.