Riding Two Release Lines — Splitting Antigravity's 2.0 and 2.1 Tracks Between Unattended and Interactive Work

Drift Detection — Reconciling Declared Versus Actual Every Morning

A declaration alone will not tell you when reality drifts away from it. A small script collects the actual version from every surface and reconciles the report against the policy; I run it as one step in my morning scheduled batch.

// check-version-policy.mjs — reconcile actual versions against the policy
// usage: node check-version-policy.mjs <version-policy.json> <report.json>
import { readFileSync } from "node:fs";
 
const [policyPath, reportPath] = process.argv.slice(2);
const policy = JSON.parse(readFileSync(policyPath, "utf8"));
// report.json is written by each machine from `agy --version` output
// shape: [{ "host": "mac-studio", "surface": "cli", "workload": "unattended", "version": "2.0.11" }]
const report = JSON.parse(readFileSync(reportPath, "utf8"));
 
const parse = (v) => v.split(".").map(Number);
const cmp = (a, b) => {
  const [a1, a2, a3] = parse(a); const [b1, b2, b3] = parse(b);
  return a1 - b1 || a2 - b2 || a3 - b3;
};
const inRange = (version, range) =>
  range.split(" ").every((cond) => {
    const m = cond.match(/^(>=|<=|<|>)?([\d.]+)$/);
    if (!m) return true;
    const [, op = ">=", bound] = m;
    const c = cmp(version, bound);
    return op === ">=" ? c >= 0 : op === "<=" ? c <= 0 : op === "<" ? c < 0 : c > 0;
  });
 
let violations = 0;
for (const entry of report) {
  const rule = policy.policies.find(
    (p) => p.surface === entry.surface && p.workload === entry.workload
  );
  if (!rule) {
    console.log(`⚠️  ${entry.host}/${entry.surface}: no policy defined`);
    violations++;
    continue;
  }
  if (!inRange(entry.version, rule.range)) {
    console.log(
      `❌ ${entry.host}/${entry.surface}(${entry.workload}): ` +
      `${entry.version} is outside ${rule.range} (line ${rule.line} declared)`
    );
    violations++;
  }
}
console.log(violations === 0 ? "✅ all surfaces within policy" : `${violations} violation(s)`);
process.exit(violations === 0 ? 0 : 1);

The collection side is trivial — each machine's cron or scheduled task writes one line of agy --version output into the report. The range check is a deliberately minimal hand-rolled comparison so the script runs with zero dependencies; if I ever need full semver semantics I will switch libraries, but "drift becomes visible the next morning" was the state worth reaching first.

The script returns an exit code so the same reconciliation can be dropped in front of unattended runs as a gate: an environment that violates the policy simply does not run. That quiet, negative defense is the one that pays off most.

Promotion — Feeding 2.1-Line Observations into 2.0-Line Operations

Once the lines are split, the question becomes when and how the unattended line moves. My procedure:

1. Install new 2.1-line builds only in the interactive environment. The update dialog gets obeyed there and nowhere else
2. Observe for a week in normal interactive work. Any behavior difference goes into a dated one-line note, to cross-reference against the changelog later
3. Wait for fixes to land on the 2.0 line. This is the payoff of parallel publishing: problems first encountered on the 2.1 line often come back down as 2.0-line point releases
4. Apply the 2.0-line point release to unattended environments only after a smoke test. The concrete verification steps are exactly the ones described in accepting point releases behind a smoke test and rollback harness
5. Raise the lower bound of range in version-policy.json and commit. The policy file's history becomes the decision log for version management

The exception is when a bug currently biting an unattended run is fixed only on the 2.1 line. Only then do I consider a cross-line promotion, and it goes in three stages: at least three days of observation, migrating exactly one unattended task first, and moving the rest after a week of running both in parallel. I have never migrated every task across lines at once.

The Incident This Caught in Late June

One concrete record. In late June, after moving the interactive environment to a 2.1-line point release, my note read: "substring search feels faster on long output, but the result ordering seems different." A few days later, reviewing one of my unattended runs — a task that picks specific lines out of generated logs and feeds them to the next step — I realized that if the same update had reached the unattended environment, an implicit dependency on that ordering would have broken it.

Nothing actually happened, because the unattended environment was pinned to the 2.0 line. The drift report stayed at "✅ all surfaces within policy." A story about an incident that did not occur is unglamorous, but that is precisely the value of splitting lines: you can design "nothing happened" into your operations. I rewrote the ordering dependency into an explicit sort that same week, so the 2.0-line update could be accepted without worry.

How the Changelog Reads Differently

Operating on split lines changes how you read release notes. The question is no longer just "what landed on 2.1" but "which of the 2.1 fixes also came down to 2.0." Days like July 1, when several builds publish simultaneously, are the best moments to map the correspondence between lines.

My morning batch diffs the releases page, and on days a new build appears, the only judgment I make is which step of the promotion procedure it touches. There is no need to read everything daily. With "does this affect the unattended line?" as the first filter, the check takes a few minutes.

Start by Writing One Declaration File

Parallel 2.0 and 2.1 lines mean, put bluntly, that line selection is now the user's responsibility. As a next step, adapt the version-policy.json above to your own surfaces and compare it against the versions actually installed. If even one environment turns out to be off-policy, that is reason enough to make the reconciliation a daily habit.

If you run unattended automation of your own, I hope this saves you the incident I almost had. Thank you for reading.