@intentic/machine 1.344.0 → 1.346.0

package/dist/sync/mirror.js

@@ -1,26 +1,27 @@
 import net from "node:net";
-import { sleep } from "@intentic/base/async";
 import { errorMessage } from "@intentic/base/errors";
 import { plural } from "@intentic/base/format";
 import { writeFileAtomic } from "@intentic/base/fs";
 import { PortsListSchema } from "@intentic/sandbox-contract/schemas/ports";
-import { isAttachedPairing, mirrorHeartbeatPath, pairingKey, pairingTransport, readState, removeSandboxPairings, setFileSyncAutoPaused, setFileSyncSwapPaused, setSandboxGone, setUnreachableSince, updateState, } from "./config.js";
+import { mirrorHeartbeatPath, pairingKey, pairingTransport, readState, removeSandboxPairings, retireLegacyPairings, setSandboxGone, setSwapSince, setUnreachableSince, updateState, } from "./config.js";
 import { pairingEndpoint } from "./endpoint.js";
 import { runProcess, runProcessSync } from "./exec.js";
 import { candidateBases, createDaemonBases, dialedPairings } from "../daemon-base.js";
 import { answeredGone, goneStep, SandboxGoneError } from "./gone.js";
-import { checkContainers, checkKeptHere, sandboxAnswered, sandboxSaidGone } from "./gone-watch.js";
+import { checkContainers, checkKeptHere, goneLingers, sandboxAnswered, sandboxSaidGone } from "./gone-watch.js";
 import { retireSandbox } from "./retire.js";
 import { readSwaps } from "../device/sandbox-rounds/ic-swaps.js";
 import { publishedPortsReader } from "./docker-ports.js";
 import { realBridgeExec, runGitBridge } from "./git-bridge.js";
+import { holdSessions, holdsSync, recordOf, RELEASE_FORWARDS_MS, shouldReleaseForwards, swapBegan, swapStep, syncHeld, syncHolds, UNREACHABLE_HOLD_MS } from "./holds.js";
 import { guardDisks } from "./low-disk.js";
-import { ensureMutagen, ensureSyncSession, existingSyncSessions, forwardedPorts, forwardSessionName, healDerivedConflicts, MUTAGEN_CALL_TIMEOUT_MS, mutagenForwardArgs, ourForwardSessions, pauseRunningSync, relabelBudget, retireOrphanSessions, resumeAutoPausedSync, resumeSwapPausedSync, runMutagenAsync, sayDaemonEventsTo, sessionLabels, startMutagenDaemon, syncMode, syncSessionNames, } from "./mutagen.js";
+import { ensureSyncSession, existingSyncSessions, forwardedPorts, forwardSessionName, healDerivedConflicts, MUTAGEN_CALL_TIMEOUT_MS, mutagenForwardArgs, ourForwardSessions, relabelBudget, retireOrphanSessions, runMutagenAsync, sayDaemonEventsTo, sessionLabels, startMutagenDaemon, syncMode, syncSessionNames, } from "./mutagen.js";
+import { ensureMutagen } from "./binary/mutagen-binary.js";
 import { moveOffSharedMutagen } from "./mutagen-move.js";
 import { quieted } from "./repeats.js";
+import { sleepUnlessWoken } from "./wake.js";
 import { deviceReport, scopedReport } from "./report.js";
 import { pairingSshConfig, writeManagedSshConfig } from "./ssh.js";
-import { holdsSync, recordOf, RELEASE_FORWARDS_MS, shouldReleaseForwards, swapPauseStep } from "./swap-pause.js";
 import { createTunnelPool, tunnelTargets } from "./tunnel.js";
 const POLL_MS = 5000;
 const PORTS_TIMEOUT_MS = 10_000;
@@ -28,8 +29,6 @@ const REPO_LIST_EVERY_TICKS = 12;
 const REPORT_EVERY_TICKS = 3;
 const REPORT_TIMEOUT_MS = 10_000;
 const REVOKED_POLLS = 3;
