Keep idle cleanup apply from persisting snapshot-only registry edits

Why:
- Confirmed cleanup planned from a read-only snapshot, then wrote that in-memory registry. Snapshot-only stale-lease grace restarts and cleared active-lease ids could land on disk while lease files remained.

Changed:
- After the confirmed plan matches, persist shutdown results onto a freshly loaded registry plus current simulator inventory.
- Leave unreclaimed stale-lease files and their on-disk release timestamps unchanged until a mutating load reclaims them.

Verification:
- npm run agent:verify -- --profile implementation --paths broker-core/index.mjs broker-core/test/broker-core.test.mjs --session-dir task-sessions/20260817-pr1-review-loop-5
- passed

Affected:
- broker-core/index.mjs
- broker-core/test/broker-core.test.mjs

Refs:
- #1

Session:
- task-sessions/20260817-pr1-review-loop-5

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: VladimirBrejcha

broker-core/index.mjs

@@ -4383,7 +4383,12 @@ export function cleanupIdleBroker(paths, options = {}) {
         reasonCode: "idle-plan-stale",
       });
     }
-    const result = performIdleShutdowns(paths, state, plan.candidates, {
+    const persistState = {
+      ...state,
+      registry: normalizeRegistry(readJsonIfExists(paths.registryPath), state.hostConfig, timestamp),
+    };
+    syncRegistryWithSimctl(persistState.hostConfig, persistState.registry, stateLoadOptions(options, timestamp));
+    const result = performIdleShutdowns(paths, persistState, plan.candidates, {
       ...options,
       actorId,
       actorType: "human",

broker-core/test/broker-core.test.mjs

@@ -5392,6 +5392,69 @@ test("idle cleanup apply does not contain stale leases excluded from the confirm
   assert.equal(readJson(paths.simctl.statePath).devices.find((device) => device.udid === idleLease.simulatorId).state, "Shutdown");
 });
 
+test("idle cleanup apply does not persist snapshot-only stale-lease registry edits", () => {
+  const paths = makePaths();
+  writeBaseHostConfig(paths.hostConfigPath);
+  writeBaseProject(paths.projectFilePath);
+  const resolvedPaths = brokerPaths(paths);
+
+  initBroker(resolvedPaths, runtimeOptions(paths, { processExists: () => true }));
+  const staleLease = acquireLeaseBroker(resolvedPaths, {
+    actorId: "dead-agent",
+    actorType: "agent",
+    now: "2026-01-01T00:00:00.000Z",
+    ownerPid: 424242,
+    processExists: () => true,
+    purposeId: "agent-ui-session",
+    simctlAdapter: paths.simctl.adapter,
+  }).lease;
+  const idleLease = acquireLeaseBroker(resolvedPaths, {
+    actorId: "idle-agent",
+    actorType: "agent",
+    now: "2026-01-01T00:00:00.000Z",
+    ownerPid: process.pid,
+    processExists: () => true,
+    purposeId: "agent-ui-session",
+    simctlAdapter: paths.simctl.adapter,
+  }).lease;
+  releaseLeaseBroker(resolvedPaths, {
+    leaseId: idleLease.leaseId,
+    now: "2026-01-01T00:00:00.000Z",
+    processExists: () => true,
+    simctlAdapter: paths.simctl.adapter,
+  });
+  const registry = readJson(resolvedPaths.registryPath);
+  registry.aliases[staleLease.alias].driftReason = "test-unhealthy";
+  registry.aliases[staleLease.alias].health = "repair-needed";
+  writeJson(resolvedPaths.registryPath, registry);
+  const staleAliasBefore = readJson(resolvedPaths.registryPath).aliases[staleLease.alias];
+
+  const preview = cleanupIdleBroker(resolvedPaths, {
+    now: "2026-01-01T02:00:00.000Z",
+    processExists: () => false,
+    simctlAdapter: paths.simctl.adapter,
+  });
+  assert.equal(preview.eligibleCount, 1);
+
+  const result = cleanupIdleBroker(resolvedPaths, {
+    actorId: "operator",
+    actorType: "human",
+    apply: true,
+    confirmPlanId: preview.planId,
+    now: "2026-01-01T02:00:00.000Z",
+    processExists: () => false,
+    simctlAdapter: paths.simctl.adapter,
+  });
+
+  assert.equal(result.shutdownCount, 1);
+  const staleAliasAfter = readJson(resolvedPaths.registryPath).aliases[staleLease.alias];
+  assert.equal(staleAliasAfter.activeLeaseId, staleLease.leaseId);
+  assert.equal(staleAliasAfter.lastLeaseReleasedAt, staleAliasBefore.lastLeaseReleasedAt);
+  assert.equal(staleAliasAfter.health, "repair-needed");
+  assert.equal(fs.existsSync(path.join(resolvedPaths.leasesDir, `${staleLease.leaseId}.json`)), true);
+  assert.equal(readJson(paths.simctl.statePath).devices.find((device) => device.udid === idleLease.simulatorId).state, "Shutdown");
+});
+
 test("releasing a healthy lease is not blocked by unrelated stale containment failure", () => {
   const paths = makePaths();
   writeBaseHostConfig(paths.hostConfigPath);