[codex] fix Pet activity pill theme compatibility

Author: semantic-craft

TASK_PROGRESS.md

@@ -1,5 +1,17 @@
 # Task Progress
 
+## Pet overlay + Dream Skin compatibility — locally fixed (2026-08-04)
+
+- [goal] Preserve the native Codex Pet/avatar overlay while a Dream Skin theme is active; auxiliary pet windows remain transparent while activity pills do not repeat the skin wallpaper.
+- [scope] Branch `codex/fix-pet-overlay-compat` from clean `main` at `1c7a859`. The fix is macOS-only because the reproduced failure is native transparent-window composition on macOS. Repository changes are limited to `macos/scripts/injector.mjs`, its focused bootstrap regression, and this progress record.
+- [root cause] The native Pet activity pill intentionally uses a transparent material. With Dream Skin painting a high-contrast wallpaper behind the separate Pet composition windows, each `activity-slot-0` through `activity-slot-3` surface samples the wallpaper into a rounded rectangle. The Pet renderer was not receiving Dream Skin CSS; the missing behavior was a bounded Dream Skin compatibility treatment.
+- [implemented] The watcher recognizes only the exact `app://-/avatar-overlay-composition-surface.html?surfaceId=activity-slot-[0-3]` pages with the exact native title, re-verifies live identity, and applies an opaque native-token background only to `[class*="_activityPillMaterial_"]`. Main Codex, avatar root, mascot, voice output, voice controls, and microphone surfaces remain untouched. Pause/shutdown removal is verified before acknowledgement; target replacement and same-target reload are reprotected.
+- [tested] The focused regression first failed on the missing exported contract and now passes. The final complete `bash macos/tests/run-tests.sh` passes after the reload lifecycle change, including Swift build/XCTest, shared runtime checks, Safe CSS, import/rollback, signed-runtime integration, runtime-state integration, and Doctor. `node --check` and `git diff --check` pass.
+- [deployed locally] The installed v1.5.11 injector source was updated only after its pre-change SHA-256 matched repository `HEAD`, then the recorded injector was identity-checked and hot-restarted. Codex PID stayed `50570`; only the injector changed to PID `75775`. All four activity slots now contain the bounded style and compute to opaque `rgb(24, 24, 24)` while their HTML/body remain transparent. Main/avatar/mascot/voice surfaces contain no compatibility style. Reloading activity slot 0 produced a replacement target that the watcher automatically protected again.
+- [runtime status] The local theme operation record is `success` with message `皮肤已应用`, and a live scan of every CDP page found no Dream Skin operation host or operation registry. Pet activity slot 0 instead reports this still-running task as `Thinking`; the user's remaining spinner is therefore the Pet task-state indicator, not a stuck theme application. Codex was not restarted or switched.
+- [accepted locally] The user confirmed the native composite returned to normal after the task-state spinner ended.
+- [pending] Commit, push, open the requested draft PR, and synchronize the exact reviewed commit to Metis. No merge, version bump, or Release has occurred.
+
 ## Client release v1.5.11 — preparing (2026-08-01)
 
 - [base/merged] Settings renderer PR #334 passed exact-head CI run

macos/scripts/injector.mjs

@@ -52,6 +52,15 @@ const OPERATION_UI_HOST_ID = "chatgpt-dream-skin-operation";
 const OPERATION_UI_REGISTRY_KEY = "__CHATGPT_DREAM_SKIN_OPERATION_UI__";
 const OPERATION_KINDS = new Set(["apply", "pause", "switch"]);
 const OPERATION_UI_STATES = new Set(["success", "error", "cancelled"]);
+const PET_ACTIVITY_STYLE_ID = "codex-dream-skin-pet-compat-style";
+const PET_ACTIVITY_SURFACE_PATTERN = /^activity-slot-[0-3]$/;
+const PET_COMPOSITION_TITLE = "Codex Pet Composition Surface";
+const PET_COMPOSITION_PATH = "/avatar-overlay-composition-surface.html";
+const PET_ACTIVITY_COMPATIBILITY_CSS = `
+  [class*="_activityPillMaterial_"] {
+    background-color: var(--color-token-main-surface-primary, Canvas) !important;
+  }
+`;
 const MIN_RENDERER_WIDTH = 320;
 const MIN_RENDERER_HEIGHT = 240;
 const MAX_RENDERER_DIMENSION = 65536;
@@ -370,6 +379,42 @@ function isValidCdpPageTarget(item, port) {
   }
 }
 