-const UNREACHABLE_PAUSE_MS = 60 * 60_000;
-export const shouldAutoPauseFileSync = (unreachableForMs) => unreachableForMs >= UNREACHABLE_PAUSE_MS;
 export const pollBackoffMs = (unreachableForMs) => unreachableForMs < 60_000 ? 0 : unreachableForMs < 10 * 60_000 ? 30_000 : 5 * 60_000;
 export const pollDue = (held, now) => held === undefined || now - held.lastTried >= pollBackoffMs(now - held.since);
 export class SyncAuthError extends Error {
@@ -225,9 +224,6 @@ const servePairing = async (context, pairing, base) => {
     const { mutagen, claimedBy, holding, holders, say: log } = context;
     const baseline = pairing.mirroredPorts ?? [];
     const ports = pairing.syncToken === undefined ? [] : await fetchWorkspacePorts(base, pairing.syncToken);
-    if (isAttachedPairing(pairing)) {
-        return [];
-    }
     if (pairing.mirrorOff === true) {
         await retireSwitchedOff(mutagen, pairing, log);
         return [];
@@ -286,7 +282,6 @@ const dropRevokedPairing = async (mutagen, sandboxId, log) => {
     await removeSandboxPairings(sandboxId);
     retireOrphanSessions(mutagen, (await readState()).pairings, log);
 };
-const keyOfSandbox = (key, sandboxId) => key === sandboxId || key.startsWith(`${sandboxId}~`);
 const guard = async (log, what, step) => {
     try {
         await step();
@@ -308,15 +303,14 @@ const absorbRejectedPoll = async (mutagen, pairing, rejectedPolls, repos, sessio
     log(`${pairing.sandboxId} rejected the sync token ${REVOKED_POLLS} polls in a row: this machine's enrollment was revoked.`);
     rejectedPolls.delete(pairing.sandboxId);
     repos.delete(pairing.sandboxId);
-    for (const key of [...sessionsPending].filter((held) => keyOfSandbox(held, pairing.sandboxId))) {
-        sessionsPending.delete(key);
-    }
+    sessionsPending.delete(pairingKey(pairing));
     await dropRevokedPairing(mutagen, pairing.sandboxId, log);
     return true;
 };
 const absorbUnreachablePoll = async (mutagen, pairing, unreachable, log) => {
     const now = Date.now();
-    const since = unreachable.get(pairing.sandboxId)?.since ?? pairing.unreachableSince ?? now;
+    const before = unreachable.get(pairing.sandboxId);
+    const since = before?.since ?? pairing.unreachableSince ?? now;
     unreachable.set(pairing.sandboxId, { since, lastTried: now });
     if (pairing.unreachableSince === undefined) {
         await setUnreachableSince(pairing.sandboxId, since);
@@ -326,15 +320,11 @@ const absorbUnreachablePoll = async (mutagen, pairing, unreachable, log) => {
         await retirePairingMirror(mutagen, pairing.sandboxId);
         log(`  ${pairing.sandboxId}: unreachable for ${RELEASE_FORWARDS_MS / 60_000} minutes; took its ${plural(mirrored, "port")} off localhost. They come back when it answers again.`);
     }
-    return await pauseIfLongUnreachable(mutagen, pairing, now - since, log);
-};
-const pauseIfLongUnreachable = async (mutagen, pairing, unreachableForMs, log) => {
-    if (pairing.fileSyncAutoPaused === true || !shouldAutoPauseFileSync(unreachableForMs) || !pauseRunningSync(mutagen, pairing)) {
-        return false;
+    const holds = now - since >= UNREACHABLE_HOLD_MS;
+    if (holds && (before === undefined || before.lastTried - since < UNREACHABLE_HOLD_MS)) {
+        log(`  ${pairing.sandboxId}: unreachable for an hour; its file sync holds still to stop permanent reconnect and scanning load, and carries on when it answers.`);
     }
-    await setFileSyncAutoPaused(pairingKey(pairing), true);
-    log(`  ${pairingKey(pairing)}: unreachable for one hour; paused its Mutagen sessions to stop permanent reconnect/scanning load. They resume automatically when it returns.`);
-    return true;
+    return holds;
 };
 const startBridge = (tracking, pairing, tick, say) => {
     const id = pairing.sandboxId;
@@ -392,7 +382,7 @@ export const markPrepared = (prepared, pairing) => void prepared.add(setupOf(pai
 const prepareSession = async (mutagen, pairing, pending, relabels, say) => {
     let converged = false;
     await guard(say, `${pairingKey(pairing)}: preparing its file sync`, async () => {
-        converged = await ensureSyncSession(mutagen, pairing, say, relabels);
+        converged = await ensureSyncSession(mutagen, pairing, say, syncHeld(pairing, Date.now()), relabels);
     });
     if (converged) {
         pending.delete(pairingKey(pairing));
@@ -403,62 +393,15 @@ const prepareSession = async (mutagen, pairing, pending, relabels, say) => {
     return converged;
 };
 const dormant = (mutagen, pairing) => pairing.goneSince !== undefined ||
-    pairing.fileSyncPausedFor !== undefined ||
-    (pairing.fileSyncAutoPaused === true && (existingSyncSessions(mutagen, syncSessionNames(pairing)) ?? [undefined]).length > 0);
-export const readyToPrepare = async (setups, firstCopyAhead, announce) => {
-    const told = new Map();
-    const ready = [];
-    for (const pairing of setups) {
-        if (isAttachedPairing(pairing) && pairing.mode === "sync" && pairing.localDir !== undefined && firstCopyAhead(pairing)) {
-            const said = told.get(pairing.sandboxId) ?? (await announce(pairing));
-            told.set(pairing.sandboxId, said);
-            if (!said) {
-                continue;
-            }
-        }
-        ready.push(pairing);
-    }
-    return ready;
-};
-const announcer = (mutagen, bases, unsupported, unreachable, gone, say) => async (pairing) => {
-    if (pairing.goneSince !== undefined) {
-        return false;
-    }
-    if (pairing.syncToken === undefined || unsupported.has(pairing.sandboxId)) {
-        return true;
-    }
-    if (!pollDue(unreachable.get(pairing.sandboxId), Date.now())) {
-        return false;
-    }
-    try {
-        const response = await sendReport(await bases.resolve(pairing), pairing, await deviceReport(mutagen));
-        if (response.status === 404) {
-            unsupported.add(pairing.sandboxId);
-            say(`  ${pairing.sandboxId}: this sandbox is running a daemon without machine reports, its Devices view will stay empty.`);
-            return true;
-        }
-        if (answeredGone(response)) {
-            await gone(pairing);
-            return false;
-        }
-        if (!response.ok) {
-            say(`  ${pairingKey(pairing)}: ${pairing.sandboxId} did not take the report naming this folder (${response.status}); its first copy waits for it.`);
-        }
-        return response.ok;
-    }
-    catch (error) {
-        say(`  ${pairingKey(pairing)}: ${pairing.sandboxId} could not be told of this folder (${errorMessage(error)}); its first copy waits until it can.`);
-        return false;
-    }
-};
-const prepareSessions = async (mutagen, pairings, prepared, pending, announce, passes, say) => {
-    const firstCopyAhead = (pairing) => (existingSyncSessions(mutagen, syncSessionNames(pairing)) ?? []).length === 0;
+    pairing.containerAway !== undefined ||
+    (syncHolds(pairing, Date.now()).includes("unreachable") && (existingSyncSessions(mutagen, syncSessionNames(pairing)) ?? [undefined]).length > 0);
+const prepareSessions = async (mutagen, pairings, prepared, pending, passes, say) => {
     const unprepared = unpreparedSetups(pairings, prepared);
     const docker = unprepared.filter((pairing) => pairingTransport(pairing) === "docker");
     if (docker.length > 0) {
         await guard(say, "asking after the containers docker pairings reach", async () => await checkContainers(passes.fate, docker, answeringOf(passes.tracking)));
     }
-    for (const pairing of await readyToPrepare(unprepared, firstCopyAhead, announce)) {
+    for (const pairing of unprepared) {
         markPrepared(prepared, pairing);
         if (dormant(mutagen, pairing)) {
             pending.add(pairingKey(pairing));
@@ -478,25 +421,23 @@ const retryPendingSessions = async (mutagen, pairings, sessionsPending, tick, re
         }
     }
 };
-const holdSyncDuringSwaps = async (mutagen, pairings, unreachable, say) => {
-    const records = await readSwaps();
+export const holdSyncDuringSwaps = async (pairings, unreachable, say, read = readSwaps, record = setSwapSince) => {
+    const records = await read();
     const now = Date.now();
     const held = new Set();
     for (const pairing of pairings) {
-        const record = recordOf(pairing, records);
-        const holds = holdsSync(record, now, !unreachable.has(pairing.sandboxId));
+        const swap = recordOf(pairing, records);
+        const holds = holdsSync(swap, pairing.swapSince, now, !unreachable.has(pairing.sandboxId));
         if (holds) {
             held.add(pairing.sandboxId);
         }
-        const step = swapPauseStep(pairing, holds);
-        if (step === "pause" && pauseRunningSync(mutagen, pairing)) {
-            await setFileSyncSwapPaused(pairingKey(pairing), true);
-            say(`  ${pairingKey(pairing)}: its sandbox is being swapped on this machine; file sync is paused until the new version has held.`);
-        }
-        else if (step === "resume") {
-            resumeSwapPausedSync(mutagen, pairing);
-            await setFileSyncSwapPaused(pairingKey(pairing), false);
-            say(`  ${pairingKey(pairing)}: its sandbox's swap is settled; file sync resumed.`);
+        const began = swapBegan(swap, pairing.swapSince, now);
+        const step = swapStep(pairing, holds, began);
+        if (step !== undefined) {
+            await record(pairingKey(pairing), step === "began" ? began : undefined);
+            say(step === "began"
+                ? `  ${pairingKey(pairing)}: its sandbox is being swapped on this machine; file sync holds still until the new version has held.`
+                : `  ${pairingKey(pairing)}: its sandbox's swap is settled; file sync carries on.`);
         }
     }
     return held;
@@ -506,29 +447,23 @@ const runPairingPass = async (context, pairing, base) => {
     const { rejectedPolls, unreachable } = tracking;
     const swapping = swapHeld.has(pairing.sandboxId);
     const short = context.diskHeld.has(pairingKey(pairing));
-    let pausedThisPass = false;
+    let heldThisPass = false;
     try {
         const mirrored = await servePairing(context, pairing, base);
         rejectedPolls.delete(pairing.sandboxId);
         unreachable.delete(pairing.sandboxId);
-        if (context.pairings.some((held) => held.sandboxId === pairing.sandboxId && held.goneSince !== undefined)) {
+        if (goneLingers(context.pairings, pairing.sandboxId)) {
             await sandboxAnswered(fate, pairing.sandboxId);
         }
         if (context.pairings.some((held) => held.sandboxId === pairing.sandboxId && held.unreachableSince !== undefined)) {
             await setUnreachableSince(pairing.sandboxId, undefined);
         }
-        if (!swapping && !short && resumeAutoPausedSync(mutagen, pairing)) {
-            await setFileSyncAutoPaused(pairingKey(pairing), false);
-            say(`  ${pairingKey(pairing)}: reachable again; resumed its automatically paused file sync`);
+        for (const port of mirrored) {
+            claimedBy.set(port.port, pairing.sandboxId);
         }
-        if (!isAttachedPairing(pairing)) {
-            for (const port of mirrored) {
-                claimedBy.set(port.port, pairing.sandboxId);
-            }
-            handOver(holding, pairing.sandboxId, mirrored);
-            if (tick % STRANDED_SWEEP_EVERY_TICKS === 0) {
-                sweepStrandedForwards(mutagen, pairing.sandboxId, mirrored, say);
-            }
+        handOver(holding, pairing.sandboxId, mirrored);
+        if (tick % STRANDED_SWEEP_EVERY_TICKS === 0) {
+            sweepStrandedForwards(mutagen, pairing.sandboxId, mirrored, say);
         }
     }
     catch (error) {
@@ -537,49 +472,16 @@ const runPairingPass = async (context, pairing, base) => {
         if (outcome.drop) {
             return;
         }
-        pausedThisPass = outcome.paused;
+        heldThisPass = outcome.paused;
         say(`  ${pairingKey(pairing)}: reconcile skipped: ${errorMessage(error)}`);
     }
-    if (pairing.fileSyncAutoPaused === true || pairing.fileSyncPausedFor !== undefined || pausedThisPass || swapping || short) {
+    if (syncHeld({ ...pairing, unreachableSince: undefined }, Date.now()) || heldThisPass || swapping || short) {
         stopBridge(tracking, pairing.sandboxId);
         return;
     }
     await healPairing(mutagen, pairing, tick, say);
     startBridge(tracking, pairing, tick, say);
 };
-export const pollingPairings = (pairings) => {
-    const polling = new Set();
-    for (const sandboxId of new Set(pairings.map((pairing) => pairing.sandboxId))) {
-        const own = pairings.filter((pairing) => pairing.sandboxId === sandboxId);
-        const poller = own.find((pairing) => !isAttachedPairing(pairing)) ?? own[0];
-        if (poller !== undefined) {
-            polling.add(pairingKey(poller));
-        }
-    }
-    return polling;
-};
-const followSandbox = async (context, pairing) => {
-    const { mutagen, tick, tracking, swapHeld, say } = context;
-    if (pairing.goneSince !== undefined || pairing.fileSyncPausedFor !== undefined) {
-        return;
-    }
-    const down = tracking.unreachable.get(pairing.sandboxId)?.since ?? pairing.unreachableSince;
-    const swapping = swapHeld.has(pairing.sandboxId);
-    const short = context.diskHeld.has(pairingKey(pairing));
-    if (down === undefined) {
-        if (!swapping && !short && resumeAutoPausedSync(mutagen, pairing)) {
-            await setFileSyncAutoPaused(pairingKey(pairing), false);
-            say(`  ${pairingKey(pairing)}: reachable again; resumed its automatically paused file sync`);
-        }
-    }
-    else if (await pauseIfLongUnreachable(mutagen, pairing, Date.now() - down, say)) {
-        return;
-    }
-    if (pairing.fileSyncAutoPaused === true || swapping || short) {
-        return;
-    }
-    await healPairing(mutagen, pairing, tick, say);
-};
 const passGone = async (context, pairing) => {
     const now = Date.now();
     const step = goneStep(pairing, now);
@@ -600,15 +502,12 @@ const passGone = async (context, pairing) => {
         tracking.unreachable.delete(pairing.sandboxId);
         tracking.rejectedPolls.delete(pairing.sandboxId);
         tracking.repos.delete(pairing.sandboxId);
-        for (const key of [...tracking.sessionsPending].filter((held) => keyOfSandbox(held, pairing.sandboxId))) {
-            tracking.sessionsPending.delete(key);
-        }
+        tracking.sessionsPending.delete(pairingKey(pairing));
     }
     return "skip";
 };
-const runPasses = async (context, dialed, pairings, live) => {
-    const polling = pollingPairings(pairings);
-    for (const { pairing, base } of dialed.filter((held) => polling.has(pairingKey(held.pairing)))) {
+const runPasses = async (context, dialed, live) => {
+    for (const { pairing, base } of dialed) {
         if (!live()) {
             return;
         }
@@ -622,12 +521,6 @@ const runPasses = async (context, dialed, pairings, live) => {
         await runPairingPass(context, pairing, base);
         context.progress(`${pairingKey(pairing)}'s pass`);
     }
-    for (const { pairing } of dialed.filter((held) => !polling.has(pairingKey(held.pairing)))) {
-        if (!live()) {
-            return;
-        }
-        await guard(context.say, `${pairingKey(pairing)}: following its sandbox`, async () => await followSandbox(context, pairing));
-    }
 };
 const ORPHAN_SWEEP_EVERY_TICKS = 12;
 const CONTAINER_CHECK_EVERY_TICKS = 12;
@@ -695,7 +588,7 @@ const watchLoop = async (log, generation) => {
         if ((await watchTick(watch, tick)) === "stop") {
             return;
         }
-        await sleep(POLL_MS, { signal: generation.signal });
+        await sleepUnlessWoken(POLL_MS, generation.signal);
     }
 };
 const startWatch = async (log, generation) => {
@@ -703,8 +596,15 @@ const startWatch = async (log, generation) => {
     const say = quieted(log);
     sayDaemonEventsTo(say);
     await guard(say, "moving off Mutagen's shared data directory", async () => await moveOffSharedMutagen(mutagen, say));
+    let retired = 0;
+    await guard(say, "retiring the pairings of this computer's old sandbox for folders", async () => {
+        retired = (await retireLegacyPairings(log)).length;
+    });
     const initial = await readState();
     if (initial.pairings.length === 0) {
+        if (retired > 0 && startMutagenDaemon(mutagen)) {
+            await guard(say, "retiring orphaned sessions", () => retireOrphanSessions(mutagen, [], say));
+        }
         log("no sandboxes are paired: nothing to mirror. Enable it from a sandbox's Desktop sync card.");
         return undefined;
     }
@@ -713,9 +613,9 @@ const startWatch = async (log, generation) => {
     }
     const sshConfig = pairingSshConfig(initial.pairings);
     await guard(say, "refreshing the ssh configuration", async () => await writeManagedSshConfig(sshConfig));
-    const tunnels = createTunnelPool(say, generation.signal);
-    generation.stopTransports = tunnels.stopAll;
     const bases = createDaemonBases(say);
+    const tunnels = createTunnelPool(say, generation.signal, (sandboxId) => bases.failed(sandboxId));
+    generation.stopTransports = tunnels.stopAll;
     await guard(say, "opening the sync transports", async () => await tunnels.reconcile(tunnelTargets(await dialedPairings(initial.pairings, bases))));
     const tracking = {
         rejectedPolls: new Map(),
@@ -726,7 +626,7 @@ const startWatch = async (log, generation) => {
     };
     generation.signal.addEventListener("abort", () => stopBridges(tracking), { once: true });
     const reportUnsupported = new Set();
-    const fate = { mutagen, releaseForwards: async (sandboxId) => await retirePairingMirror(mutagen, sandboxId), say };
+    const fate = { releaseForwards: async (sandboxId) => await retirePairingMirror(mutagen, sandboxId), say };
     const gone = async (pairing) => await sandboxSaidGone(fate, pairing.sandboxId, "edge");
     const watch = {
         log,
@@ -745,11 +645,10 @@ const startWatch = async (log, generation) => {
         reportUnsupported,
         fate,
         gone,
-        announce: announcer(mutagen, bases, reportUnsupported, tracking.unreachable, gone, say),
         holders: { dockerPorts: publishedPortsReader(say), freeSince: new Map() },
         sshConfig,
     };
-    await prepareSessions(mutagen, initial.pairings, watch.sessionsPrepared, tracking.sessionsPending, watch.announce, { fate, relabels: relabelBudget(1), tracking }, say);
+    await prepareSessions(mutagen, initial.pairings, watch.sessionsPrepared, tracking.sessionsPending, { fate, relabels: relabelBudget(1), tracking }, say);
     await guard(say, "retiring orphaned sessions", () => retireOrphanSessions(mutagen, initial.pairings, say));
     log(`sync started; polling ${plural(initial.pairings.length, "paired sandbox")} every ${POLL_MS / 1000}s`);
     return watch;
@@ -779,7 +678,7 @@ const watchTick = async (watch, tick) => {
     await guard(say, "reconciling the sync transports", async () => await watch.tunnels.reconcile(tunnelTargets(dialed)));
     progress("the sync transports");
     const relabels = relabelBudget(1);
-    await prepareSessions(mutagen, state.pairings, watch.sessionsPrepared, tracking.sessionsPending, watch.announce, { fate, relabels, tracking }, say);
+    await prepareSessions(mutagen, state.pairings, watch.sessionsPrepared, tracking.sessionsPending, { fate, relabels, tracking }, say);
     await retryPendingSessions(mutagen, state.pairings, tracking.sessionsPending, tick, relabels, say);
     progress("preparing file sync");
     if (!watch.live()) {
@@ -787,11 +686,11 @@ const watchTick = async (watch, tick) => {
     }
     let swapHeld = new Set();
     await guard(say, "holding file sync still during swaps", async () => {
-        swapHeld = await holdSyncDuringSwaps(mutagen, state.pairings, tracking.unreachable, say);
+        swapHeld = await holdSyncDuringSwaps(state.pairings, tracking.unreachable, say);
     });
     let diskHeld = new Set();
     await guard(say, "measuring the drives synced folders are on", async () => {
-        diskHeld = await guardDisks(mutagen, state.pairings, tick, say);
+        diskHeld = await guardDisks(state.pairings, say);
     });
     stopBridges(tracking, state.pairings);
     const context = {
@@ -810,10 +709,12 @@ const watchTick = async (watch, tick) => {
         pairings: state.pairings,
         say,
     };
-    await runPasses(context, dialed, state.pairings, watch.live);
+    await runPasses(context, dialed, watch.live);
     if (!watch.live()) {
         return "stop";
     }
+    await guard(say, "holding file sync still where something holds it", async () => void (await holdSessions(mutagen, (await readState()).pairings, say)));
+    progress("holding file sync");
     if (tick % REPORT_EVERY_TICKS === 0) {
         await guard(say, "posting this machine's reports", async () => await postReports(dialed, mutagen, watch.reportUnsupported, watch.gone, say));
     }
@@ -831,7 +732,7 @@ const teardownForwards = async (mutagen, sandboxId) => {
         await runProcess(mutagen, ["forward", "terminate", ...names], { timeoutMs: MUTAGEN_CALL_TIMEOUT_MS });
     }
     await updateState((state) => ({
-        pairings: state.pairings.map((held) => (sandboxId === undefined || held.sandboxId === sandboxId) && !isAttachedPairing(held)
+        pairings: state.pairings.map((held) => sandboxId === undefined || held.sandboxId === sandboxId
             ? { ...held, mirroredPorts: [], skippedPorts: [] }
             : held),
     }));
@@ -843,7 +744,7 @@ export const retireMirroredPort = async (mutagen, sandboxId, port) => {
     let wasMirrored = false;
     await updateState((state) => ({
         pairings: state.pairings.map((held) => {
-            if (held.sandboxId !== sandboxId || isAttachedPairing(held)) {
+            if (held.sandboxId !== sandboxId) {
                 return held;
             }
             const mirrored = held.mirroredPorts ?? [];