Update tests for CLI 1.0.81-6

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Author: stephentoub

nodejs/test/e2e/factory.e2e.test.ts

@@ -93,12 +93,9 @@ it.skipIf(isInProcessTransport)(
     }
 );
 
-// TODO(cli-1.0.81-2): the subagent request is rejected downstream under CLI 1.0.81-2, so the
-// fixture reports didThrow: true. Re-enable once the runtime fix ships.
-//
 // The timeout is generous because the factory abandons its subagent once the runtime has
 // accepted the request, so the run settles only after the runtime drains that work.
-it.skip("forwards every declared subagent option to the runtime", async () => {
+it("forwards every declared subagent option to the runtime", async () => {
     if (!factoryTestContext) {
         throw new Error("Factory E2E requires the stdio transport");
     }

nodejs/test/e2e/permissions.e2e.test.ts

@@ -17,8 +17,6 @@ import { approveAll, defineTool, createAttributedPermissionResult } from "../../
 import { createSdkTestContext, isInProcessTransport } from "./harness/sdkTestContext.js";
 import { getFinalAssistantMessage, getNextEventOfType } from "./harness/sdkTestHelper.js";
 
-const isWindows = process.platform === "win32";
-
 describe("Permission callbacks", async () => {
     const { copilotClient: client, workDir } = await createSdkTestContext();
 
@@ -632,76 +630,67 @@ describe("Permission callbacks", async () => {
         }
     });
 
-    // TODO(cli-1.0.81-2): CLI 1.0.81-2 no longer matches the location key returned by
-    // permissions.locations.resolve when permissions.locations.apply re-resolves it on Windows,
-    // so appliedRuleCount comes back as 0. Still covered on Linux and macOS.
-    it.skipIf(isWindows)(
-        "should invoke permission location and folder trust rpc apis",
-        async () => {
-            const session = await client.createSession({ onPermissionRequest: approveAll });
-            const locationDirectory = await createUniqueWorkDirectory(
-                workDir,
-                "permission-location"
-            );
-            const trustedDirectory = await createUniqueWorkDirectory(workDir, "folder-trust");
-            const commandIdentifier = `node-permission-location-${Date.now()}`;
-            try {
-                const resolved = await session.rpc.permissions.locations.resolve({
-                    workingDirectory: locationDirectory,
-                });
-                expect(resolved.locationType).toBe("dir");
-                expectPathEqual(resolved.locationKey, locationDirectory);
-
-                expect(
-                    (
-                        await session.rpc.permissions.locations.addToolApproval({
-                            locationKey: resolved.locationKey,
-                            approval: {
-                                kind: "commands",
-                                commandIdentifiers: [commandIdentifier],
-                            },
-                        })
-                    ).success
-                ).toBe(true);
-
-                const applied = await session.rpc.permissions.locations.apply({
-                    workingDirectory: locationDirectory,
-                });
-                expect(applied.locationType).toBe(resolved.locationType);
-                expectPathEqual(applied.locationKey, resolved.locationKey);
-                expect(applied.appliedRuleCount).toBeGreaterThanOrEqual(1);
-                expect(
-                    applied.appliedRules.some(
-                        (rule) => rule.kind === "shell" && rule.argument === commandIdentifier
-                    )
-                ).toBe(true);
-
-                expect(
-                    (
-                        await session.rpc.permissions.folderTrust.isTrusted({
-                            path: trustedDirectory,
-                        })
-                    ).trusted
-                ).toBe(false);
-                expect(
-                    (
-                        await session.rpc.permissions.folderTrust.addTrusted({
-                            path: trustedDirectory,
-                        })
-                    ).success
-                ).toBe(true);
-                expect(
-                    (
-                        await session.rpc.permissions.folderTrust.isTrusted({
-                            path: trustedDirectory,
-                        })
-                    ).trusted
-                ).toBe(true);
-            } finally {
-                await session.disconnect();
-            }
+    it("should invoke permission location and folder trust rpc apis", async () => {
+        const session = await client.createSession({ onPermissionRequest: approveAll });
+        const locationDirectory = await createUniqueWorkDirectory(workDir, "permission-location");
+        const trustedDirectory = await createUniqueWorkDirectory(workDir, "folder-trust");
+        const commandIdentifier = `node-permission-location-${Date.now()}`;
+        try {
+            const resolved = await session.rpc.permissions.locations.resolve({
+                workingDirectory: locationDirectory,
+            });
+            expect(resolved.locationType).toBe("dir");
+            expectPathEqual(resolved.locationKey, locationDirectory);
+
+            expect(
+                (
+                    await session.rpc.permissions.locations.addToolApproval({
+                        locationKey: resolved.locationKey,
+                        approval: {
+                            kind: "commands",
+                            commandIdentifiers: [commandIdentifier],
+                        },
+                    })
+                ).success
+            ).toBe(true);
+
+            const applied = await session.rpc.permissions.locations.apply({
+                workingDirectory: locationDirectory,
+            });
+            expect(applied.locationType).toBe(resolved.locationType);
+            expectPathEqual(applied.locationKey, resolved.locationKey);
+            expect(applied.appliedRuleCount).toBeGreaterThanOrEqual(1);
+            expect(
+                applied.appliedRules.some(
+                    (rule) => rule.kind === "shell" && rule.argument === commandIdentifier
+                )
+            ).toBe(true);
+
+            expect(
+                (
+                    await session.rpc.permissions.folderTrust.isTrusted({
+                        path: trustedDirectory,
+                    })
+                ).trusted
+            ).toBe(false);
+            expect(
+                (
+                    await session.rpc.permissions.folderTrust.addTrusted({
+                        path: trustedDirectory,
+                    })
+                ).success
+            ).toBe(true);
+            expect(
+                (
+                    await session.rpc.permissions.folderTrust.isTrusted({
+                        path: trustedDirectory,
+                    })
+                ).trusted
+            ).toBe(true);
+        } finally {
+            await session.disconnect();
         }
-    );
+    });
 });
 
 async function createUniqueWorkDirectory(baseDir: string, prefix: string): Promise<string> {

nodejs/test/e2e/rpc_ui_ephemeral_query.e2e.test.ts

@@ -9,10 +9,7 @@ import { createSdkTestContext } from "./harness/sdkTestContext.js";
 describe("UI ephemeral query RPC", async () => {
     const { copilotClient: client } = await createSdkTestContext();
 
-    // TODO(cli-1.0.81-2): CLI 1.0.81-5 still fails session.ui.ephemeralQuery against the
-    // recorded snapshot on macOS ("Failed to get response from the AI model"). Re-enable
-    // once the runtime fix ships.
-    it.skip("should answer ephemeral query", { timeout: 120_000 }, async () => {
+    it("should answer ephemeral query", { timeout: 120_000 }, async () => {
         const session = await client.createSession({ onPermissionRequest: approveAll });
         try {
             const result = await session.rpc.ui.ephemeralQuery({

rust/tests/e2e/rpc_mcp_lifecycle.rs

@@ -209,6 +209,7 @@ async fn should_start_and_restart_mcp_server() {
 // internal methods generically; it never exercised a supported wire API.
 
 #[tokio::test]
+#[ignore = "blocked on CLI 1.0.81-6 missing session.mcp.reloadWithConfig handler"]
 async fn should_reload_mcp_servers_with_config() {
     super::support::with_shared_e2e_context(
         &E2E,
@@ -252,6 +253,7 @@ async fn should_reload_mcp_servers_with_config() {
 }
 
 #[tokio::test]
+#[ignore = "blocked on CLI 1.0.81-6 missing session.mcp.configureGitHub handler"]
 async fn should_configure_github_mcp_server() {
     super::support::with_shared_e2e_context(
         &E2E,