ship: prepare lane for review

Mobile connection fixes: desktop sync host/peer changeset ack with
retry + command result cache, iOS SyncService rework, iOS chat UI
(WorkNewChatScreen/WorkChatSessionView/model picker) updates, model
registry consolidation. Includes terminal color-env handling and
WebGL-by-default renderer.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: arul28

apps/ade-cli/src/headlessLinearServices.test.ts

@@ -420,7 +420,7 @@ describe("headlessLinearServices", () => {
     });
     expect(session.title).toBe("CTO Headless Session");
     expect(session.model).toBe("gpt-5.5");
-    expect(session.modelId).toBe("openai/gpt-5.5-codex");
+    expect(session.modelId).toBe("openai/gpt-5.5");
 
     services.dispose();
   });
@@ -440,7 +440,7 @@ describe("headlessLinearServices", () => {
     });
 
     expect(codex.model).toBe("gpt-5.5");
-    expect(codex.modelId).toBe("openai/gpt-5.5-codex");
+    expect(codex.modelId).toBe("openai/gpt-5.5");
     expect(claude.model).toBe("opus-1m");
     expect(claude.modelId).toBe("anthropic/claude-opus-4-7-1m");
 

apps/desktop/src/main/services/ai/aiIntegrationService.test.ts

@@ -296,14 +296,14 @@ describe("aiIntegrationService", () => {
       taskType: "review",
       prompt: "Evaluate this step",
       cwd: "/tmp",
-      model: "openai/gpt-5.4-codex",
+      model: "openai/gpt-5.4",
       sessionId: "carry-forward-session",
       permissionMode: "read-only",
     });
 
     expect(mockState.runProviderTask).toHaveBeenCalledWith(expect.objectContaining({
       sessionId: "carry-forward-session",
-      descriptor: expect.objectContaining({ id: "openai/gpt-5.4-codex" }),
+      descriptor: expect.objectContaining({ id: "openai/gpt-5.4" }),
       permissionMode: "read-only",
     }));
   });

apps/desktop/src/main/services/ai/aiIntegrationService.ts

@@ -183,7 +183,7 @@ const DEFAULT_AI_FEATURE_FLAGS: Record<AiFeatureKey, boolean> = {
 };
 
 const DEFAULT_CLAUDE_TASK_MODEL_ID = getDefaultModelDescriptor("claude")?.id ?? "anthropic/claude-sonnet-4-6";
