Source Tree Rename
Product Rename Through The Tree
Gantry carried its product rename through contracts, stored replay data, source code, docs, and local harness names.
3 milestones 13 tasks 35 agents
7 plan 17 execute 16 review 2 fix
244k peak context
138k median execute
4h 57m total 15m 32s per task
8m 27s plan 2h 54m execute 39m 55s review
105 edits 1.1k commands
codex harness
This run was the source-tree half of the product rename. It started at the wire boundary, where a client and server can break each other, then moved through durable replay data and Rails naming before sweeping the internal source vocabulary.
The decomposition kept compatibility work ahead of broad replacement. That mattered because the run was not a blind search and replace: historical records, fixtures, legacy reads, and outside trademarks had to remain old-spelled while current Gantry code stopped describing itself with the retired name.
How this walkthrough is structured
Feature
What did the run build and ship?
The current tree speaks Gantry on primary code, replay data, commands, docs, and harness-local artifacts, while explicit legacy reads and historical residues remain named as such.
Build
How did Gantry structure the work?
The run cut the rename by risk surface, and the stress clustered where Rails autoloading, broad runtime vocabulary, and final documentation residue crossed subsystem boundaries.
Milestone 1
Wire Contract Guard
3 tasks 10 agents 21m 43s wall time 62k peak context
The lasting result is visible in the shared matcher notes, the migration state, the demo API controller, and the Rust demo client. Current code sends and requires the Gantry version key on demo requests, and the surrounding demo identity flow still validates the version value as part of signed permission and completion checks. The source-scope notes remain the authority for why generated data and path hits are counted apart.
This milestone carried the outage-sensitive part first. Its brief paired a measured source baseline with the demo API key transition, so later rename work could consume a proven compatibility boundary instead of coordinating a flag day. The sprint ledger stayed green, but the milestone closeout still recorded stale scope text as a plan-impact finding for later work.
Scope Assessment
2 agents 3m 30s wall time 62k peak context
The current migration state still records the source-tree rename as a measured source problem rather than an anecdotal count. The matcher remains centralized in the Gantry word script, with its rule and exceptions documented beside the implementation. Later replay and registry tooling still rely on that shared matcher instead of carrying a competing product-word test.
This sprint was a measurement slice, not a rename slice. It asked one fresh agent to run the existing product matcher, separate content matches from path hits, and update the migration state before any code edit could move the baseline. The clean pass made the later milestones depend on a committed reference point rather than on stale plan prose.
Rails Compatibility
2 agents 2m 49s wall time 47k peak context
In the live controller, demo checks and completion reports validate a Gantry version field before credentials are accepted. The controller also rejects legacy personalized-binary identity fields, so version identity is part of the newer email-based demo contract rather than the removed binary-selector model. The old transitional spelling is no longer visible as a primary Rails path in today's file.
This sprint owned the server side of the demo version-key boundary. The brief kept the client out of scope so the Rails agent could decide and pin request identity behavior before anything new started sending it. It passed cleanly, giving the next sprint a server contract to consume.
Rust Client Rename
2 agents 2m 24s wall time 44k peak context
The Rust demo HTTP types now carry the Gantry version field in both check and completion requests. The demo gate fills that field from the package version when it asks the server for permission and when it reports completed work. The client-side contribution is still present as ordinary request structure rather than as a compatibility shim.
This sprint deliberately came after the Rails contract. Its scope was the outbound Rust request shape, with tests expected to prove the client sent one version identity rather than both. The boundary was small and stayed green because compatibility had already been settled on the server side.
Milestone 2
Job Data Paths
5 tasks 17 agents 1h 18m wall time 153k peak context
The exact Gantry-job layer this milestone created has since been absorbed into the replay domain, but its direction is still standing. The current Rails artifact naming code writes to the replay locations and keeps Gantry-job and older authored paths as read-only compatibility inputs. Public replay serving joins authored prose, fleet facts, and video roster metadata through the newer replay classes rather than through the retired job-domain names.
This milestone moved from wire compatibility to durable replay data and Rails naming. It was sliced so a naming contract landed before files moved, the Rails domain moved after data existed under the new product spelling, and analysis tools caught up after both sides had a contract. The Rails domain sprint went red, was repaired, and then recorded as already satisfied on retry, which locates the hardest edge at autoloading and persistence rather than at file movement.
Naming Contract
2 agents 8m 47s wall time 97k peak context
The live artifact naming class still embodies that pattern, though it now names replay artifacts. It has canonical write paths and separate legacy read paths for both the Gantry-job and older authored directories. Callers ask the naming class where to read and write instead of scattering product-spelled strings.
This sprint made the path contract explicit before moving committed data. The agent's job was to route readers and writers through one naming boundary while leaving old files readable during the transition. That made the next sprint a data move instead of a mixed code-and-data rename.
Artifact Rename
2 agents 10m 24s wall time 153k peak context
The committed authored artifacts are now under the replay directory, and the serving file is the replay data file. The current loader still accepts the Gantry-job location as a legacy input, which shows the run's renamed data path became an intermediate compatibility tier rather than disappearing as a mistake. New authored prose is written to the replay home.
This sprint carried the reversible data move. Its brief kept historical identifiers, slugs, and compatibility strings out of scope while moving the serving rows and authored per-run artifacts under the product spelling. The clean boundary let Rails autoloading wait for its own sprint.
Rails Job Domain
5 agents 17m 10s wall time 60k peak context 1 fix
Today's application no longer exposes the Gantry-job class names this sprint introduced as the primary domain. The surviving structure is the replay domain, with artifact sync, authored catalog, loaders, rake tasks, and public pages carrying the same job-summary purpose under its current name. The sprint's direct residue is therefore partly folded into a later rename, while its public route behavior survived through the replay surface.
This sprint was the milestone's pressure point. Rails constants, directories, helpers, persistence, routes, views, tasks, and tests had to move together, and the gate stayed red through repair before the retry recorded the target as satisfied. That stress matches the brief: Rails autoloading gives little room for a half-renamed domain.
Analysis Tooling
2 agents 14m 27s wall time 134k peak context
The current analysis surface now uses Gantry replay commands, checks, allowlists, fixtures, and tests. The row enumerator still emits the identities, digest paths, fact paths, data repository, and slug needed by map workers. The older Gantry-job command names from this sprint have mostly become compatibility history beneath the replay-summary tooling.
This sprint brought the Python and map tooling into agreement with the renamed artifact contract. It was sequenced after the Rails move so the tools could validate the corpus shape the app now consumed. The run facts show it stayed green, which fits a command-surface rename with a stable row schema underneath.
Reference Audit
2 agents 15m 32s wall time 138k peak context
The live tree no longer has the old primary authored job directory as the active write target. The replay naming layer keeps older Gantry-job and pre-rename paths only as compatibility reads, and operational code writes to the current replay locations. That makes this sprint's audit partly superseded by the later replay rename, while preserving its core rule that stale runtime paths should not be primary.
This sprint was the closeout for job data and path references. Its brief asked for residue to be measured and explained against the already-defined contracts, not for a new exemption category. It passed, but the top-level milestone note later found a stale root-agent path reference, so the audit became evidence for what the next milestone still had to recheck.
Milestone 3
Source Tree Sweep
5 tasks 19 agents 3h wall time 244k peak context
The current repository presents Gantry as the product across the root runtime, web app, analysis scripts, replay tooling, docs, and local harness artifacts. Old spellings still appear where the migration state says they should: legacy registry reads, compatibility environment fallbacks, matcher fixtures, historical files, and outside names. The result is a classified residue rather than a tree pretending the old word never existed.
This milestone carried the broad internal sweep after the contract and data-path work had landed. It split the source tree by subsystem so agents could rename current vocabulary while leaving fixtures, historical records, legacy reads, and outside names alone. Several boundaries pushed back: the runtime sprint blocked before succeeding, the web sprint forced a replan, tooling blocked once, and the docs sweep needed a repair before the closeout passed.
Runtime And CLI Sweep
4 agents 1h 2m wall time 200k peak context
The root Rust code now uses Gantry vocabulary through commands, engine modules, domain types, MCP names, TUI code, demo licensing, and runtime messages. The remaining old-spelled runtime references are concentrated in documented legacy fallbacks, path compatibility, and tests that prove old environment names are not honored. Temporary harness prefixes were intentionally left for the final sprint.
This sprint was the broadest code slice in the rename. It asked a fresh agent to touch the root binary, runtime state, CLI copy, schemas, and tests while preserving compatibility reads and deferring harness-local prefixes. The first attempts blocked, so Gantry retried the slice until the agent could finish it against the narrower residue rules.
Web App Rename
3 agents 18m 58s wall time 235k peak context 1 replan
The web application now speaks Gantry in legal pages, release handling, demo signup, public replay pages, tests, and operational app docs. The demo API still carries current compatibility behavior through the email and version fields rather than old personalized binary identity. Some legal and archive files keep old names where they are historical or compatibility records.
This sprint aligned Rails with the renamed runtime and job-domain vocabulary without reopening settled wire contracts. Its scope included models, controllers, views, tasks, fixtures, copy, and source-controlled assets. Review triggered a replan for later work, which means the web slice taught the remaining milestone where residue boundaries needed sharper wording.
Analysis Tooling Rename
3 agents 19m 53s wall time 190k peak context
Current analysis scripts and tests use Gantry names for fleet collection, replay facts, replay rows, screencast batch work, and registry support. The older files that remain in the history are mostly compatibility wrappers, renamed-away predecessors, or fixtures that preserve historical input. Screencast scripts likewise use Gantry names for current generated maps and registry maintenance.
This tooling slice followed the web app because it reads the artifacts and registries those surfaces produce. The first attempt blocked, then the retry completed with the matcher and historical-fixture rules made explicit. Fleet closure was deliberately excluded from this sprint's pass condition, so a fresh agent could finish repository-local tooling without chasing concurrently changing registries.
Ops Docs Sweep
3 agents 22m 5s wall time 163k peak context 1 fix
The root agent index, runbooks, screencast docs, release scripts, metadata, and miscellaneous tools now describe Gantry paths and commands where they are current instructions. Archive pages and compatibility notes still preserve older names where changing them would rewrite history or third-party references. The migration state records the remaining categories instead of letting old wording hide in active docs.
This sprint handled the material no subsystem-specific agent owned: operational docs, config, metadata, and miscellaneous source files. Its gate went red and a fix ran, which is exactly where a broad documentation and path audit is likely to find leftovers. The brief also made the final closeout depend on a measured residue, not on confidence from prose review.
Harness Prefix Cleanup
2 agents 40m 13s wall time 244k peak context
Runtime-local temporary names in the harness now use Gantry prefixes in current code paths. The final residue is documented as compatibility, fixture, historical, published-artifact, or outside-name material, not as an unclassified search result. Later work has changed the replay surface again, but the local harness cleanup remains present in the engine and harness modules.
This final sprint waited until the source sweep had settled before renaming runtime-local harness prefixes and worker labels. That kept disposable artifact names out of the earlier compatibility work and turned the sprint into closeout accounting. It passed green, while the milestone note still warned that some active surfaces needed later attention before the rename could be called complete.