+export function classifyPetActivityTarget(target) {
+  if (target?.type !== "page" || target.title !== PET_COMPOSITION_TITLE) return null;
+  let url;
+  try {
+    url = new URL(target.url);
+  } catch {
+    return null;
+  }
+  if (url.protocol !== "app:" || url.host !== "-" || url.pathname !== PET_COMPOSITION_PATH
+    || url.username || url.password || url.hash) return null;
+  const entries = [...url.searchParams.entries()];
+  if (entries.length !== 1 || entries[0][0] !== "surfaceId"
+    || !PET_ACTIVITY_SURFACE_PATTERN.test(entries[0][1])) return null;
+  return entries[0][1];
+}
+
+export function petActivityCompatibilityPayloadFor(enabled) {
+  return `(() => {
+    const styleId = ${JSON.stringify(PET_ACTIVITY_STYLE_ID)};
+    const applicable = location.protocol === "app:" && location.host === "-" &&
+      location.pathname === ${JSON.stringify(PET_COMPOSITION_PATH)} &&
+      /^\\?surfaceId=activity-slot-[0-3]$/.test(location.search);
+    const existing = document.getElementById(styleId);
+    if (!applicable || !${JSON.stringify(Boolean(enabled))}) {
+      existing?.remove();
+      return { applicable, installed: false };
+    }
+    if (!document.head) return { applicable: true, installed: false };
+    const style = existing || document.createElement("style");
+    style.id = styleId;
+    style.textContent = ${JSON.stringify(PET_ACTIVITY_COMPATIBILITY_CSS)};
+    if (!existing) document.head.append(style);
+    return { applicable: true, installed: true };
+  })()`;
+}
+
 class CdpSession {
   constructor(target, port) {
     this.target = target;
@@ -867,6 +912,23 @@ async function applyToSession(session, payload) {
   return session.evaluate(payload);
 }
 
+async function setPetActivityCompatibility(session, enabled) {
+  const result = await session.evaluate(petActivityCompatibilityPayloadFor(enabled));
+  if (!result?.applicable || result.installed !== Boolean(enabled)) {
+    throw new Error(`Pet activity compatibility ${enabled ? "install" : "removal"} did not verify`);
+  }
+  return result;
+}
+
+async function livePetActivityTarget(session) {
+  const target = await session.evaluate(`({
+    type: "page",
+    title: document.title,
+    url: location.href,
+  })`);
+  return { target, surfaceId: classifyPetActivityTarget(target) };
+}
+
 function nextOperationToken() {
   operationSequence += 1;
   return `${process.pid}:${Date.now()}:${operationSequence}`;
@@ -1560,6 +1622,7 @@ async function watchOperationState(statePath, onState) {
 async function runWatch(options) {
   let current = await loadPayload(options.themeDir);
   const sessions = new Map();
+  const petSessions = new Map();
   const rejected = new Set();
   let stopping = false;
   let reloadTimer = null;
@@ -1689,6 +1752,28 @@ async function runWatch(options) {
     sessions.clear();
   };
 
+  const releasePetSessions = async ({ strict = false } = {}) => {
+    const failures = [];
+    await Promise.all([...petSessions.entries()].map(async ([id, { session }]) => {
+      if (!session.closed) {
+        try {
+          await setPetActivityCompatibility(session, false);
+        } catch (error) {
+          if (strict) {
+            failures.push(error);
+            return;
+          }
+          console.error(`[dream-skin] pet compatibility removal failed: ${error.message}`);
+        }
+      }
+      session.close();
+      petSessions.delete(id);
+    }));
+    if (failures.length) {
+      throw new Error(`Pet compatibility removal did not verify: ${failures[0].message}`);
+    }
+  };
+
   const restoreAfterAbortedPause = async (operation) => {
     mutationEpoch += 1;
     controlOnly = false;
@@ -1833,6 +1918,7 @@ async function runWatch(options) {
       if (busy && operation.status === "pausing") {
         await reloadChain.catch(() => {});
         await waitForTargetSetups();
+        await releasePetSessions({ strict: true });
         await Promise.all([...sessions.values()].map(async (record) => {
           await invalidateEarly(record, { strict: true });
         }));
@@ -1841,6 +1927,7 @@ async function runWatch(options) {
       else if (operation.status === "paused") {
         await reloadChain.catch(() => {});
         await waitForTargetSetups().catch(() => {});
+        await releasePetSessions({ strict: true });
         await Promise.all([...sessions.values()].map((record) =>
           invalidateEarly(record, { strict: true }))).catch((error) => {
           console.error(`[dream-skin] final pause invalidation failed: ${error.message}`);
@@ -1874,6 +1961,7 @@ async function runWatch(options) {
         }
       }
       if (controlOnly && !activeOperation) {
+        await releasePetSessions();
         releaseControlSessions();
         await waitForControlOperation();
         continue;
@@ -1893,6 +1981,7 @@ async function runWatch(options) {
       }
 
       if (controlOnly && !activeOperation) {
+        await releasePetSessions();
         releaseControlSessions();
         continue;
       }
@@ -1909,12 +1998,71 @@ async function runWatch(options) {
           sessions.delete(id);
         }
       }
+      for (const [id, record] of petSessions) {
+        if (!activeIds.has(id) || record.session.closed) {
+          record.session.close();
+          petSessions.delete(id);
+        }
+      }
 
       const cycleRecovery = activeOperation ? null : pauseRecovery;
       let recoveredPauseThisCycle = false;
       let recoveryFailedThisCycle = false;
       for (const target of targets) {
-        if (sessions.has(target.id)) continue;
+        if (sessions.has(target.id) || petSessions.has(target.id)) continue;
+        const petSurfaceId = classifyPetActivityTarget(target);
+        if (petSurfaceId) {
+          let petSession;
+          let petRecord;
+          const petConnectionEpoch = mutationEpoch;
+          beginTargetSetup();
+          try {
+            petSession = await connectTarget(target, options.port);
+            const liveTarget = await livePetActivityTarget(petSession);
+            if (liveTarget.surfaceId !== petSurfaceId || liveTarget.target.url !== target.url) {
+              throw new Error("Pet activity target identity changed after connection");
+            }
+            if (controlOnly || mutationEpoch !== petConnectionEpoch) {
+              throw new Error("Pet activity target became inactive during setup");
+            }
+            await setPetActivityCompatibility(petSession, true);
+            if (controlOnly || mutationEpoch !== petConnectionEpoch) {
+              await setPetActivityCompatibility(petSession, false);
+              throw new Error("Pet activity target became inactive during setup");
+            }
+            petRecord = { session: petSession, surfaceId: petSurfaceId };
+            petSessions.set(target.id, petRecord);
+            petSession.on("Page.loadEventFired", () => {
+              const reloadEpoch = mutationEpoch;
+              setTimeout(async () => {
+                if (petSession.closed || controlOnly || mutationEpoch !== reloadEpoch
+                  || petSessions.get(target.id) !== petRecord) return;
+                try {
+                  const reloaded = await livePetActivityTarget(petSession);
+                  if (reloaded.surfaceId !== petSurfaceId) {
+                    petSession.close();
+                    petSessions.delete(target.id);
+                    return;
+                  }
+                  await setPetActivityCompatibility(petSession, true);
+                } catch (error) {
+                  console.error(`[dream-skin] pet compatibility reload failed for ${target.id}: ${error.message}`);
+                }
+              }, 0);
+            });
+            rejected.delete(target.id);
+            console.log(`[dream-skin] protected pet activity surface ${petSurfaceId}`);
+          } catch (error) {
+            petSession?.close();
+            if (!rejected.has(target.id)) {
+              console.error(`[dream-skin] pet compatibility failed for ${target.id}: ${error.message}`);
+              rejected.add(target.id);
+            }
+          } finally {
+            finishTargetSetup();
+          }
+          continue;
+        }
         let session;
         let record;
         let connectionEpoch;
@@ -2080,6 +2228,7 @@ async function runWatch(options) {
         ? bestEffortOperationUi(record.session, "hide", record.operationToken, "loading", "")
         : Promise.resolve(false)));
     await Promise.all([...sessions.values()].map((record) => removeEarly(record)));
+    await releasePetSessions();
     for (const record of sessions.values()) record.session.close();
   }
 }

macos/tests/injector-bootstrap.test.mjs

@@ -3,7 +3,11 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import vm from "node:vm";
 import { fileURLToPath } from "node:url";
-import { earlyPayloadFor } from "../scripts/injector.mjs";
+import {
+  classifyPetActivityTarget,
+  earlyPayloadFor,
+  petActivityCompatibilityPayloadFor,
+} from "../scripts/injector.mjs";
 
 const here = path.dirname(fileURLToPath(import.meta.url));
 const injectorPath = path.resolve(here, "../scripts/injector.mjs");
@@ -203,4 +207,92 @@ assert.match(
 assert.match(source, /visibleSuggestionLabels\.length >= result\.visibleCardCount/);
 assert.match(source, /result\.suggestionLabelColorsMatch/);
 
-console.log("PASS: early injection is L0-ready, generation-safe, and removed on shutdown.");
+const petTarget = (url, title = "Codex Pet Composition Surface") => ({
+  type: "page",
+  title,
+  url,
+});
+assert.equal(classifyPetActivityTarget(petTarget(
+  "app://-/avatar-overlay-composition-surface.html?surfaceId=activity-slot-0",
+)), "activity-slot-0");
+assert.equal(classifyPetActivityTarget(petTarget(
+  "app://-/avatar-overlay-composition-surface.html?surfaceId=activity-slot-3",
+)), "activity-slot-3");
+for (const url of [
+  "app://-/index.html?initialRoute=%2Favatar-overlay",
+  "app://-/avatar-overlay-composition-surface.html?surfaceId=mascot-badge",
+  "app://-/avatar-overlay-composition-surface.html?surfaceId=voice-controls",
+  "app://-/avatar-overlay-composition-surface.html?surfaceId=activity-slot-4",
+  "app://-/avatar-overlay-composition-surface.html?surfaceId=activity-slot-0&extra=1",
+  "https://-/avatar-overlay-composition-surface.html?surfaceId=activity-slot-0",
+]) {
+  assert.equal(classifyPetActivityTarget(petTarget(url)), null,
+    `Non-activity or non-app target must not receive pet compatibility CSS: ${url}`);
+}
+assert.equal(classifyPetActivityTarget(petTarget(
+  "app://-/avatar-overlay-composition-surface.html?surfaceId=activity-slot-0",
+  "Unexpected Surface",
+)), null, "The exact native pet title is part of the auxiliary-target identity boundary.");
+
+function createPetCompatibilityFixture(href) {
+  const nodes = new Map();
+  const head = {
+    append(node) {
+      node.parentNode = head;
+      nodes.set(node.id, node);
+    },
+  };
+  const document = {
+    head,
+    createElement(tagName) {
+      return { tagName: tagName.toUpperCase(), id: "", textContent: "", parentNode: null };
+    },
+    getElementById(id) { return nodes.get(id) ?? null; },
+  };
+  return {
+    context: {
+      location: new URL(href),
+      document,
+    },
+    get style() { return nodes.get("codex-dream-skin-pet-compat-style") ?? null; },
+    remove(id) { nodes.delete(id); },
+  };
+}
+
+const petCompat = createPetCompatibilityFixture(
+  "app://-/avatar-overlay-composition-surface.html?surfaceId=activity-slot-1",
+);
+vm.runInNewContext(petActivityCompatibilityPayloadFor(true), petCompat.context);
+assert.ok(petCompat.style, "An exact activity slot must receive the bounded compatibility style.");
+assert.match(petCompat.style.textContent, /\[class\*="_activityPillMaterial_"\]/);
+assert.match(petCompat.style.textContent, /var\(--color-token-main-surface-primary, Canvas\)/);
+assert.doesNotMatch(petCompat.style.textContent, /(?:html|body|main|form)\s*\{/,
+  "Pet compatibility CSS must not paint the auxiliary window or native input surface.");
+assert.doesNotMatch(petCompat.style.textContent, /background-image|url\(/,
+  "Pet compatibility CSS must never copy the Dream Skin wallpaper into pet surfaces.");
+petCompat.style.remove = () => petCompat.remove(petCompat.style.id);
+vm.runInNewContext(petActivityCompatibilityPayloadFor(false), petCompat.context);
+assert.equal(petCompat.style, null, "Pausing or stopping Dream Skin must remove the pet workaround.");
+
+const petCompatWrongSurface = createPetCompatibilityFixture(
+  "app://-/avatar-overlay-composition-surface.html?surfaceId=voice-controls",
+);
+vm.runInNewContext(petActivityCompatibilityPayloadFor(true), petCompatWrongSurface.context);
+assert.equal(petCompatWrongSurface.style, null,
+  "Voice, mascot, and other auxiliary surfaces must remain completely untouched.");
+const targetLoopStart = source.indexOf("for (const target of targets)", source.indexOf("async function runWatch"));
+const petClassificationStart = source.indexOf("classifyPetActivityTarget(target)", targetLoopStart);
+const mainEarlyRegistrationStart = source.indexOf("registerEarlyForRecord(", petClassificationStart);
+assert.ok(targetLoopStart >= 0 && petClassificationStart > targetLoopStart
+  && mainEarlyRegistrationStart > petClassificationStart,
+"Pet activity surfaces must be classified before the full Dream Skin early payload is registered.");
+assert.match(source, /await setPetActivityCompatibility\(petSession, true\)/,
+  "The watcher must install the bounded pet style only after live target identity verification.");
+assert.match(source, /petSession\.on\("Page\.loadEventFired"[\s\S]*livePetActivityTarget\(petSession\)[\s\S]*setPetActivityCompatibility\(petSession, true\)/,
+  "A same-target pet renderer reload must reverify its identity and restore the bounded style.");
+assert.match(source, /operation\.status === "pausing"[\s\S]*await releasePetSessions\(\{ strict: true \}\)/,
+  "Pausing Dream Skin must remove pet compatibility before acknowledging control-only mode.");
+assert.match(source, /finally\s*\{[\s\S]*await releasePetSessions\(\)[\s\S]*record\.session\.close/,
+  "Watcher shutdown must remove the pet style before closing auxiliary CDP sessions.");
+
+console.log("PASS: early injection is L0-ready, generation-safe, removed on shutdown, and pet-safe.");