-const DEFAULT_CODEX_TASK_MODEL_ID = getDefaultModelDescriptor("codex")?.id ?? "openai/gpt-5.5-codex";
+const DEFAULT_CODEX_TASK_MODEL_ID = getDefaultModelDescriptor("codex")?.id ?? "openai/gpt-5.5";
 
 const TASK_DEFAULTS: Record<AiTaskType, RuntimeTaskDefaults> = {
   planning: {

apps/desktop/src/main/services/ai/tools/ctoOperatorTools.ts

@@ -763,7 +763,7 @@ export function createCtoOperatorTools(deps: CtoOperatorToolDeps): Record<string
       "Create a native ADE work chat session — the primary way to launch an AI agent in ADE. " +
       "IMPORTANT: Always pass modelId when the user specifies a model. Use the full model ID " +
       "(e.g. 'anthropic/claude-opus-4-7' for Opus, 'anthropic/claude-sonnet-4-6' for Sonnet, " +
-      "'anthropic/claude-haiku-4-5' for Haiku, 'openai/gpt-5.5-codex' for GPT-5.5). " +
+      "'anthropic/claude-haiku-4-5' for Haiku, 'openai/gpt-5.5' for GPT-5.5). " +
       "If no modelId is passed, the CTO's default model preference is used. " +
       "Set initialPrompt to seed the chat with a task description — the agent will begin working immediately. " +
       "This creates a full ADE chat with UI, streaming, tool approval, and service integration. " +

apps/desktop/src/main/services/automations/automationService.test.ts

@@ -1144,7 +1144,7 @@ describe("automationService integration", () => {
       triggers: [{ type: "manual" as const }],
       executor: { mode: "automation-bot", targetId: null },
       modelConfig: {
-        orchestratorModel: { modelId: "openai/gpt-5.4-codex", thinkingLevel: "low" },
+        orchestratorModel: { modelId: "openai/gpt-5.4", thinkingLevel: "low" },
       },
       permissionConfig: { providers: { codex: "default" as const, opencode: "edit" as const } },
       toolPalette: [] as const,
@@ -1242,7 +1242,7 @@ describe("automationService integration", () => {
       },
       modelConfig: {
         orchestratorModel: {
-          modelId: "openai/gpt-5.4-codex",
+          modelId: "openai/gpt-5.4",
           thinkingLevel: "medium",
         },
       },

apps/desktop/src/main/services/chat/agentChatService.test.ts

@@ -5431,7 +5431,7 @@ describe("createAgentChatService", () => {
         | { mode?: unknown; settings?: { model?: unknown; reasoning_effort?: unknown; developer_instructions?: unknown } }
         | undefined;
 
-      expect(params?.approvalPolicy).toBe("untrusted");
+      expect(params?.approvalPolicy).toBe("unlessTrusted");
       expect(params?.sandboxPolicy?.type).toBe("readOnly");
       expect(params?.effort).toBe("medium");
       expect(collaborationMode?.mode).toBe("plan");
@@ -5484,7 +5484,7 @@ describe("createAgentChatService", () => {
       } | undefined;
       const collaborationMode = params?.collaborationMode as { mode?: unknown } | undefined;
 
-      expect(params?.approvalPolicy).toBe("on-request");
+      expect(params?.approvalPolicy).toBe("onRequest");
       expect(params?.sandboxPolicy?.type).toBe("workspaceWrite");
       expect(params?.effort).toBe("medium");
       expect(collaborationMode?.mode).toBe("default");
@@ -5548,8 +5548,8 @@ describe("createAgentChatService", () => {
         reasoningEffort?: unknown;
       } | undefined;
       expect(params?.approvalPolicy).toBe("never");
-      expect(params?.sandbox).toBe("danger-full-access");
-      expect(params?.reasoningEffort).toBeUndefined();
+      expect(params?.sandbox).toBe("dangerFullAccess");
+      expect(params?.reasoningEffort).toBe("medium");
 
       const turnStartRequest = mockState.codexRequestPayloads.find((payload) => payload.method === "turn/start");
       const turnStartParams = turnStartRequest?.params as {
@@ -5562,10 +5562,10 @@ describe("createAgentChatService", () => {
       expect(turnStartParams?.effort).toBe("medium");
     });
 
-    it("uses the app-server's effective Codex policy for subsequent turn/start overrides", async () => {
+    it("keeps the requested Codex reasoning effort while applying effective thread policy", async () => {
       mockState.codexResponseOverrides.set("thread/start", () => ({
         thread: { id: "thread-effective-start" },
-        approvalPolicy: "on-failure",
+        approvalPolicy: "onFailure",
         sandbox: {
           type: "workspaceWrite",
           writableRoots: [],
@@ -5582,6 +5582,7 @@ describe("createAgentChatService", () => {
         laneId: "lane-1",
         provider: "codex",
         model: "gpt-5.4",
+        reasoningEffort: "xhigh",
       });
 
       await service.sendMessage({
@@ -5593,26 +5594,28 @@ describe("createAgentChatService", () => {
         expect(mockState.codexRequestPayloads.some((payload) => payload.method === "turn/start")).toBe(true);
       });
 
+      const threadStartRequest = mockState.codexRequestPayloads.find((payload) => payload.method === "thread/start");
+      expect((threadStartRequest?.params as { reasoningEffort?: unknown } | undefined)?.reasoningEffort).toBe("xhigh");
       const turnStartRequest = mockState.codexRequestPayloads.find((payload) => payload.method === "turn/start");
       const turnStartParams = turnStartRequest?.params as {
         approvalPolicy?: unknown;
         sandboxPolicy?: { type?: unknown };
         effort?: unknown;
       } | undefined;
-      expect(turnStartParams?.approvalPolicy).toBe("on-failure");
+      expect(turnStartParams?.approvalPolicy).toBe("onFailure");
       expect(turnStartParams?.sandboxPolicy?.type).toBe("workspaceWrite");
-      expect(turnStartParams?.effort).toBe("high");
+      expect(turnStartParams?.effort).toBe("xhigh");
 
       const summary = await service.getSessionSummary(session.id);
       expect(summary?.codexApprovalPolicy).toBe("on-failure");
       expect(summary?.codexSandbox).toBe("workspace-write");
       expect(summary?.permissionMode).toBe("default");
-      expect(summary?.reasoningEffort).toBe("high");
+      expect(summary?.reasoningEffort).toBe("xhigh");
 
       const persisted = readPersistedChatState(session.id);
       expect(persisted.codexApprovalPolicy).toBe("on-failure");
       expect(persisted.codexSandbox).toBe("workspace-write");
-      expect(persisted.reasoningEffort).toBe("high");
+      expect(persisted.reasoningEffort).toBe("xhigh");
     });
 
     it("re-resumes Codex threads when permission mode changes mid-session", async () => {
@@ -5681,8 +5684,8 @@ describe("createAgentChatService", () => {
         reasoningEffort?: unknown;
       } | undefined;
       expect(params?.approvalPolicy).toBe("never");
-      expect(params?.sandbox).toBe("danger-full-access");
-      expect(params?.reasoningEffort).toBeUndefined();
+      expect(params?.sandbox).toBe("dangerFullAccess");
+      expect(params?.reasoningEffort).toBe("medium");
 
       const turnStartRequest = mockState.codexRequestPayloads.find((payload) => payload.method === "turn/start");
       const turnStartParams = turnStartRequest?.params as {
@@ -5760,7 +5763,7 @@ describe("createAgentChatService", () => {
       const resumeRequest = mockState.codexRequestPayloads.find((payload) => payload.method === "thread/resume");
       const resumeParams = resumeRequest?.params as { approvalPolicy?: unknown; sandbox?: unknown } | undefined;
       expect(resumeParams?.approvalPolicy).toBe("never");
-      expect(resumeParams?.sandbox).toBe("danger-full-access");
+      expect(resumeParams?.sandbox).toBe("dangerFullAccess");
     });
 
     it("does not auto-upgrade default Codex chats into plan mode", async () => {
@@ -5837,10 +5840,10 @@ describe("createAgentChatService", () => {
       expect(sessionService.reopen).toHaveBeenCalledWith(session.id);
     });
 
-    it("trusts the app-server's effective Codex policy on resume", async () => {
+    it("keeps persisted Codex reasoning effort while applying effective policy on resume", async () => {
       mockState.codexResponseOverrides.set("thread/resume", () => ({
         thread: { id: "thread-effective-resume" },
-        approvalPolicy: "on-failure",
+        approvalPolicy: "onFailure",
         sandbox: { type: "workspaceWrite" },
         reasoningEffort: "high",
       }));
@@ -5861,21 +5864,23 @@ describe("createAgentChatService", () => {
         codexApprovalPolicy: "never",
         codexSandbox: "danger-full-access",
         codexConfigSource: "flags",
-        reasoningEffort: "medium",
+        reasoningEffort: "xhigh",
       });
 
       const resumed = await service.resumeSession({ sessionId: session.id });
 
+      const resumeRequest = mockState.codexRequestPayloads.find((payload) => payload.method === "thread/resume");
+      expect((resumeRequest?.params as { reasoningEffort?: unknown } | undefined)?.reasoningEffort).toBe("xhigh");
       expect(resumed.codexApprovalPolicy).toBe("on-failure");
       expect(resumed.codexSandbox).toBe("workspace-write");
       expect(resumed.permissionMode).toBe("default");
-      expect(resumed.reasoningEffort).toBe("high");
+      expect(resumed.reasoningEffort).toBe("xhigh");
 
       const persistedAfter = readPersistedChatState(session.id);
       expect(persistedAfter.threadId).toBe("thread-effective-resume");
       expect(persistedAfter.codexApprovalPolicy).toBe("on-failure");
       expect(persistedAfter.codexSandbox).toBe("workspace-write");
-      expect(persistedAfter.reasoningEffort).toBe("high");
+      expect(persistedAfter.reasoningEffort).toBe("xhigh");
     });
 
     it("throws when resuming an unknown session", async () => {