@@ -73,8 +73,9 @@ export const make = Effect.gen(function* () {
         );
         if (current === null || current.runId !== candidate.runId) return;
         const instance = yield* instances.getInstance(projection.thread.providerInstanceId);
-        if (instance === undefined || !instance.enabled || instance.driverKind !== current.driver)
-          return;
+        // Enablement is the project-resolved value above; a project can enable
+        // an instance that is disabled machine-wide.
+        if (instance === undefined || instance.driverKind !== current.driver) return;
         // Earlier candidates in this sweep can push this one past its cache TTL.
         if (DateTime.toEpochMillis(yield* DateTime.now) >= window.endMs) return;
         // One idempotent command per completed run survives concurrent scans and
 
@@ -4136,6 +4136,11 @@ it.layer(layerTest)("OrchestrationV2LayerLive lifecycle", (it) => {
           ],
         });
 
+        // A failed idle compaction is maintenance: the queued message still runs.
+        if (idleCompaction) {
+          assert.equal(yield* Queue.take(promotedRunIds), queuedRun.id);
+          return;
+        }
         if (failureClass === "provider_error") {
           assert.equal(yield* Queue.take(heldRunIds), queuedRun.id);
           const held = yield* orchestrator.getThreadProjection(threadId);
@@ -4153,7 +4158,6 @@ it.layer(layerTest)("OrchestrationV2LayerLive lifecycle", (it) => {
         const after = yield* orchestrator.getThreadProjection(threadId);
         assert.equal(after.runs.find((run) => run.id === queuedRun.id)?.status, "queued");
         assert.isFalse(after.turnItems.some((item) => item.runId === queuedRun.id));
-        if (idleCompaction) return;
         const shell = (yield* orchestrator.getShellSnapshot()).threads.find(
           (thread) => thread.id === threadId,
         );
 
@@ -72,10 +72,17 @@ function presentedUsageLimitRun(
   const providerSession = projection.providerSessions.findLast(
     (session) => session.providerInstanceId === projection.thread.providerInstanceId,
   );
+  // Mirrors the server shell: idle compaction never stands for the outcome.
+  const latestPhysicalRun = projection.runs.reduce<(typeof projection.runs)[number] | null>(
+    (latest, run) => (latest === null || run.ordinal > latest.ordinal ? run : latest),
+    null,
+  );
   return usageLimitRunPresentedAsLatest(
-    projection.runs,
+    projection.runs.filter((run) => run.idleCompactionOfRunId === undefined),
     projection.turnItems,
-    providerSession?.lastError ?? null,
+    latestPhysicalRun?.idleCompactionOfRunId !== undefined
+      ? null
+      : (providerSession?.lastError ?? null),
   );
 }
 
 
@@ -53,6 +53,10 @@ export function latestExecutedRun(
 ): OrchestrationV2Run | null {
   let latest: OrchestrationV2Run | null = null;
   for (const run of runs) {
+    // A failed idle compaction is invisible maintenance: it neither presents as
+    // the outcome nor holds the queue. A queued message that then meets the same
+    // usage limit fails as an ordinary run with the normal recovery controls.
+    if (run.idleCompactionOfRunId !== undefined) continue;
     if (run.status === "queued") continue;
     if (run.status === "cancelled" && run.startedAt === null) continue;
     if (latest === null || runRanAfter(run, latest)) latest = run;