@oxagen/cli 0.4.0 → 0.6.0

package/dist/commands.test.js

@@ -3,7 +3,11 @@ import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
 vi.mock("./lib/config.js", () => ({
     getToken: vi.fn(() => "test-token"),
     getApiUrl: vi.fn(() => "http://localhost:4000"),
-    readConfig: vi.fn(() => ({ token: "test-token", orgSlug: "my-org", workspaceSlug: "default" })),
+    readConfig: vi.fn(() => ({
+        token: "test-token",
+        orgSlug: "my-org",
+        workspaceSlug: "default",
+    })),
     writeConfig: vi.fn(),
     clearConfig: vi.fn(),
     getOrgId: vi.fn(() => "my-org"),
@@ -67,9 +71,9 @@ import { imageListCommand } from "./commands/image.list.js";
 import { imageAnalyzeCommand } from "./commands/image.analyze.js";
 import { documentListCommand } from "./commands/document.list.js";
 import { documentReadCommand } from "./commands/document.read.js";
-import { formCreateCommand } from "./commands/form.create.js";
-import { formSubmitCommand } from "./commands/form.submit.js";
 import { automationCreateCommand } from "./commands/automation.create.js";
+import { automationEnableCommand } from "./commands/automation.enable.js";
+import { automationDisableCommand } from "./commands/automation.disable.js";
 import { automationTriggerCommand } from "./commands/automation.trigger.js";
 import { skillWorkspaceListCommand } from "./commands/skill.workspace.list.js";
 import { agentMemoryRecallCommand } from "./commands/agent.memory.recall.js";
@@ -92,20 +96,16 @@ import { agentTaskBackgroundReadCommand } from "./commands/agent.task.background
 import { agentTaskBackgroundCancelCommand } from "./commands/agent.task.background.cancel.js";
 import { assetUploadCommand } from "./commands/asset.upload.js";
 import { billingSubscriptionUpgradeStartCommand } from "./commands/billing.subscription.upgrade.start.js";
-import { brandkitApplyCommand } from "./commands/brandkit.apply.js";
 import { conversationPurgeCommand } from "./commands/conversation.purge.js";
 import { documentsPdfCreateCommand } from "./commands/documents.pdf.create.js";
 import { formFillCommand } from "./commands/form.fill.js";
 import { orgMemberInviteDeclineCommand } from "./commands/org.member.invite.decline.js";
 import { organizationCreateCommand } from "./commands/organization.create.js";
 import { pluginCredentialSetSecretCommand } from "./commands/plugin.credential.set_secret.js";
-import { pluginDenylistAddCommand } from "./commands/plugin.denylist.add.js";
-import { pluginDenylistRemoveCommand } from "./commands/plugin.denylist.remove.js";
 import { pluginOrgInstallBulkCommand } from "./commands/plugin.org.install_bulk.js";
 import { pluginOrgListCommand } from "./commands/plugin.org.list.js";
 import { pluginOrgSetEnabledCommand } from "./commands/plugin.org.set_enabled.js";
 import { pluginRegistryRemoveCommand } from "./commands/plugin.registry.remove.js";
-import { pluginRegistrySyncCommand } from "./commands/plugin.registry.sync.js";
 import { pluginSettingsSetAuthAlertsCommand } from "./commands/plugin.settings.set_auth_alerts.js";
 import { pluginWorkspaceSetEnabledCommand } from "./commands/plugin.workspace.set_enabled.js";
 import { systemInstallInstructionsCommand } from "./commands/system.install.instructions.js";
@@ -140,7 +140,9 @@ afterEach(() => {
 describe("auth login", () => {
     it("exits 1 if email or password is missing", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation(() => { throw new Error("exit"); });
+        const exitSpy = vi.spyOn(process, "exit").mockImplementation(() => {
+            throw new Error("exit");
+        });
         await expect(() => authLoginCommand.parseAsync(["node", "cli"])).rejects.toThrow("exit");
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("email and password are required"));
         consoleSpy.mockRestore();
@@ -148,8 +150,18 @@ describe("auth login", () => {
     });
     it("calls API with credentials and stores token", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        mockApiRequest.mockResolvedValueOnce({ token: "new-token", user: { email: "user@example.com" } });
-        await authLoginCommand.parseAsync(["node", "cli", "--email", "user@example.com", "--password", "secret"]);
+        mockApiRequest.mockResolvedValueOnce({
+            token: "new-token",
+            user: { email: "user@example.com" },
+        });
+        await authLoginCommand.parseAsync([
+            "node",
+            "cli",
+            "--email",
+            "user@example.com",
+            "--password",
+            "secret",
+        ]);
         expect(mockApiRequest).toHaveBeenCalledWith("/auth/sign-in/email", expect.objectContaining({ method: "POST" }));
         expect(mockWriteConfig).toHaveBeenCalledWith(expect.objectContaining({ token: "new-token" }));
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Authenticated"));
@@ -157,9 +169,18 @@ describe("auth login", () => {
     });
     it("exits 1 on API error during login", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation(() => { throw new Error("exit"); });
+        const exitSpy = vi.spyOn(process, "exit").mockImplementation(() => {
+            throw new Error("exit");
+        });
         mockApiRequest.mockRejectedValueOnce(new Error("Unauthorized"));
-        await expect(() => authLoginCommand.parseAsync(["node", "cli", "--email", "a@b.com", "--password", "pw"])).rejects.toThrow("exit");
+        await expect(() => authLoginCommand.parseAsync([
+            "node",
+            "cli",
+            "--email",
+            "a@b.com",
+            "--password",
+            "pw",
+        ])).rejects.toThrow("exit");
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Error:"));
         consoleSpy.mockRestore();
         exitSpy.mockRestore();
@@ -167,7 +188,14 @@ describe("auth login", () => {
     it("handles response with session.token shape", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
         mockApiRequest.mockResolvedValueOnce({ session: { token: "session-tok" } });
-        await authLoginCommand.parseAsync(["node", "cli", "-e", "a@b.com", "-p", "pw"]);
+        await authLoginCommand.parseAsync([
+            "node",
+            "cli",
+            "-e",
+            "a@b.com",
+            "-p",
+            "pw",
+        ]);
         expect(mockWriteConfig).toHaveBeenCalledWith(expect.objectContaining({ token: "session-tok" }));
         consoleSpy.mockRestore();
     });
@@ -222,15 +250,22 @@ describe("auth whoami", () => {
     });
     it("falls back to config values for org/workspace", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        mockApiRequest.mockResolvedValueOnce({ user: { email: "mac@example.com" } });
-        vi.mocked(config.readConfig).mockReturnValue({ orgSlug: "cfg-org", workspaceSlug: "cfg-ws" });
+        mockApiRequest.mockResolvedValueOnce({
+            user: { email: "mac@example.com" },
+        });
+        vi.mocked(config.readConfig).mockReturnValue({
+            orgSlug: "cfg-org",
+            workspaceSlug: "cfg-ws",
+        });
         await authWhoamiCommand.parseAsync(["node", "cli"]);
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("cfg-org"));
         consoleSpy.mockRestore();
     });
     it("exits 1 on API error", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation(() => { throw new Error("exit"); });
+        const exitSpy = vi.spyOn(process, "exit").mockImplementation(() => {
+            throw new Error("exit");
+        });
         mockApiRequest.mockRejectedValueOnce(new Error("Forbidden"));
         await expect(() => authWhoamiCommand.parseAsync(["node", "cli"])).rejects.toThrow("exit");
         consoleSpy.mockRestore();
@@ -260,7 +295,9 @@ describe("org list", () => {
     });
     it("handles data array shape from API", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        mockApiRequest.mockResolvedValueOnce({ data: [{ id: "id1", slug: "org-1", name: "Org 1" }] });
+        mockApiRequest.mockResolvedValueOnce({
+            data: [{ id: "id1", slug: "org-1", name: "Org 1" }],
+        });
         await orgListCommand.parseAsync(["node", "cli"]);
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("org-1"));
         consoleSpy.mockRestore();
@@ -272,7 +309,9 @@ describe("org list", () => {
 describe("org create", () => {
     it("creates org and prints slug", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        mockApiRequest.mockResolvedValueOnce({ organization: { slug: "new-org", name: "New Org" } });
+        mockApiRequest.mockResolvedValueOnce({
+            organization: { slug: "new-org", name: "New Org" },
+        });
         await orgCreateCommand.parseAsync(["node", "cli", "New Org"]);
         expect(mockApiRequest).toHaveBeenCalledWith("/organizations", expect.objectContaining({ method: "POST" }));
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("new-org"));
@@ -280,7 +319,9 @@ describe("org create", () => {
     });
     it("exits 1 on API error", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation(() => { throw new Error("exit"); });
+        const exitSpy = vi.spyOn(process, "exit").mockImplementation(() => {
+            throw new Error("exit");
+        });
         mockApiRequest.mockRejectedValueOnce(new Error("Conflict"));
         await expect(() => orgCreateCommand.parseAsync(["node", "cli", "Dup"])).rejects.toThrow("exit");
         consoleSpy.mockRestore();
@@ -294,7 +335,13 @@ describe("org member add", () => {
     it("adds member and confirms", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
         mockApiRequest.mockResolvedValueOnce({});
-        await orgMemberAddCommand.parseAsync(["node", "cli", "new@example.com", "--role", "admin"]);
+        await orgMemberAddCommand.parseAsync([
+            "node",
+            "cli",
+            "new@example.com",
+            "--role",
+            "admin",
+        ]);
         expect(mockApiRequest).toHaveBeenCalledWith("/org/members", expect.objectContaining({ method: "POST" }));
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("new@example.com"));
         consoleSpy.mockRestore();
@@ -302,7 +349,13 @@ describe("org member add", () => {
     it("defaults role to member when no --role flag given", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
         mockApiRequest.mockResolvedValueOnce({});
-        await orgMemberAddCommand.parseAsync(["node", "cli", "x@example.com", "--role", "member"]);
+        await orgMemberAddCommand.parseAsync([
+            "node",
+            "cli",
+            "x@example.com",
+            "--role",
+            "member",
+        ]);
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("member"));
         consoleSpy.mockRestore();
     });
@@ -349,7 +402,9 @@ describe("workspace list", () => {
 describe("workspace create", () => {
     it("creates workspace and prints slug", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        mockApiRequest.mockResolvedValueOnce({ workspace: { slug: "my-ws", name: "My WS" } });
+        mockApiRequest.mockResolvedValueOnce({
+            workspace: { slug: "my-ws", name: "My WS" },
+        });
         await workspaceCreateCommand.parseAsync(["node", "cli", "My WS"]);
         expect(mockApiRequest).toHaveBeenCalledWith("/workspaces", expect.objectContaining({ method: "POST" }));
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("my-ws"));
@@ -365,7 +420,10 @@ function makeSseResponse(text) {
     const line = `data: ${JSON.stringify({ type: "text", text })}\n\nevent: done\ndata: [DONE]\n\n`;
     const encoder = new TextEncoder();
     const stream = new ReadableStream({
-        start(c) { c.enqueue(encoder.encode(line)); c.close(); },
+        start(c) {
+            c.enqueue(encoder.encode(line));
+            c.close();
+        },
     });
     return new Response(stream, {
         status: 200,
@@ -379,9 +437,13 @@ function makeErrorResponse(status, message) {
     });
 }
 describe("chat send", () => {
-    afterEach(() => { vi.restoreAllMocks(); });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
     it("sends message and streams response to stdout", async () => {
-        const stdoutSpy = vi.spyOn(process.stdout, "write").mockImplementation(() => true);
+        const stdoutSpy = vi
+            .spyOn(process.stdout, "write")
+            .mockImplementation(() => true);
         vi.spyOn(global, "fetch").mockResolvedValueOnce(makeSseResponse("Hello back!"));
         await chatSendCommand.parseAsync(["node", "cli", "hello"]);
         const written = stdoutSpy.mock.calls.map((c) => String(c[0])).join("");
@@ -389,19 +451,29 @@ describe("chat send", () => {
         stdoutSpy.mockRestore();
     });
     it("passes conversationId when --conversation is provided", async () => {
-        const stdoutSpy = vi.spyOn(process.stdout, "write").mockImplementation(() => true);
+        const stdoutSpy = vi
+            .spyOn(process.stdout, "write")
+            .mockImplementation(() => true);
         let capturedBody = null;
         vi.spyOn(global, "fetch").mockImplementationOnce(async (_url, init) => {
             capturedBody = JSON.parse(init.body);
             return makeSseResponse("ok");
         });
-        await chatSendCommand.parseAsync(["node", "cli", "hi", "--conversation", "cnv_abc"]);
+        await chatSendCommand.parseAsync([
+            "node",
+            "cli",
+            "hi",
+            "--conversation",
+            "cnv_abc",
+        ]);
         expect(capturedBody["conversationId"]).toBe("cnv_abc");
         stdoutSpy.mockRestore();
     });
     it("exits 1 when fetch throws a network error", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation(() => { throw new Error("exit"); });
+        const exitSpy = vi.spyOn(process, "exit").mockImplementation(() => {
+            throw new Error("exit");
+        });
         vi.spyOn(global, "fetch").mockRejectedValueOnce(new Error("ECONNREFUSED"));
         await expect(() => chatSendCommand.parseAsync(["node", "cli", "msg"])).rejects.toThrow("exit");
         consoleSpy.mockRestore();
@@ -409,7 +481,9 @@ describe("chat send", () => {
     });
     it("exits 1 on non-ok HTTP response", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation(() => { throw new Error("exit"); });
+        const exitSpy = vi.spyOn(process, "exit").mockImplementation(() => {
+            throw new Error("exit");
+        });
         vi.spyOn(global, "fetch").mockResolvedValueOnce(makeErrorResponse(503, "Service unavailable"));
         await expect(() => chatSendCommand.parseAsync(["node", "cli", "test"])).rejects.toThrow();
         consoleSpy.mockRestore();
@@ -440,7 +514,14 @@ describe("conversation list", () => {
     it("passes filter and limit params", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
         mockApiRequest.mockResolvedValueOnce({ conversations: [] });
-        await conversationListCommand.parseAsync(["node", "cli", "--filter", "archived", "--limit", "5"]);
+        await conversationListCommand.parseAsync([
+            "node",
+            "cli",
+            "--filter",
+            "archived",
+            "--limit",
+            "5",
+        ]);
         expect(mockApiRequest).toHaveBeenCalledWith(expect.stringContaining("archived"));
         consoleSpy.mockRestore();
     });
@@ -456,7 +537,9 @@ describe("conversation delete", () => {
     });
     it("exits 1 on not found", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation(() => { throw new Error("exit"); });
+        const exitSpy = vi.spyOn(process, "exit").mockImplementation(() => {
+            throw new Error("exit");
+        });
         mockApiRequest.mockRejectedValueOnce(new Error("Not found"));
         await expect(() => conversationDeleteCommand.parseAsync(["node", "cli", "bad"])).rejects.toThrow("exit");
         consoleSpy.mockRestore();
@@ -475,7 +558,12 @@ describe("conversation archive", () => {
     it("unarchives when --unarchive flag is set", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
         mockApiRequest.mockResolvedValueOnce({});
-        await conversationArchiveCommand.parseAsync(["node", "cli", "cnv_abc", "--unarchive"]);
+        await conversationArchiveCommand.parseAsync([
+            "node",
+            "cli",
+            "cnv_abc",
+            "--unarchive",
+        ]);
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("unarchived"));
         consoleSpy.mockRestore();
     });
@@ -484,7 +572,12 @@ describe("conversation rename", () => {
     it("renames conversation", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
         mockApiRequest.mockResolvedValueOnce({});
-        await conversationRenameCommand.parseAsync(["node", "cli", "cnv_abc", "New Title"]);
+        await conversationRenameCommand.parseAsync([
+            "node",
+            "cli",
+            "cnv_abc",
+            "New Title",
+        ]);
         expect(mockApiRequest).toHaveBeenCalledWith("/conversations/cnv_abc/rename", expect.objectContaining({ method: "POST" }));
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("New Title"));
         consoleSpy.mockRestore();
@@ -496,7 +589,10 @@ describe("conversation rename", () => {
 describe("api-key create", () => {
     it("creates API key and displays secret", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        mockApiRequest.mockResolvedValueOnce({ id: "key_123", key: "oxk_abc123secret" });
+        mockApiRequest.mockResolvedValueOnce({
+            id: "key_123",
+            key: "oxk_abc123secret",
+        });
         const origIsTTY = process.stdout.isTTY;
         process.stdout.isTTY = true; // Simulate interactive TTY to show full secret
         await apiKeyCreateCommand.parseAsync(["node", "cli", "my-key"]);
@@ -508,7 +604,9 @@ describe("api-key create", () => {
     });
     it("exits 1 on API error", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation(() => { throw new Error("exit"); });
+        const exitSpy = vi.spyOn(process, "exit").mockImplementation(() => {
+            throw new Error("exit");
+        });
         mockApiRequest.mockRejectedValueOnce(new Error("Quota exceeded"));
         await expect(() => apiKeyCreateCommand.parseAsync(["node", "cli", "key"])).rejects.toThrow("exit");
         consoleSpy.mockRestore();
@@ -534,7 +632,11 @@ describe("notifications list", () => {
         mockApiRequest.mockResolvedValueOnce({
             notifications: [
                 { publicId: "ntf_1", title: "New member joined", readAt: null },
-                { publicId: "ntf_2", title: "Subscription renewed", readAt: "2026-06-01" },
+                {
+                    publicId: "ntf_2",
+                    title: "Subscription renewed",
+                    readAt: "2026-06-01",
+                },
             ],
         });
         await notificationsListCommand.parseAsync(["node", "cli"]);
@@ -569,7 +671,12 @@ describe("notifications mark", () => {
     it("marks notification as unread with --unread flag", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
         mockApiRequest.mockResolvedValueOnce({});
-        await notificationsMarkCommand.parseAsync(["node", "cli", "ntf_1", "--unread"]);
+        await notificationsMarkCommand.parseAsync([
+            "node",
+            "cli",
+            "ntf_1",
+            "--unread",
+        ]);
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("unread"));
         consoleSpy.mockRestore();
     });
@@ -581,7 +688,10 @@ describe("plugin list", () => {
     it("lists installed plugins", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
         mockApiRequest.mockResolvedValueOnce({
-            plugins: [{ pluginId: "github", enabled: true }, { pluginId: "slack", enabled: false }],
+            plugins: [
+                { pluginId: "github", enabled: true },
+                { pluginId: "slack", enabled: false },
+            ],
         });
         await pluginListCommand.parseAsync(["node", "cli"]);
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("github"));
@@ -607,7 +717,9 @@ describe("plugin install", () => {
     });
     it("exits 1 on install failure", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation(() => { throw new Error("exit"); });
+        const exitSpy = vi.spyOn(process, "exit").mockImplementation(() => {
+            throw new Error("exit");
+        });
         mockApiRequest.mockRejectedValueOnce(new Error("Not found in catalog"));
         await expect(() => pluginInstallCommand.parseAsync(["node", "cli", "bad-plugin"])).rejects.toThrow("exit");
         consoleSpy.mockRestore();
@@ -653,7 +765,9 @@ describe("billing status", () => {
     });
     it("exits 1 on API error", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation(() => { throw new Error("exit"); });
+        const exitSpy = vi.spyOn(process, "exit").mockImplementation(() => {
+            throw new Error("exit");
+        });
         mockApiRequest.mockRejectedValueOnce(new Error("Forbidden"));
         await expect(() => billingStatusCommand.parseAsync(["node", "cli"])).rejects.toThrow("exit");
         consoleSpy.mockRestore();
@@ -682,7 +796,9 @@ describe("agent skill list", () => {
     it("lists agent skills successfully", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
         mockApiRequest.mockResolvedValueOnce({
-            skills: [{ id: "skill1", name: "memory", description: "Memory management" }],
+            skills: [
+                { id: "skill1", name: "memory", description: "Memory management" },
+            ],
         });
         await agentSkillListCommand.parseAsync(["node", "cli"]);
         expect(mockApiRequest).toHaveBeenCalledWith(expect.stringContaining("/agent/skill/list"), expect.objectContaining({ method: "GET" }));
@@ -697,7 +813,9 @@ describe("agent tool list", () => {
     it("lists agent tools successfully", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
         mockApiRequest.mockResolvedValueOnce({
-            tools: [{ id: "tool1", name: "search", description: "Search capability" }],
+            tools: [
+                { id: "tool1", name: "search", description: "Search capability" },
+            ],
         });
         await agentToolListCommand.parseAsync(["node", "cli"]);
         expect(mockApiRequest).toHaveBeenCalledWith(expect.stringContaining("/agent/tool/list"), expect.objectContaining({ method: "GET" }));
@@ -715,7 +833,12 @@ describe("billing credits purchase", () => {
             credits: 100,
             totalCost: 10,
         });
-        await billingCreditsPurchaseCommand.parseAsync(["node", "cli", "-a", "100"]);
+        await billingCreditsPurchaseCommand.parseAsync([
+            "node",
+            "cli",
+            "-a",
+            "100",
+        ]);
         expect(mockApiRequest).toHaveBeenCalledWith("/billing/credits/purchase", expect.objectContaining({ method: "POST" }));
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Purchase initiated"));
         consoleSpy.mockRestore();
@@ -763,7 +886,12 @@ describe("plugin org uninstall", () => {
             id: "plugin1",
             status: "uninstalled",
         });
-        await pluginOrgUninstallCommand.parseAsync(["node", "cli", "-p", "plugin1"]);
+        await pluginOrgUninstallCommand.parseAsync([
+            "node",
+            "cli",
+            "-p",
+            "plugin1",
+        ]);
         expect(mockApiRequest).toHaveBeenCalledWith("/plugin/org/uninstall", expect.objectContaining({ method: "POST" }));
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Plugin uninstalled"));
         consoleSpy.mockRestore();
@@ -776,7 +904,14 @@ describe("plugin catalog get", () => {
     it("browses plugin catalog", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
         mockApiRequest.mockResolvedValueOnce({
-            plugins: [{ id: "p1", name: "github", description: "GitHub integration", category: "vcs" }],
+            plugins: [
+                {
+                    id: "p1",
+                    name: "github",
+                    description: "GitHub integration",
+                    category: "vcs",
+                },
+            ],
         });
         await pluginCatalogGetCommand.parseAsync(["node", "cli"]);
         expect(mockApiRequest).toHaveBeenCalledWith("/plugin/catalog/get?", expect.objectContaining({ method: "GET" }));
@@ -795,7 +930,14 @@ describe("org member role change", () => {
             role: "admin",
             updated: true,
         });
-        await orgMemberRoleChangeCommand.parseAsync(["node", "cli", "-u", "user1", "-r", "admin"]);
+        await orgMemberRoleChangeCommand.parseAsync([
+            "node",
+            "cli",
+            "-u",
+            "user1",
+            "-r",
+            "admin",
+        ]);
         expect(mockApiRequest).toHaveBeenCalledWith("/org/member/role-change", expect.objectContaining({ method: "POST" }));
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Role updated"));
         consoleSpy.mockRestore();
@@ -808,14 +950,30 @@ describe("agent approval resolve", () => {
     it("resolves approval with approve decision", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
         mockApiRequest.mockResolvedValueOnce({ id: "apr1", status: "approved" });
-        await agentApprovalResolveCommand.parseAsync(["node", "cli", "-a", "apr1", "-d", "approve"]);
+        await agentApprovalResolveCommand.parseAsync([
+            "node",
+            "cli",
+            "-a",
+            "apr1",
+            "-d",
+            "approve",
+        ]);
         expect(mockApiRequest).toHaveBeenCalledWith("/agent/approval/resolve", expect.objectContaining({ method: "POST" }));
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("approved"));
         consoleSpy.mockRestore();
     });
     it("rejects invalid decision", async () => {
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation(() => { throw new Error("exit"); });
-        await expect(() => agentApprovalResolveCommand.parseAsync(["node", "cli", "-a", "apr1", "-d", "invalid"])).rejects.toThrow();
+        const exitSpy = vi.spyOn(process, "exit").mockImplementation(() => {
+            throw new Error("exit");
+        });
+        await expect(() => agentApprovalResolveCommand.parseAsync([
+            "node",
+            "cli",
+            "-a",
+            "apr1",
+            "-d",
+            "invalid",
+        ])).rejects.toThrow();
         exitSpy.mockRestore();
     });
 });
@@ -825,8 +983,19 @@ describe("agent approval resolve", () => {
 describe("archive create", () => {
     it("creates archive from conversation", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        mockApiRequest.mockResolvedValueOnce({ id: "arc1", name: "Archive 1", status: "created" });
-        await archiveCreateCommand.parseAsync(["node", "cli", "-c", "conv1", "-n", "My Archive"]);
+        mockApiRequest.mockResolvedValueOnce({
+            id: "arc1",
+            name: "Archive 1",
+            status: "created",
+        });
+        await archiveCreateCommand.parseAsync([
+            "node",
+            "cli",
+            "-c",
+            "conv1",
+            "-n",
+            "My Archive",
+        ]);
         expect(mockApiRequest).toHaveBeenCalledWith("/archive/create", expect.objectContaining({ method: "POST" }));
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Archive created"));
         consoleSpy.mockRestore();
@@ -839,7 +1008,14 @@ describe("workflow run", () => {
     it("runs workflow with input", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
         mockApiRequest.mockResolvedValueOnce({ id: "run1", status: "started" });
-        await workflowRunCommand.parseAsync(["node", "cli", "-w", "wf1", "--input", '{"key":"value"}']);
+        await workflowRunCommand.parseAsync([
+            "node",
+            "cli",
+            "-w",
+            "wf1",
+            "--input",
+            '{"key":"value"}',
+        ]);
         expect(mockApiRequest).toHaveBeenCalledWith("/workflow/run", expect.objectContaining({ method: "POST" }));
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("started"));
         consoleSpy.mockRestore();
@@ -862,7 +1038,12 @@ describe("user preferences update", () => {
     it("updates user preferences", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
         mockApiRequest.mockResolvedValueOnce({ theme: "light" });
-        await userPreferencesUpdateCommand.parseAsync(["node", "cli", "-t", "light"]);
+        await userPreferencesUpdateCommand.parseAsync([
+            "node",
+            "cli",
+            "-t",
+            "light",
+        ]);
         expect(mockApiRequest).toHaveBeenCalledWith("/user/preferences/update", expect.objectContaining({ method: "POST" }));
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("light"));
         consoleSpy.mockRestore();
@@ -874,7 +1055,14 @@ describe("user preferences update", () => {
 describe("workspace member list", () => {
     it("lists workspace members", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        mockApiRequest.mockResolvedValueOnce([{ id: "m1", email: "user@example.com", role: "member", joined_at: "2026-06-08" }]);
+        mockApiRequest.mockResolvedValueOnce([
+            {
+                id: "m1",
+                email: "user@example.com",
+                role: "member",
+                joined_at: "2026-06-08",
+            },
+        ]);
         await workspaceMemberListCommand.parseAsync(["node", "cli"]);
         expect(mockApiRequest).toHaveBeenCalled();
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("member(s)"));
@@ -885,7 +1073,12 @@ describe("workspace invite send", () => {
     it("sends workspace invitation", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
         mockApiRequest.mockResolvedValueOnce({ id: "inv1", status: "sent" });
-        await workspaceInviteSendCommand.parseAsync(["node", "cli", "-e", "user@example.com"]);
+        await workspaceInviteSendCommand.parseAsync([
+            "node",
+            "cli",
+            "-e",
+            "user@example.com",
+        ]);
         expect(mockApiRequest).toHaveBeenCalledWith("/workspace/invite/send", expect.objectContaining({ method: "POST" }));
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Invitation sent"));
         consoleSpy.mockRestore();
@@ -897,8 +1090,18 @@ describe("workspace invite send", () => {
 describe("conversation chat", () => {
     it("sends chat message", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        mockApiRequest.mockResolvedValueOnce({ id: "msg1", created_at: "2026-06-08T00:00:00Z" });
-        await conversationChatCommand.parseAsync(["node", "cli", "-c", "conv1", "-m", "Hello"]);
+        mockApiRequest.mockResolvedValueOnce({
+            id: "msg1",
+            created_at: "2026-06-08T00:00:00Z",
+        });
+        await conversationChatCommand.parseAsync([
+            "node",
+            "cli",
+            "-c",
+            "conv1",
+            "-m",
+            "Hello",
+        ]);
         expect(mockApiRequest).toHaveBeenCalledWith("/conversation/chat", expect.objectContaining({ method: "POST" }));
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Message sent"));
         consoleSpy.mockRestore();
@@ -910,7 +1113,10 @@ describe("conversation chat", () => {
 describe("image create", () => {
     it("creates image from prompt", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        mockApiRequest.mockResolvedValueOnce({ id: "img1", url: "https://example.com/img1.jpg" });
+        mockApiRequest.mockResolvedValueOnce({
+            id: "img1",
+            url: "https://example.com/img1.jpg",
+        });
         await imageCreateCommand.parseAsync(["node", "cli", "-p", "A blue sky"]);
         expect(mockApiRequest).toHaveBeenCalledWith("/image/create", expect.objectContaining({ method: "POST" }));
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Image created"));
@@ -920,7 +1126,16 @@ describe("image create", () => {
 describe("image list", () => {
     it("lists images", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        mockApiRequest.mockResolvedValueOnce({ images: [{ id: "img1", url: "https://example.com/img1.jpg", prompt: "Blue sky", created_at: "2026-06-08" }] });
+        mockApiRequest.mockResolvedValueOnce({
+            images: [
+                {
+                    id: "img1",
+                    url: "https://example.com/img1.jpg",
+                    prompt: "Blue sky",
+                    created_at: "2026-06-08",
+                },
+            ],
+        });
         await imageListCommand.parseAsync(["node", "cli"]);
         expect(mockApiRequest).toHaveBeenCalled();
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Images"));
@@ -930,7 +1145,10 @@ describe("image list", () => {
 describe("image analyze", () => {
     it("analyzes image", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        mockApiRequest.mockResolvedValueOnce({ analysis: "sky", tags: ["nature", "outdoor"] });
+        mockApiRequest.mockResolvedValueOnce({
+            analysis: "sky",
+            tags: ["nature", "outdoor"],
+        });
         await imageAnalyzeCommand.parseAsync(["node", "cli", "-i", "img1"]);
         expect(mockApiRequest).toHaveBeenCalledWith("/image/analyze", expect.objectContaining({ method: "POST" }));
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Analysis"));
@@ -953,7 +1171,17 @@ describe("document create", () => {
 describe("document list", () => {
     it("lists documents", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        mockApiRequest.mockResolvedValueOnce({ documents: [{ id: "doc1", title: "Doc 1", created_at: "2026-06-08", updated_at: "2026-06-08", author: "user" }] });
+        mockApiRequest.mockResolvedValueOnce({
+            documents: [
+                {
+                    id: "doc1",
+                    title: "Doc 1",
+                    created_at: "2026-06-08",
+                    updated_at: "2026-06-08",
+                    author: "user",
+                },
+            ],
+        });
         await documentListCommand.parseAsync(["node", "cli"]);
         expect(mockApiRequest).toHaveBeenCalled();
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Documents"));
@@ -963,7 +1191,12 @@ describe("document list", () => {
 describe("document read", () => {
     it("reads document", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        mockApiRequest.mockResolvedValueOnce({ title: "Doc 1", content: "Content...", metadata: {}, created_at: "2026-06-08" });
+        mockApiRequest.mockResolvedValueOnce({
+            title: "Doc 1",
+            content: "Content...",
+            metadata: {},
+            created_at: "2026-06-08",
+        });
         await documentReadCommand.parseAsync(["node", "cli", "-d", "doc1"]);
         expect(mockApiRequest).toHaveBeenCalled();
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Title:"));
@@ -971,35 +1204,14 @@ describe("document read", () => {
     });
 });
 // ---------------------------------------------------------------------------
-// form management
-// ---------------------------------------------------------------------------
-describe("form create", () => {
-    it("creates form", async () => {
-        const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        mockApiRequest.mockResolvedValueOnce({ id: "form1", title: "Survey" });
-        await formCreateCommand.parseAsync(["node", "cli", "-t", "Survey"]);
-        expect(mockApiRequest).toHaveBeenCalledWith("/form/create", expect.objectContaining({ method: "POST" }));
-        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Form created"));
-        consoleSpy.mockRestore();
-    });
-});
-describe("form submit", () => {
-    it("submits form", async () => {
-        const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        mockApiRequest.mockResolvedValueOnce({ id: "sub1", status: "submitted" });
-        await formSubmitCommand.parseAsync(["node", "cli", "-f", "form1"]);
-        expect(mockApiRequest).toHaveBeenCalledWith("/form/submit", expect.objectContaining({ method: "POST" }));
-        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("submitted"));
-        consoleSpy.mockRestore();
-    });
-});
-// ---------------------------------------------------------------------------
 // automation management
 // ---------------------------------------------------------------------------
 describe("automation list", () => {
     it("lists automations", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        mockApiRequest.mockResolvedValueOnce([{ id: "auto1", name: "Auto 1", status: "active", triggers: ["event1"] }]);
+        mockApiRequest.mockResolvedValueOnce([
+            { id: "auto1", name: "Auto 1", status: "active", triggers: ["event1"] },
+        ]);
         await automationListCommand.parseAsync(["node", "cli"]);
         expect(mockApiRequest).toHaveBeenCalled();
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("automation(s)"));
@@ -1007,14 +1219,138 @@ describe("automation list", () => {
     });
 });
 describe("automation create", () => {
-    it("creates automation", async () => {
+    it("creates automation with the contract payload shape", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        mockApiRequest.mockResolvedValueOnce({ id: "auto1", name: "My Automation" });
-        await automationCreateCommand.parseAsync(["node", "cli", "-n", "My Automation"]);
+        mockApiRequest.mockResolvedValueOnce({
+            automation_id: "plt_1",
+            playbook_id: "plb_1",
+            name: "My Automation",
+            status: "inactive",
+            triggerType: "api",
+            enabled: false,
+        });
+        await automationCreateCommand.parseAsync([
+            "node",
+            "cli",
+            "-n",
+            "My Automation",
+        ]);
         expect(mockApiRequest).toHaveBeenCalledWith("/automation/create", expect.objectContaining({ method: "POST" }));
+        const body = JSON.parse((mockApiRequest.mock.calls[0]?.[1]).body);
+        expect(body).toMatchObject({
+            name: "My Automation",
+            triggerType: "api",
+            triggerConfig: {},
+            steps: [],
+            enabled: false,
+        });
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Automation created"));
         consoleSpy.mockRestore();
     });
+    it("builds event triggerConfig from --entity-type/--event-type/--conditions and passes --enabled", async () => {
+        const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
+        mockApiRequest.mockResolvedValueOnce({
+            automation_id: "plt_2",
+            playbook_id: "plb_2",
+            name: "Watcher",
+            status: "active",
+            triggerType: "event",
+            enabled: true,
+        });
+        await automationCreateCommand.parseAsync([
+            "node",
+            "cli",
+            "-n",
+            "Watcher",
+            "--trigger-type",
+            "event",
+            "--entity-type",
+            "Contact",
+            "--event-type",
+            "node.updated",
+            "--conditions",
+            '[{"property":"status","toValue":"customer","operator":"eq"}]',
+            "--enabled",
+        ]);
+        const body = JSON.parse((mockApiRequest.mock.calls[0]?.[1]).body);
+        expect(body).toMatchObject({
+            name: "Watcher",
+            triggerType: "event",
+            triggerConfig: {
+                entityType: "Contact",
+                eventType: "node.updated",
+                propertyConditions: [
+                    { property: "status", toValue: "customer", operator: "eq" },
+                ],
+            },
+            enabled: true,
+        });
+        consoleSpy.mockRestore();
+    });
+    it("builds schedule triggerConfig from --cron/--timezone", async () => {
+        const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
+        mockApiRequest.mockResolvedValueOnce({
+            automation_id: "plt_3",
+            playbook_id: "plb_3",
+            name: "Report",
+            status: "inactive",
+            triggerType: "schedule",
+            enabled: false,
+        });
+        await automationCreateCommand.parseAsync([
+            "node",
+            "cli",
+            "-n",
+            "Report",
+            "--trigger-type",
+            "schedule",
+            "--cron",
+            "0 9 * * 1",
+            "--timezone",
+            "America/New_York",
+        ]);
+        const body = JSON.parse((mockApiRequest.mock.calls[0]?.[1]).body);
+        expect(body).toMatchObject({
+            triggerType: "schedule",
+            triggerConfig: {
+                cronExpression: "0 9 * * 1",
+                timezone: "America/New_York",
+            },
+        });
+        consoleSpy.mockRestore();
+    });
+});
+describe("automation enable", () => {
+    it("enables automation", async () => {
+        const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
+        mockApiRequest.mockResolvedValueOnce({
+            automation_id: "plt_1",
+            enabled: true,
+            status: "active",
+        });
+        await automationEnableCommand.parseAsync(["node", "cli", "plt_1"]);
+        expect(mockApiRequest).toHaveBeenCalledWith("/automation/enable", expect.objectContaining({ method: "POST" }));
+        const body = JSON.parse((mockApiRequest.mock.calls[0]?.[1]).body);
+        expect(body).toEqual({ automation_id: "plt_1" });
+        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Automation enabled"));
+        consoleSpy.mockRestore();
+    });
+});
+describe("automation disable", () => {
+    it("disables automation", async () => {
+        const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
+        mockApiRequest.mockResolvedValueOnce({
+            automation_id: "plt_1",
+            enabled: false,
+            status: "paused",
+        });
+        await automationDisableCommand.parseAsync(["node", "cli", "plt_1"]);
+        expect(mockApiRequest).toHaveBeenCalledWith("/automation/disable", expect.objectContaining({ method: "POST" }));
+        const body = JSON.parse((mockApiRequest.mock.calls[0]?.[1]).body);
+        expect(body).toEqual({ automation_id: "plt_1" });
+        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Automation disabled"));
+        consoleSpy.mockRestore();
+    });
 });
 describe("automation trigger", () => {
     it("triggers automation", async () => {
@@ -1032,7 +1368,16 @@ describe("automation trigger", () => {
 describe("skill workspace list", () => {
     it("lists workspace skills", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        mockApiRequest.mockResolvedValueOnce({ skills: [{ id: "skill1", name: "Research", enabled: true, description: "Research skill" }] });
+        mockApiRequest.mockResolvedValueOnce({
+            skills: [
+                {
+                    id: "skill1",
+                    name: "Research",
+                    enabled: true,
+                    description: "Research skill",
+                },
+            ],
+        });
         await skillWorkspaceListCommand.parseAsync(["node", "cli"]);
         expect(mockApiRequest).toHaveBeenCalled();
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Workspace skills"));
@@ -1045,18 +1390,40 @@ describe("skill workspace list", () => {
 describe("agent memory recall", () => {
     it("recalls memory observations", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        const mockResult = { observations: [{ id: "obs1", text: "User prefers dark mode", score: 0.9 }] };
+        const mockResult = {
+            observations: [
+                { id: "obs1", text: "User prefers dark mode", score: 0.9 },
+            ],
+        };
         mockApiRequest.mockResolvedValueOnce(mockResult);
-        await agentMemoryRecallCommand.parseAsync(["node", "cli", "-a", "agent1", "-q", "user preferences"]);
+        await agentMemoryRecallCommand.parseAsync([
+            "node",
+            "cli",
+            "-a",
+            "agent1",
+            "-q",
+            "user preferences",
+        ]);
         expect(mockApiRequest).toHaveBeenCalledWith("/agent/memory/recall", expect.objectContaining({ method: "POST" }));
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("obs1"));
         consoleSpy.mockRestore();
     });
     it("handles recall failure", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("process.exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("process.exit");
+        });
         mockApiRequest.mockRejectedValueOnce(new Error("Network error"));
-        await expect(agentMemoryRecallCommand.parseAsync(["node", "cli", "-a", "agent1", "-q", "query"])).rejects.toThrow();
+        await expect(agentMemoryRecallCommand.parseAsync([
+            "node",
+            "cli",
+            "-a",
+            "agent1",
+            "-q",
+            "query",
+        ])).rejects.toThrow();
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Failed to recall"), expect.any(Error));
         consoleSpy.mockRestore();
         exitSpy.mockRestore();
@@ -1067,7 +1434,14 @@ describe("agent memory write", () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
         const mockResult = { id: "obs2", status: "stored" };
         mockApiRequest.mockResolvedValueOnce(mockResult);
-        await agentMemoryWriteCommand.parseAsync(["node", "cli", "-a", "agent1", "-t", "User prefers TypeScript"]);
+        await agentMemoryWriteCommand.parseAsync([
+            "node",
+            "cli",
+            "-a",
+            "agent1",
+            "-t",
+            "User prefers TypeScript",
+        ]);
         expect(mockApiRequest).toHaveBeenCalledWith("/agent/memory/write", expect.objectContaining({ method: "POST" }));
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("obs2"));
         consoleSpy.mockRestore();
@@ -1075,16 +1449,36 @@ describe("agent memory write", () => {
     it("writes a memory observation with tags", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
         mockApiRequest.mockResolvedValueOnce({ id: "obs3", status: "stored" });
-        await agentMemoryWriteCommand.parseAsync(["node", "cli", "-a", "agent1", "-t", "Uses dark mode", "--tags", "ui,preferences"]);
+        await agentMemoryWriteCommand.parseAsync([
+            "node",
+            "cli",
+            "-a",
+            "agent1",
+            "-t",
+            "Uses dark mode",
+            "--tags",
+            "ui,preferences",
+        ]);
         const callBody = JSON.parse(mockApiRequest.mock.calls[0][1].body);
         expect(callBody.tags).toEqual(["ui", "preferences"]);
         consoleSpy.mockRestore();
     });
     it("handles write failure", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("process.exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("process.exit");
+        });
         mockApiRequest.mockRejectedValueOnce(new Error("Network error"));
-        await expect(agentMemoryWriteCommand.parseAsync(["node", "cli", "-a", "agent1", "-t", "text"])).rejects.toThrow();
+        await expect(agentMemoryWriteCommand.parseAsync([
+            "node",
+            "cli",
+            "-a",
+            "agent1",
+            "-t",
+            "text",
+        ])).rejects.toThrow();
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Failed to write"), expect.any(Error));
         consoleSpy.mockRestore();
         exitSpy.mockRestore();
@@ -1096,26 +1490,59 @@ describe("agent memory write", () => {
 describe("documents generate", () => {
     it("generates a document from template", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        const mockResult = { id: "doc1", status: "complete", url: "https://example.com/doc.pdf" };
+        const mockResult = {
+            id: "doc1",
+            status: "complete",
+            url: "https://example.com/doc.pdf",
+        };
         mockApiRequest.mockResolvedValueOnce(mockResult);
-        await documentsGenerateCommand.parseAsync(["node", "cli", "-t", "report", "-c", '{"title":"Q1 Report"}']);
+        await documentsGenerateCommand.parseAsync([
+            "node",
+            "cli",
+            "-t",
+            "report",
+            "-c",
+            '{"title":"Q1 Report"}',
+        ]);
         expect(mockApiRequest).toHaveBeenCalledWith("/documents/generate", expect.objectContaining({ method: "POST" }));
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("doc1"));
         consoleSpy.mockRestore();
     });
     it("fails on invalid JSON context", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("process.exit"); });
-        await expect(documentsGenerateCommand.parseAsync(["node", "cli", "-t", "report", "-c", "not-json"])).rejects.toThrow();
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("process.exit");
+        });
+        await expect(documentsGenerateCommand.parseAsync([
+            "node",
+            "cli",
+            "-t",
+            "report",
+            "-c",
+            "not-json",
+        ])).rejects.toThrow();
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Invalid JSON"), expect.anything());
         consoleSpy.mockRestore();
         exitSpy.mockRestore();
     });
     it("handles generate failure", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("process.exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("process.exit");
+        });
         mockApiRequest.mockRejectedValueOnce(new Error("Template not found"));
-        await expect(documentsGenerateCommand.parseAsync(["node", "cli", "-t", "report", "-c", '{}'])).rejects.toThrow();
+        await expect(documentsGenerateCommand.parseAsync([
+            "node",
+            "cli",
+            "-t",
+            "report",
+            "-c",
+            "{}",
+        ])).rejects.toThrow();
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Failed to generate"), expect.any(Error));
         consoleSpy.mockRestore();
         exitSpy.mockRestore();
@@ -1129,14 +1556,23 @@ describe("image generate", () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
         const mockResult = { url: "https://example.com/img.png", id: "img1" };
         mockApiRequest.mockResolvedValueOnce(mockResult);
-        await imageGenerateCommand.parseAsync(["node", "cli", "-p", "A sunset over the ocean"]);
+        await imageGenerateCommand.parseAsync([
+            "node",
+            "cli",
+            "-p",
+            "A sunset over the ocean",
+        ]);
         expect(mockApiRequest).toHaveBeenCalledWith("/image/generate", expect.objectContaining({ method: "POST" }));
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("img1"));
         consoleSpy.mockRestore();
     });
     it("handles generate failure", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("process.exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("process.exit");
+        });
         mockApiRequest.mockRejectedValueOnce(new Error("Model not found"));
         await expect(imageGenerateCommand.parseAsync(["node", "cli", "-p", "a cat"])).rejects.toThrow();
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Failed to generate"), expect.any(Error));
@@ -1150,15 +1586,27 @@ describe("image generate", () => {
 describe("org member invite accept", () => {
     it("accepts an invitation", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        mockApiRequest.mockResolvedValueOnce({ status: "accepted", orgSlug: "my-org" });
-        await orgMemberInviteAcceptCommand.parseAsync(["node", "cli", "-i", "invite123"]);
+        mockApiRequest.mockResolvedValueOnce({
+            status: "accepted",
+            orgSlug: "my-org",
+        });
+        await orgMemberInviteAcceptCommand.parseAsync([
+            "node",
+            "cli",
+            "-i",
+            "invite123",
+        ]);
         expect(mockApiRequest).toHaveBeenCalledWith("/org/member/invite/accept", expect.objectContaining({ method: "POST" }));
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("accepted"));
         consoleSpy.mockRestore();
     });
     it("handles accept failure", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("process.exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("process.exit");
+        });
         mockApiRequest.mockRejectedValueOnce(new Error("Invitation expired"));
         await expect(orgMemberInviteAcceptCommand.parseAsync(["node", "cli", "-i", "inv1"])).rejects.toThrow();
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Failed to accept"), expect.any(Error));
@@ -1172,7 +1620,10 @@ describe("org member invite accept", () => {
 describe("plugin catalog browse", () => {
     it("browses the plugin catalog", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        const mockResult = { plugins: [{ id: "p1", name: "Slack", category: "messaging" }], total: 1 };
+        const mockResult = {
+            plugins: [{ id: "p1", name: "Slack", category: "messaging" }],
+            total: 1,
+        };
         mockApiRequest.mockResolvedValueOnce(mockResult);
         await pluginCatalogBrowseCommand.parseAsync(["node", "cli"]);
         expect(mockApiRequest).toHaveBeenCalledWith("/plugin/catalog/browse", expect.objectContaining({ method: "GET" }));
@@ -1181,7 +1632,11 @@ describe("plugin catalog browse", () => {
     });
     it("handles browse failure", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("process.exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("process.exit");
+        });
         mockApiRequest.mockRejectedValueOnce(new Error("Service unavailable"));
         await expect(pluginCatalogBrowseCommand.parseAsync(["node", "cli"])).rejects.toThrow();
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Failed to browse"), expect.any(Error));
@@ -1195,15 +1650,27 @@ describe("plugin catalog browse", () => {
 describe("plugin credential reauth", () => {
     it("re-authenticates plugin credentials", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        mockApiRequest.mockResolvedValueOnce({ status: "reauthenticated", pluginId: "slack" });
-        await pluginCredentialReauthCommand.parseAsync(["node", "cli", "-p", "slack"]);
+        mockApiRequest.mockResolvedValueOnce({
+            status: "reauthenticated",
+            pluginId: "slack",
+        });
+        await pluginCredentialReauthCommand.parseAsync([
+            "node",
+            "cli",
+            "-p",
+            "slack",
+        ]);
         expect(mockApiRequest).toHaveBeenCalledWith("/plugin/credential/reauth", expect.objectContaining({ method: "POST" }));
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("reauthenticated"));
         consoleSpy.mockRestore();
     });
     it("handles reauth failure", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("process.exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("process.exit");
+        });
         mockApiRequest.mockRejectedValueOnce(new Error("OAuth error"));
         await expect(pluginCredentialReauthCommand.parseAsync(["node", "cli", "-p", "slack"])).rejects.toThrow();
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Failed to re-authenticate"), expect.any(Error));
@@ -1217,7 +1684,11 @@ describe("plugin credential reauth", () => {
 describe("plugin registry list", () => {
     it("lists plugin registries", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        mockApiRequest.mockResolvedValueOnce({ registries: [{ id: "reg1", name: "Official", url: "https://registry.oxagen.ai" }] });
+        mockApiRequest.mockResolvedValueOnce({
+            registries: [
+                { id: "reg1", name: "Official", url: "https://registry.oxagen.ai" },
+            ],
+        });
         await pluginRegistryListCommand.parseAsync(["node", "cli"]);
         expect(mockApiRequest).toHaveBeenCalledWith("/plugin/registry/list", expect.objectContaining({ method: "GET" }));
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Official"));
@@ -1225,7 +1696,11 @@ describe("plugin registry list", () => {
     });
     it("handles list failure", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("process.exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("process.exit");
+        });
         mockApiRequest.mockRejectedValueOnce(new Error("Network error"));
         await expect(pluginRegistryListCommand.parseAsync(["node", "cli"])).rejects.toThrow();
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Failed to list"), expect.any(Error));
@@ -1236,17 +1711,39 @@ describe("plugin registry list", () => {
 describe("plugin registry add", () => {
     it("adds a plugin registry", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        mockApiRequest.mockResolvedValueOnce({ id: "reg2", name: "Private", url: "https://private.example.com" });
-        await pluginRegistryAddCommand.parseAsync(["node", "cli", "-n", "Private", "-u", "https://private.example.com"]);
+        mockApiRequest.mockResolvedValueOnce({
+            id: "reg2",
+            name: "Private",
+            url: "https://private.example.com",
+        });
+        await pluginRegistryAddCommand.parseAsync([
+            "node",
+            "cli",
+            "-n",
+            "Private",
+            "-u",
+            "https://private.example.com",
+        ]);
         expect(mockApiRequest).toHaveBeenCalledWith("/plugin/registry/add", expect.objectContaining({ method: "POST" }));
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("reg2"));
         consoleSpy.mockRestore();
     });
     it("handles add failure", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("process.exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("process.exit");
+        });
         mockApiRequest.mockRejectedValueOnce(new Error("Registry already exists"));
-        await expect(pluginRegistryAddCommand.parseAsync(["node", "cli", "-n", "Private", "-u", "https://x.com"])).rejects.toThrow();
+        await expect(pluginRegistryAddCommand.parseAsync([
+            "node",
+            "cli",
+            "-n",
+            "Private",
+            "-u",
+            "https://x.com",
+        ])).rejects.toThrow();
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Failed to add"), expect.any(Error));
         consoleSpy.mockRestore();
         exitSpy.mockRestore();
@@ -1266,7 +1763,11 @@ describe("svg generate", () => {
     });
     it("handles generate failure", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("process.exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("process.exit");
+        });
         mockApiRequest.mockRejectedValueOnce(new Error("Generation failed"));
         await expect(svgGenerateCommand.parseAsync(["node", "cli", "-d", "circle"])).rejects.toThrow();
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Failed to generate"), expect.any(Error));
@@ -1280,15 +1781,28 @@ describe("svg generate", () => {
 describe("video generate", () => {
     it("generates a video", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        mockApiRequest.mockResolvedValueOnce({ id: "vid1", status: "processing", url: null });
-        await videoGenerateCommand.parseAsync(["node", "cli", "-p", "A flying eagle"]);
+        mockApiRequest.mockResolvedValueOnce({
+            id: "vid1",
+            status: "processing",
+            url: null,
+        });
+        await videoGenerateCommand.parseAsync([
+            "node",
+            "cli",
+            "-p",
+            "A flying eagle",
+        ]);
         expect(mockApiRequest).toHaveBeenCalledWith("/video/generate", expect.objectContaining({ method: "POST" }));
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("vid1"));
         consoleSpy.mockRestore();
     });
     it("handles generate failure", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("process.exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("process.exit");
+        });
         mockApiRequest.mockRejectedValueOnce(new Error("Model not available"));
         await expect(videoGenerateCommand.parseAsync(["node", "cli", "-p", "a cat"])).rejects.toThrow();
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Failed to generate"), expect.any(Error));
@@ -1302,7 +1816,10 @@ describe("video generate", () => {
 describe("workspace model settings read", () => {
     it("reads workspace model settings", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        mockApiRequest.mockResolvedValueOnce({ defaultModel: "claude-haiku-4-5-20251001", maxTokens: 4096 });
+        mockApiRequest.mockResolvedValueOnce({
+            defaultModel: "claude-haiku-4-5-20251001",
+            maxTokens: 4096,
+        });
         await workspaceModelSettingsReadCommand.parseAsync(["node", "cli"]);
         expect(mockApiRequest).toHaveBeenCalledWith("/workspace/model-settings/read", expect.objectContaining({ method: "POST" }));
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("defaultModel"));
@@ -1310,7 +1827,11 @@ describe("workspace model settings read", () => {
     });
     it("handles read failure", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("process.exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("process.exit");
+        });
         mockApiRequest.mockRejectedValueOnce(new Error("Workspace not found"));
         await expect(workspaceModelSettingsReadCommand.parseAsync(["node", "cli"])).rejects.toThrow();
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Failed to read"), expect.any(Error));
@@ -1321,17 +1842,39 @@ describe("workspace model settings read", () => {
 describe("workspace model settings write", () => {
     it("writes workspace model settings", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        mockApiRequest.mockResolvedValueOnce({ success: true, key: "defaultModel", value: "claude-sonnet-4-6" });
-        await workspaceModelSettingsWriteCommand.parseAsync(["node", "cli", "-k", "defaultModel", "-v", "claude-sonnet-4-6"]);
+        mockApiRequest.mockResolvedValueOnce({
+            success: true,
+            key: "defaultModel",
+            value: "claude-sonnet-4-6",
+        });
+        await workspaceModelSettingsWriteCommand.parseAsync([
+            "node",
+            "cli",
+            "-k",
+            "defaultModel",
+            "-v",
+            "claude-sonnet-4-6",
+        ]);
         expect(mockApiRequest).toHaveBeenCalledWith("/workspace/model-settings/write", expect.objectContaining({ method: "POST" }));
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("defaultModel"));
         consoleSpy.mockRestore();
     });
     it("handles write failure", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("process.exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("process.exit");
+        });
         mockApiRequest.mockRejectedValueOnce(new Error("Invalid setting key"));
-        await expect(workspaceModelSettingsWriteCommand.parseAsync(["node", "cli", "-k", "badKey", "-v", "value"])).rejects.toThrow();
+        await expect(workspaceModelSettingsWriteCommand.parseAsync([
+            "node",
+            "cli",
+            "-k",
+            "badKey",
+            "-v",
+            "value",
+        ])).rejects.toThrow();
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Failed to write"), expect.any(Error));
         consoleSpy.mockRestore();
         exitSpy.mockRestore();
@@ -1343,17 +1886,43 @@ describe("workspace model settings write", () => {
 describe("agent mcp register", () => {
     it("registers an MCP server", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        mockApiRequest.mockResolvedValueOnce({ mcpServerId: "mcp1", healthStatus: "healthy", discoveredTools: ["tool1", "tool2"] });
-        await agentMcpRegisterCommand.parseAsync(["node", "cli", "-n", "My MCP", "-u", "https://mcp.example.com", "-t", "streamable-http"]);
+        mockApiRequest.mockResolvedValueOnce({
+            mcpServerId: "mcp1",
+            healthStatus: "healthy",
+            discoveredTools: ["tool1", "tool2"],
+        });
+        await agentMcpRegisterCommand.parseAsync([
+            "node",
+            "cli",
+            "-n",
+            "My MCP",
+            "-u",
+            "https://mcp.example.com",
+            "-t",
+            "streamable-http",
+        ]);
         expect(mockApiRequest).toHaveBeenCalledWith("/agent/mcp/register", expect.objectContaining({ method: "POST" }));
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("mcp1"));
         consoleSpy.mockRestore();
     });
     it("handles registration failure", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("process.exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("process.exit");
+        });
         mockApiRequest.mockRejectedValueOnce(new Error("Bad URL"));
-        await expect(agentMcpRegisterCommand.parseAsync(["node", "cli", "-n", "M", "-u", "http://x", "-t", "stdio"])).rejects.toThrow();
+        await expect(agentMcpRegisterCommand.parseAsync([
+            "node",
+            "cli",
+            "-n",
+            "M",
+            "-u",
+            "http://x",
+            "-t",
+            "stdio",
+        ])).rejects.toThrow();
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Error:"));
         consoleSpy.mockRestore();
         exitSpy.mockRestore();
@@ -1365,17 +1934,38 @@ describe("agent mcp register", () => {
 describe("agent plan approve", () => {
     it("approves a plan", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        mockApiRequest.mockResolvedValueOnce({ planId: "plan1", status: "approved" });
-        await agentPlanApproveCommand.parseAsync(["node", "cli", "-p", "plan1", "-d", "approve"]);
+        mockApiRequest.mockResolvedValueOnce({
+            planId: "plan1",
+            status: "approved",
+        });
+        await agentPlanApproveCommand.parseAsync([
+            "node",
+            "cli",
+            "-p",
+            "plan1",
+            "-d",
+            "approve",
+        ]);
         expect(mockApiRequest).toHaveBeenCalledWith("/agent/plan/approve", expect.objectContaining({ method: "POST" }));
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("approved"));
         consoleSpy.mockRestore();
     });
     it("handles approval failure", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("process.exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("process.exit");
+        });
         mockApiRequest.mockRejectedValueOnce(new Error("Plan not found"));
-        await expect(agentPlanApproveCommand.parseAsync(["node", "cli", "-p", "p1", "-d", "deny"])).rejects.toThrow();
+        await expect(agentPlanApproveCommand.parseAsync([
+            "node",
+            "cli",
+            "-p",
+            "p1",
+            "-d",
+            "deny",
+        ])).rejects.toThrow();
         consoleSpy.mockRestore();
         exitSpy.mockRestore();
     });
@@ -1386,17 +1976,38 @@ describe("agent plan approve", () => {
 describe("agent task background start", () => {
     it("starts a background task", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        mockApiRequest.mockResolvedValueOnce({ taskId: "task1", inngestRunId: "run1" });
-        await agentTaskBackgroundStartCommand.parseAsync(["node", "cli", "-k", "research", "--payload", '{"query":"test"}']);
+        mockApiRequest.mockResolvedValueOnce({
+            taskId: "task1",
+            inngestRunId: "run1",
+        });
+        await agentTaskBackgroundStartCommand.parseAsync([
+            "node",
+            "cli",
+            "-k",
+            "research",
+            "--payload",
+            '{"query":"test"}',
+        ]);
         expect(mockApiRequest).toHaveBeenCalledWith("/agent/task/background/start", expect.objectContaining({ method: "POST" }));
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("task1"));
         consoleSpy.mockRestore();
     });
     it("handles start failure", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("process.exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("process.exit");
+        });
         mockApiRequest.mockRejectedValueOnce(new Error("Queue full"));
-        await expect(agentTaskBackgroundStartCommand.parseAsync(["node", "cli", "-k", "kind", "--payload", "{}"])).rejects.toThrow();
+        await expect(agentTaskBackgroundStartCommand.parseAsync([
+            "node",
+            "cli",
+            "-k",
+            "kind",
+            "--payload",
+            "{}",
+        ])).rejects.toThrow();
         consoleSpy.mockRestore();
         exitSpy.mockRestore();
     });
@@ -1404,15 +2015,34 @@ describe("agent task background start", () => {
 describe("agent task background read", () => {
     it("reads task status", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        mockApiRequest.mockResolvedValueOnce({ taskId: "task1", kind: "research", status: "completed", label: "My task", resultPayload: { answer: "42" }, failureReason: null, createdAt: "2026-06-08", startedAt: "2026-06-08", completedAt: "2026-06-08" });
-        await agentTaskBackgroundReadCommand.parseAsync(["node", "cli", "-t", "task1"]);
+        mockApiRequest.mockResolvedValueOnce({
+            taskId: "task1",
+            kind: "research",
+            status: "completed",
+            label: "My task",
+            resultPayload: { answer: "42" },
+            failureReason: null,
+            createdAt: "2026-06-08",
+            startedAt: "2026-06-08",
+            completedAt: "2026-06-08",
+        });
+        await agentTaskBackgroundReadCommand.parseAsync([
+            "node",
+            "cli",
+            "-t",
+            "task1",
+        ]);
         expect(mockApiRequest).toHaveBeenCalled();
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("completed"));
         consoleSpy.mockRestore();
     });
     it("handles read failure", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("process.exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("process.exit");
+        });
         mockApiRequest.mockRejectedValueOnce(new Error("Not found"));
         await expect(agentTaskBackgroundReadCommand.parseAsync(["node", "cli", "-t", "t1"])).rejects.toThrow();
         consoleSpy.mockRestore();
@@ -1423,7 +2053,12 @@ describe("agent task background cancel", () => {
     it("cancels a background task", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
         mockApiRequest.mockResolvedValueOnce({ cancelled: true });
-        await agentTaskBackgroundCancelCommand.parseAsync(["node", "cli", "-t", "task1"]);
+        await agentTaskBackgroundCancelCommand.parseAsync([
+            "node",
+            "cli",
+            "-t",
+            "task1",
+        ]);
         expect(mockApiRequest).toHaveBeenCalledWith("/agent/task/background/cancel", expect.objectContaining({ method: "POST" }));
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("cancelled"));
         consoleSpy.mockRestore();
@@ -1431,13 +2066,22 @@ describe("agent task background cancel", () => {
     it("reports task could not be cancelled", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
         mockApiRequest.mockResolvedValueOnce({ cancelled: false });
-        await agentTaskBackgroundCancelCommand.parseAsync(["node", "cli", "-t", "task1"]);
+        await agentTaskBackgroundCancelCommand.parseAsync([
+            "node",
+            "cli",
+            "-t",
+            "task1",
+        ]);
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("could not be cancelled"));
         consoleSpy.mockRestore();
     });
     it("handles cancel failure", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("process.exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("process.exit");
+        });
         mockApiRequest.mockRejectedValueOnce(new Error("Not found"));
         await expect(agentTaskBackgroundCancelCommand.parseAsync(["node", "cli", "-t", "t1"])).rejects.toThrow();
         consoleSpy.mockRestore();
@@ -1450,17 +2094,40 @@ describe("agent task background cancel", () => {
 describe("asset upload", () => {
     it("uploads an asset", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        mockApiRequest.mockResolvedValueOnce({ url: "https://cdn.example.com/img.png", key: "img/abc.png", contentType: "image/png", bytes: 12345 });
-        await assetUploadCommand.parseAsync(["node", "cli", "-s", "https://example.com/img.png", "-k", "image"]);
+        mockApiRequest.mockResolvedValueOnce({
+            url: "https://cdn.example.com/img.png",
+            key: "img/abc.png",
+            contentType: "image/png",
+            bytes: 12345,
+        });
+        await assetUploadCommand.parseAsync([
+            "node",
+            "cli",
+            "-s",
+            "https://example.com/img.png",
+            "-k",
+            "image",
+        ]);
         expect(mockApiRequest).toHaveBeenCalledWith("/asset/upload", expect.objectContaining({ method: "POST" }));
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Asset uploaded"));
         consoleSpy.mockRestore();
     });
     it("handles upload failure", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("process.exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("process.exit");
+        });
         mockApiRequest.mockRejectedValueOnce(new Error("Source URL unreachable"));
-        await expect(assetUploadCommand.parseAsync(["node", "cli", "-s", "https://bad.url", "-k", "image"])).rejects.toThrow();
+        await expect(assetUploadCommand.parseAsync([
+            "node",
+            "cli",
+            "-s",
+            "https://bad.url",
+            "-k",
+            "image",
+        ])).rejects.toThrow();
         consoleSpy.mockRestore();
         exitSpy.mockRestore();
     });
@@ -1471,38 +2138,47 @@ describe("asset upload", () => {
 describe("billing subscription upgrade start", () => {
     it("starts a checkout session", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        mockApiRequest.mockResolvedValueOnce({ checkoutUrl: "https://checkout.stripe.com/pay/cs_test_123", planSlug: "scale", interval: "month" });
-        await billingSubscriptionUpgradeStartCommand.parseAsync(["node", "cli", "-p", "scale", "-i", "month", "--success-url", "https://app.oxagen.ai/success", "--cancel-url", "https://app.oxagen.ai/cancel"]);
+        mockApiRequest.mockResolvedValueOnce({
+            checkoutUrl: "https://checkout.stripe.com/pay/cs_test_123",
+            planSlug: "scale",
+            interval: "month",
+        });
+        await billingSubscriptionUpgradeStartCommand.parseAsync([
+            "node",
+            "cli",
+            "-p",
+            "scale",
+            "-i",
+            "month",
+            "--success-url",
+            "https://app.oxagen.ai/success",
+            "--cancel-url",
+            "https://app.oxagen.ai/cancel",
+        ]);
         expect(mockApiRequest).toHaveBeenCalledWith("/billing/subscription/upgrade/start", expect.objectContaining({ method: "POST" }));
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Checkout session created"));
         consoleSpy.mockRestore();
     });
     it("handles upgrade failure", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("process.exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("process.exit");
+        });
         mockApiRequest.mockRejectedValueOnce(new Error("Stripe error"));
-        await expect(billingSubscriptionUpgradeStartCommand.parseAsync(["node", "cli", "-p", "scale", "-i", "month", "--success-url", "https://a.com/ok", "--cancel-url", "https://a.com/cancel"])).rejects.toThrow();
-        consoleSpy.mockRestore();
-        exitSpy.mockRestore();
-    });
-});
-// ---------------------------------------------------------------------------
-// brandkit apply
-// ---------------------------------------------------------------------------
-describe("brandkit apply", () => {
-    it("applies a brand kit", async () => {
-        const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        mockApiRequest.mockResolvedValueOnce({ stub: true, applied: false, brandKitId: "bk1", targetFileId: "file1" });
-        await brandkitApplyCommand.parseAsync(["node", "cli", "-b", "bk1", "-f", "file1", "-w", "ws1"]);
-        expect(mockApiRequest).toHaveBeenCalledWith("/brandkit/apply", expect.objectContaining({ method: "POST" }));
-        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("stub"));
-        consoleSpy.mockRestore();
-    });
-    it("handles apply failure", async () => {
-        const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("process.exit"); });
-        mockApiRequest.mockRejectedValueOnce(new Error("Brand kit not found"));
-        await expect(brandkitApplyCommand.parseAsync(["node", "cli", "-b", "bk1", "-f", "f1", "-w", "ws1"])).rejects.toThrow();
+        await expect(billingSubscriptionUpgradeStartCommand.parseAsync([
+            "node",
+            "cli",
+            "-p",
+            "scale",
+            "-i",
+            "month",
+            "--success-url",
+            "https://a.com/ok",
+            "--cancel-url",
+            "https://a.com/cancel",
+        ])).rejects.toThrow();
         consoleSpy.mockRestore();
         exitSpy.mockRestore();
     });
@@ -1514,14 +2190,24 @@ describe("conversation purge", () => {
     it("purges archived conversations with --yes", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
         mockApiRequest.mockResolvedValueOnce({ deleted: 5 });
-        await conversationPurgeCommand.parseAsync(["node", "cli", "-w", "ws1", "--yes"]);
+        await conversationPurgeCommand.parseAsync([
+            "node",
+            "cli",
+            "-w",
+            "ws1",
+            "--yes",
+        ]);
         expect(mockApiRequest).toHaveBeenCalledWith("/conversation/purge", expect.objectContaining({ method: "POST" }));
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Purged 5"));
         consoleSpy.mockRestore();
     });
     it("exits without --yes", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("process.exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("process.exit");
+        });
         await expect(conversationPurgeCommand.parseAsync(["node", "cli", "-w", "ws1"])).rejects.toThrow();
         expect(consoleSpy).toHaveBeenCalled();
         consoleSpy.mockRestore();
@@ -1529,9 +2215,19 @@ describe("conversation purge", () => {
     });
     it("handles purge failure", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("process.exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("process.exit");
+        });
         mockApiRequest.mockRejectedValueOnce(new Error("Workspace not found"));
-        await expect(conversationPurgeCommand.parseAsync(["node", "cli", "-w", "ws1", "--yes"])).rejects.toThrow();
+        await expect(conversationPurgeCommand.parseAsync([
+            "node",
+            "cli",
+            "-w",
+            "ws1",
+            "--yes",
+        ])).rejects.toThrow();
         consoleSpy.mockRestore();
         exitSpy.mockRestore();
     });
@@ -1542,15 +2238,32 @@ describe("conversation purge", () => {
 describe("documents pdf create", () => {
     it("creates a PDF document", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        mockApiRequest.mockResolvedValueOnce({ assetId: "asset1", publicId: "pub1", kind: "pdf", mimeType: "application/pdf", sizeBytes: 50000, url: "https://blob.example.com/doc.pdf", serveUrl: "https://api.example.com/assets/asset1" });
-        await documentsPdfCreateCommand.parseAsync(["node", "cli", "-t", "Q1 Report"]);
+        mockApiRequest.mockResolvedValueOnce({
+            assetId: "asset1",
+            publicId: "pub1",
+            kind: "pdf",
+            mimeType: "application/pdf",
+            sizeBytes: 50000,
+            url: "https://blob.example.com/doc.pdf",
+            serveUrl: "https://api.example.com/assets/asset1",
+        });
+        await documentsPdfCreateCommand.parseAsync([
+            "node",
+            "cli",
+            "-t",
+            "Q1 Report",
+        ]);
         expect(mockApiRequest).toHaveBeenCalledWith("/documents/pdf/create", expect.objectContaining({ method: "POST" }));
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("PDF created"));
         consoleSpy.mockRestore();
     });
     it("handles pdf create failure", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("process.exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("process.exit");
+        });
         mockApiRequest.mockRejectedValueOnce(new Error("Generation failed"));
         await expect(documentsPdfCreateCommand.parseAsync(["node", "cli", "-t", "Report"])).rejects.toThrow();
         consoleSpy.mockRestore();
@@ -1563,18 +2276,50 @@ describe("documents pdf create", () => {
 describe("form fill", () => {
     it("fills form fields", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        const fields = [{ name: "firstName", label: "First Name", type: "text", current: "", changed: false, proposed: "Alice", reason: "Inferred from instruction" }];
+        const fields = [
+            {
+                name: "firstName",
+                label: "First Name",
+                type: "text",
+                current: "",
+                changed: false,
+                proposed: "Alice",
+                reason: "Inferred from instruction",
+            },
+        ];
         mockApiRequest.mockResolvedValueOnce({ fields });
-        await formFillCommand.parseAsync(["node", "cli", "-r", "/profile", "-i", "Fill with Alice's info", "--fields", '[{"name":"firstName","label":"First Name","type":"text","current":""}]']);
+        await formFillCommand.parseAsync([
+            "node",
+            "cli",
+            "-r",
+            "/profile",
+            "-i",
+            "Fill with Alice's info",
+            "--fields",
+            '[{"name":"firstName","label":"First Name","type":"text","current":""}]',
+        ]);
         expect(mockApiRequest).toHaveBeenCalledWith("/form/fill", expect.objectContaining({ method: "POST" }));
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Form fill suggestion"));
         consoleSpy.mockRestore();
     });
     it("handles form fill failure", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("process.exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("process.exit");
+        });
         mockApiRequest.mockRejectedValueOnce(new Error("LLM error"));
-        await expect(formFillCommand.parseAsync(["node", "cli", "-r", "/p", "-i", "fill", "--fields", "[]"])).rejects.toThrow();
+        await expect(formFillCommand.parseAsync([
+            "node",
+            "cli",
+            "-r",
+            "/p",
+            "-i",
+            "fill",
+            "--fields",
+            "[]",
+        ])).rejects.toThrow();
         consoleSpy.mockRestore();
         exitSpy.mockRestore();
     });
@@ -1585,15 +2330,27 @@ describe("form fill", () => {
 describe("org member invite decline", () => {
     it("declines an invitation", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        mockApiRequest.mockResolvedValueOnce({ invitationPublicId: "inv1", status: "declined" });
-        await orgMemberInviteDeclineCommand.parseAsync(["node", "cli", "-i", "inv1"]);
+        mockApiRequest.mockResolvedValueOnce({
+            invitationPublicId: "inv1",
+            status: "declined",
+        });
+        await orgMemberInviteDeclineCommand.parseAsync([
+            "node",
+            "cli",
+            "-i",
+            "inv1",
+        ]);
         expect(mockApiRequest).toHaveBeenCalledWith("/org/member/invite/decline", expect.objectContaining({ method: "POST" }));
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("declined"));
         consoleSpy.mockRestore();
     });
     it("handles decline failure", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("process.exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("process.exit");
+        });
         mockApiRequest.mockRejectedValueOnce(new Error("Invitation not found"));
         await expect(orgMemberInviteDeclineCommand.parseAsync(["node", "cli", "-i", "inv1"])).rejects.toThrow();
         consoleSpy.mockRestore();
@@ -1606,17 +2363,41 @@ describe("org member invite decline", () => {
 describe("organization create", () => {
     it("creates an organization", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        mockApiRequest.mockResolvedValueOnce({ publicId: "org1", name: "Acme Corp", slug: "acme-corp", type: "business", createdAt: "2026-06-08" });
-        await organizationCreateCommand.parseAsync(["node", "cli", "-n", "Acme Corp", "-s", "acme-corp"]);
+        mockApiRequest.mockResolvedValueOnce({
+            publicId: "org1",
+            name: "Acme Corp",
+            slug: "acme-corp",
+            type: "business",
+            createdAt: "2026-06-08",
+        });
+        await organizationCreateCommand.parseAsync([
+            "node",
+            "cli",
+            "-n",
+            "Acme Corp",
+            "-s",
+            "acme-corp",
+        ]);
         expect(mockApiRequest).toHaveBeenCalledWith("/organization/create", expect.objectContaining({ method: "POST" }));
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Organization created"));
         consoleSpy.mockRestore();
     });
     it("handles create failure", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("process.exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("process.exit");
+        });
         mockApiRequest.mockRejectedValueOnce(new Error("Slug already taken"));
-        await expect(organizationCreateCommand.parseAsync(["node", "cli", "-n", "Acme", "-s", "acme"])).rejects.toThrow();
+        await expect(organizationCreateCommand.parseAsync([
+            "node",
+            "cli",
+            "-n",
+            "Acme",
+            "-s",
+            "acme",
+        ])).rejects.toThrow();
         consoleSpy.mockRestore();
         exitSpy.mockRestore();
     });
@@ -1628,55 +2409,36 @@ describe("plugin credential set_secret", () => {
     it("stores a credential", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
         mockApiRequest.mockResolvedValueOnce({ ok: true });
-        await pluginCredentialSetSecretCommand.parseAsync(["node", "cli", "-l", "listing1", "-a", "secret", "--secret", "my-secret"]);
+        await pluginCredentialSetSecretCommand.parseAsync([
+            "node",
+            "cli",
+            "-l",
+            "listing1",
+            "-a",
+            "secret",
+            "--secret",
+            "my-secret",
+        ]);
         expect(mockApiRequest).toHaveBeenCalledWith("/plugin/credential/set_secret", expect.objectContaining({ method: "POST" }));
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Credential stored"));
         consoleSpy.mockRestore();
     });
     it("handles credential failure", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("process.exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("process.exit");
+        });
         mockApiRequest.mockRejectedValueOnce(new Error("Listing not found"));
-        await expect(pluginCredentialSetSecretCommand.parseAsync(["node", "cli", "-l", "l1", "-a", "secret"])).rejects.toThrow();
-        consoleSpy.mockRestore();
-        exitSpy.mockRestore();
-    });
-});
-// ---------------------------------------------------------------------------
-// plugin denylist
-// ---------------------------------------------------------------------------
-describe("plugin denylist add", () => {
-    it("adds a server to the denylist", async () => {
-        const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        mockApiRequest.mockResolvedValueOnce({ ok: true });
-        await pluginDenylistAddCommand.parseAsync(["node", "cli", "-s", "bad-server"]);
-        expect(mockApiRequest).toHaveBeenCalledWith("/plugin/denylist/add", expect.objectContaining({ method: "POST" }));
-        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("bad-server"));
-        consoleSpy.mockRestore();
-    });
-    it("handles denylist add failure", async () => {
-        const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("process.exit"); });
-        mockApiRequest.mockRejectedValueOnce(new Error("Server not found"));
-        await expect(pluginDenylistAddCommand.parseAsync(["node", "cli", "-s", "srv"])).rejects.toThrow();
-        consoleSpy.mockRestore();
-        exitSpy.mockRestore();
-    });
-});
-describe("plugin denylist remove", () => {
-    it("removes a server from the denylist", async () => {
-        const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        mockApiRequest.mockResolvedValueOnce({ ok: true });
-        await pluginDenylistRemoveCommand.parseAsync(["node", "cli", "-s", "bad-server"]);
-        expect(mockApiRequest).toHaveBeenCalledWith("/plugin/denylist/remove", expect.objectContaining({ method: "POST" }));
-        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("bad-server"));
-        consoleSpy.mockRestore();
-    });
-    it("handles denylist remove failure", async () => {
-        const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("process.exit"); });
-        mockApiRequest.mockRejectedValueOnce(new Error("Entry not found"));
-        await expect(pluginDenylistRemoveCommand.parseAsync(["node", "cli", "-s", "srv"])).rejects.toThrow();
+        await expect(pluginCredentialSetSecretCommand.parseAsync([
+            "node",
+            "cli",
+            "-l",
+            "l1",
+            "-a",
+            "secret",
+        ])).rejects.toThrow();
         consoleSpy.mockRestore();
         exitSpy.mockRestore();
     });
@@ -1687,22 +2449,41 @@ describe("plugin denylist remove", () => {
 describe("plugin org install bulk", () => {
     it("bulk installs plugins", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        mockApiRequest.mockResolvedValueOnce({ installed: [{ catalogServerId: "srv1", orgListingId: "listing1", error: null }] });
-        await pluginOrgInstallBulkCommand.parseAsync(["node", "cli", "--items", '[{"catalogServerId":"srv1"}]']);
+        mockApiRequest.mockResolvedValueOnce({
+            installed: [{ pluginId: "srv1", orgListingId: "listing1", error: null }],
+        });
+        await pluginOrgInstallBulkCommand.parseAsync([
+            "node",
+            "cli",
+            "--items",
+            '[{"catalogServerId":"srv1"}]',
+        ]);
         expect(mockApiRequest).toHaveBeenCalledWith("/plugin/org/install_bulk", expect.objectContaining({ method: "POST" }));
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("1 succeeded"));
         consoleSpy.mockRestore();
     });
     it("reports partial failures", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        mockApiRequest.mockResolvedValueOnce({ installed: [{ catalogServerId: "srv1", orgListingId: null, error: "Not found" }] });
-        await pluginOrgInstallBulkCommand.parseAsync(["node", "cli", "--items", '[{"catalogServerId":"srv1"}]']);
+        mockApiRequest.mockResolvedValueOnce({
+            installed: [{ pluginId: "srv1", orgListingId: null, error: "Not found" }],
+        });
+        await pluginOrgInstallBulkCommand.parseAsync([
+            "node",
+            "cli",
+            "--items",
+            '[{"catalogServerId":"srv1"}]',
+        ]);
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("0 succeeded, 1 failed"));
+        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("srv1: Not found"));
         consoleSpy.mockRestore();
     });
     it("handles bulk install failure", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("process.exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("process.exit");
+        });
         mockApiRequest.mockRejectedValueOnce(new Error("Bad request"));
         await expect(pluginOrgInstallBulkCommand.parseAsync(["node", "cli", "--items", "[]"])).rejects.toThrow();
         consoleSpy.mockRestore();
@@ -1716,7 +2497,15 @@ describe("plugin org list", () => {
     it("lists org plugins", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
         mockApiRequest.mockResolvedValueOnce({
-            listings: [{ id: "l1", publicId: "pub1", name: "Slack", pluginType: "mcp_server", enabled: true }],
+            listings: [
+                {
+                    id: "l1",
+                    publicId: "pub1",
+                    name: "Slack",
+                    pluginType: "mcp_server",
+                    enabled: true,
+                },
+            ],
             denylist: [],
         });
         await pluginOrgListCommand.parseAsync(["node", "cli"]);
@@ -1728,7 +2517,14 @@ describe("plugin org list", () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
         mockApiRequest.mockResolvedValueOnce({
             listings: [],
-            denylist: [{ id: "d1", serverName: "bad-server", pluginType: "mcp_server", reason: "Security risk" }],
+            denylist: [
+                {
+                    id: "d1",
+                    serverName: "bad-server",
+                    pluginType: "mcp_server",
+                    reason: "Security risk",
+                },
+            ],
         });
         await pluginOrgListCommand.parseAsync(["node", "cli"]);
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Denylist"));
@@ -1736,7 +2532,11 @@ describe("plugin org list", () => {
     });
     it("handles list failure", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("process.exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("process.exit");
+        });
         mockApiRequest.mockRejectedValueOnce(new Error("Unauthorized"));
         await expect(pluginOrgListCommand.parseAsync(["node", "cli"])).rejects.toThrow();
         consoleSpy.mockRestore();
@@ -1750,7 +2550,14 @@ describe("plugin org set_enabled", () => {
     it("enables a plugin listing", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
         mockApiRequest.mockResolvedValueOnce({ ok: true });
-        await pluginOrgSetEnabledCommand.parseAsync(["node", "cli", "-l", "listing1", "--enabled", "true"]);
+        await pluginOrgSetEnabledCommand.parseAsync([
+            "node",
+            "cli",
+            "-l",
+            "listing1",
+            "--enabled",
+            "true",
+        ]);
         expect(mockApiRequest).toHaveBeenCalledWith("/plugin/org/set_enabled", expect.objectContaining({ method: "POST" }));
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("enabled"));
         consoleSpy.mockRestore();
@@ -1758,15 +2565,33 @@ describe("plugin org set_enabled", () => {
     it("disables a plugin listing", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
         mockApiRequest.mockResolvedValueOnce({ ok: true });
-        await pluginOrgSetEnabledCommand.parseAsync(["node", "cli", "-l", "listing1", "--enabled", "false"]);
+        await pluginOrgSetEnabledCommand.parseAsync([
+            "node",
+            "cli",
+            "-l",
+            "listing1",
+            "--enabled",
+            "false",
+        ]);
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("disabled"));
         consoleSpy.mockRestore();
     });
     it("handles set_enabled failure", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("process.exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("process.exit");
+        });
         mockApiRequest.mockRejectedValueOnce(new Error("Listing not found"));
-        await expect(pluginOrgSetEnabledCommand.parseAsync(["node", "cli", "-l", "l1", "--enabled", "true"])).rejects.toThrow();
+        await expect(pluginOrgSetEnabledCommand.parseAsync([
+            "node",
+            "cli",
+            "-l",
+            "l1",
+            "--enabled",
+            "true",
+        ])).rejects.toThrow();
         consoleSpy.mockRestore();
         exitSpy.mockRestore();
     });
@@ -1785,7 +2610,11 @@ describe("plugin registry remove", () => {
     });
     it("handles remove failure", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("process.exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("process.exit");
+        });
         mockApiRequest.mockRejectedValueOnce(new Error("Registry is global default"));
         await expect(pluginRegistryRemoveCommand.parseAsync(["node", "cli", "-r", "r1"])).rejects.toThrow();
         consoleSpy.mockRestore();
@@ -1793,42 +2622,18 @@ describe("plugin registry remove", () => {
     });
 });
 // ---------------------------------------------------------------------------
-// plugin registry sync
-// ---------------------------------------------------------------------------
-describe("plugin registry sync", () => {
-    it("triggers a registry sync", async () => {
-        const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        mockApiRequest.mockResolvedValueOnce({ accepted: true });
-        await pluginRegistrySyncCommand.parseAsync(["node", "cli", "-r", "reg1"]);
-        expect(mockApiRequest).toHaveBeenCalledWith("/plugin/registry/sync", expect.objectContaining({ method: "POST" }));
-        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Sync accepted"));
-        consoleSpy.mockRestore();
-    });
-    it("reports sync not accepted", async () => {
-        const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        mockApiRequest.mockResolvedValueOnce({ accepted: false });
-        await pluginRegistrySyncCommand.parseAsync(["node", "cli", "-r", "reg1"]);
-        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("not accepted"));
-        consoleSpy.mockRestore();
-    });
-    it("handles sync failure", async () => {
-        const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("process.exit"); });
-        mockApiRequest.mockRejectedValueOnce(new Error("Registry not found"));
-        await expect(pluginRegistrySyncCommand.parseAsync(["node", "cli", "-r", "reg1"])).rejects.toThrow();
-        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Error:"));
-        consoleSpy.mockRestore();
-        exitSpy.mockRestore();
-    });
-});
-// ---------------------------------------------------------------------------
 // plugin settings set_auth_alerts
 // ---------------------------------------------------------------------------
 describe("plugin settings set_auth_alerts", () => {
     it("updates auth alert settings", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
         mockApiRequest.mockResolvedValueOnce({ ok: true });
-        await pluginSettingsSetAuthAlertsCommand.parseAsync(["node", "cli", "--roles", "Owner,Admin"]);
+        await pluginSettingsSetAuthAlertsCommand.parseAsync([
+            "node",
+            "cli",
+            "--roles",
+            "Owner,Admin",
+        ]);
         expect(mockApiRequest).toHaveBeenCalledWith("/plugin/settings/set_auth_alerts", expect.objectContaining({ method: "POST" }));
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("updated"));
         consoleSpy.mockRestore();
@@ -1836,15 +2641,29 @@ describe("plugin settings set_auth_alerts", () => {
     it("reports update failed when ok=false", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
         mockApiRequest.mockResolvedValueOnce({ ok: false });
-        await pluginSettingsSetAuthAlertsCommand.parseAsync(["node", "cli", "--roles", "Owner"]);
+        await pluginSettingsSetAuthAlertsCommand.parseAsync([
+            "node",
+            "cli",
+            "--roles",
+            "Owner",
+        ]);
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Update failed"));
         consoleSpy.mockRestore();
     });
     it("handles failure", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("process.exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("process.exit");
+        });
         mockApiRequest.mockRejectedValueOnce(new Error("Permission denied"));
-        await expect(pluginSettingsSetAuthAlertsCommand.parseAsync(["node", "cli", "--roles", "Owner"])).rejects.toThrow();
+        await expect(pluginSettingsSetAuthAlertsCommand.parseAsync([
+            "node",
+            "cli",
+            "--roles",
+            "Owner",
+        ])).rejects.toThrow();
         consoleSpy.mockRestore();
         exitSpy.mockRestore();
     });
@@ -1856,7 +2675,14 @@ describe("plugin workspace set_enabled", () => {
     it("enables a plugin for workspace", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
         mockApiRequest.mockResolvedValueOnce({ workspaceServerId: "wsrv1" });
-        await pluginWorkspaceSetEnabledCommand.parseAsync(["node", "cli", "-l", "listing1", "--enabled", "true"]);
+        await pluginWorkspaceSetEnabledCommand.parseAsync([
+            "node",
+            "cli",
+            "-l",
+            "listing1",
+            "--enabled",
+            "true",
+        ]);
         expect(mockApiRequest).toHaveBeenCalledWith("/plugin/workspace/set_enabled", expect.objectContaining({ method: "POST" }));
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("enabled"));
         consoleSpy.mockRestore();
@@ -1864,15 +2690,33 @@ describe("plugin workspace set_enabled", () => {
     it("disables a plugin for workspace (no server ID)", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
         mockApiRequest.mockResolvedValueOnce({ workspaceServerId: null });
-        await pluginWorkspaceSetEnabledCommand.parseAsync(["node", "cli", "-l", "listing1", "--enabled", "false"]);
+        await pluginWorkspaceSetEnabledCommand.parseAsync([
+            "node",
+            "cli",
+            "-l",
+            "listing1",
+            "--enabled",
+            "false",
+        ]);
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("disabled"));
         consoleSpy.mockRestore();
     });
     it("handles failure", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("process.exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("process.exit");
+        });
         mockApiRequest.mockRejectedValueOnce(new Error("Listing not found"));
-        await expect(pluginWorkspaceSetEnabledCommand.parseAsync(["node", "cli", "-l", "l1", "--enabled", "true"])).rejects.toThrow();
+        await expect(pluginWorkspaceSetEnabledCommand.parseAsync([
+            "node",
+            "cli",
+            "-l",
+            "l1",
+            "--enabled",
+            "true",
+        ])).rejects.toThrow();
         consoleSpy.mockRestore();
         exitSpy.mockRestore();
     });
@@ -1890,16 +2734,30 @@ describe("system install instructions", () => {
                 { label: "Authenticate", command: "oxagen auth login" },
             ],
         });
-        await systemInstallInstructionsCommand.parseAsync(["node", "cli", "-c", "claude-code"]);
+        await systemInstallInstructionsCommand.parseAsync([
+            "node",
+            "cli",
+            "-c",
+            "claude-code",
+        ]);
         expect(mockApiRequest).toHaveBeenCalled();
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("claude-code"));
         consoleSpy.mockRestore();
     });
     it("handles fetch failure", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("process.exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("process.exit");
+        });
         mockApiRequest.mockRejectedValueOnce(new Error("Unknown client"));
-        await expect(systemInstallInstructionsCommand.parseAsync(["node", "cli", "-c", "unknown"])).rejects.toThrow();
+        await expect(systemInstallInstructionsCommand.parseAsync([
+            "node",
+            "cli",
+            "-c",
+            "unknown",
+        ])).rejects.toThrow();
         consoleSpy.mockRestore();
         exitSpy.mockRestore();
     });
@@ -1943,7 +2801,11 @@ describe("user preferences read", () => {
     });
     it("handles read failure", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("process.exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("process.exit");
+        });
         mockApiRequest.mockRejectedValueOnce(new Error("Unauthorized"));
         await expect(userPreferencesReadCommand.parseAsync(["node", "cli"])).rejects.toThrow();
         consoleSpy.mockRestore();
@@ -1963,16 +2825,30 @@ describe("user preferences write", () => {
             defaultImageModel: null,
             defaultVideoModel: null,
         });
-        await userPreferencesWriteCommand.parseAsync(["node", "cli", "--font-size", "large"]);
+        await userPreferencesWriteCommand.parseAsync([
+            "node",
+            "cli",
+            "--font-size",
+            "large",
+        ]);
         expect(mockApiRequest).toHaveBeenCalledWith("/user/preferences/write", expect.objectContaining({ method: "POST" }));
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("updated"));
         consoleSpy.mockRestore();
     });
     it("handles write failure", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("process.exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("process.exit");
+        });
         mockApiRequest.mockRejectedValueOnce(new Error("Validation failed"));
-        await expect(userPreferencesWriteCommand.parseAsync(["node", "cli", "--density", "bad"])).rejects.toThrow();
+        await expect(userPreferencesWriteCommand.parseAsync([
+            "node",
+            "cli",
+            "--density",
+            "bad",
+        ])).rejects.toThrow();
         consoleSpy.mockRestore();
         exitSpy.mockRestore();
     });
@@ -1998,7 +2874,11 @@ describe("workflow cancel", () => {
     });
     it("handles cancel failure", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("process.exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("process.exit");
+        });
         mockApiRequest.mockRejectedValueOnce(new Error("Not found"));
         await expect(workflowCancelCommand.parseAsync(["node", "cli", "-w", "wfr_abc"])).rejects.toThrow();
         consoleSpy.mockRestore();
@@ -2009,7 +2889,15 @@ describe("workflow status", () => {
     it("shows workflow status and tasks", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
         mockApiRequest.mockResolvedValueOnce({
-            workflow: { id: "wf1", publicId: "wfr_abc", title: "Research task", status: "running", totalTasks: 5, completedTasks: 3, failedTasks: 0 },
+            workflow: {
+                id: "wf1",
+                publicId: "wfr_abc",
+                title: "Research task",
+                status: "running",
+                totalTasks: 5,
+                completedTasks: 3,
+                failedTasks: 0,
+            },
             tasks: [
                 { id: "t1", title: "Gather data", status: "completed" },
                 { id: "t2", title: "Analyze data", status: "running" },
@@ -2022,7 +2910,11 @@ describe("workflow status", () => {
     });
     it("handles status fetch failure", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("process.exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("process.exit");
+        });
         mockApiRequest.mockRejectedValueOnce(new Error("Workflow not found"));
         await expect(workflowStatusCommand.parseAsync(["node", "cli", "-w", "wfr_xyz"])).rejects.toThrow();
         consoleSpy.mockRestore();
@@ -2037,7 +2929,11 @@ describe("workflow status", () => {
 describe("branch coverage: ApiError error paths", () => {
     it("automation list returns ApiError message", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("exit");
+        });
         mockApiError(403, "Forbidden");
         await expect(automationListCommand.parseAsync(["node", "cli"])).rejects.toThrow();
         expect(consoleSpy).toHaveBeenCalledWith("Error: Forbidden");
@@ -2046,16 +2942,50 @@ describe("branch coverage: ApiError error paths", () => {
     });
     it("automation create returns ApiError message", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("exit");
+        });
         mockApiError(400, "Name required");
         await expect(automationCreateCommand.parseAsync(["node", "cli", "-n", "A"])).rejects.toThrow();
         expect(consoleSpy).toHaveBeenCalledWith("Error: Name required");
         consoleSpy.mockRestore();
         exitSpy.mockRestore();
     });
+    it("automation enable returns ApiError message", async () => {
+        const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("exit");
+        });
+        mockApiError(404, "Automation not found");
+        await expect(automationEnableCommand.parseAsync(["node", "cli", "plt_missing"])).rejects.toThrow();
+        expect(consoleSpy).toHaveBeenCalledWith("Error: Automation not found");
+        consoleSpy.mockRestore();
+        exitSpy.mockRestore();
+    });
+    it("automation disable returns ApiError message", async () => {
+        const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("exit");
+        });
+        mockApiError(404, "Automation not found");
+        await expect(automationDisableCommand.parseAsync(["node", "cli", "plt_missing"])).rejects.toThrow();
+        expect(consoleSpy).toHaveBeenCalledWith("Error: Automation not found");
+        consoleSpy.mockRestore();
+        exitSpy.mockRestore();
+    });
     it("automation trigger returns ApiError message", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("exit");
+        });
         mockApiError(404, "Automation not found");
         await expect(automationTriggerCommand.parseAsync(["node", "cli", "-a", "a1"])).rejects.toThrow();
         expect(consoleSpy).toHaveBeenCalledWith("Error: Automation not found");
@@ -2064,7 +2994,11 @@ describe("branch coverage: ApiError error paths", () => {
     });
     it("billing credits purchase returns ApiError message", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("exit");
+        });
         mockApiError(402, "Payment failed");
         await expect(billingCreditsPurchaseCommand.parseAsync(["node", "cli", "-a", "10"])).rejects.toThrow();
         expect(consoleSpy).toHaveBeenCalledWith("Error: Payment failed");
@@ -2073,7 +3007,11 @@ describe("branch coverage: ApiError error paths", () => {
     });
     it("billing subscription read returns ApiError message", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("exit");
+        });
         mockApiError(404, "Subscription not found");
         await expect(billingSubscriptionReadCommand.parseAsync(["node", "cli"])).rejects.toThrow();
         expect(consoleSpy).toHaveBeenCalledWith("Error: Subscription not found");
@@ -2082,7 +3020,11 @@ describe("branch coverage: ApiError error paths", () => {
     });
     it("document list returns ApiError message", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("exit");
+        });
         mockApiError(403, "Access denied");
         await expect(documentListCommand.parseAsync(["node", "cli"])).rejects.toThrow();
         expect(consoleSpy).toHaveBeenCalledWith("Error: Access denied");
@@ -2091,7 +3033,11 @@ describe("branch coverage: ApiError error paths", () => {
     });
     it("workspace member list returns ApiError message", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("exit");
+        });
         mockApiError(403, "Not a member");
         await expect(workspaceMemberListCommand.parseAsync(["node", "cli"])).rejects.toThrow();
         expect(consoleSpy).toHaveBeenCalledWith("Error: Not a member");
@@ -2100,7 +3046,11 @@ describe("branch coverage: ApiError error paths", () => {
     });
     it("workflow cancel returns ApiError message", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("exit");
+        });
         mockApiError(404, "Workflow not found");
         await expect(workflowCancelCommand.parseAsync(["node", "cli", "-w", "wfr_abc"])).rejects.toThrow();
         expect(consoleSpy).toHaveBeenCalledWith("Error: Workflow not found");
@@ -2109,7 +3059,11 @@ describe("branch coverage: ApiError error paths", () => {
     });
     it("workflow status returns ApiError message", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("exit");
+        });
         mockApiError(404, "Run expired");
         await expect(workflowStatusCommand.parseAsync(["node", "cli", "-w", "wfr_abc"])).rejects.toThrow();
         expect(consoleSpy).toHaveBeenCalledWith("Error: Run expired");
@@ -2118,7 +3072,11 @@ describe("branch coverage: ApiError error paths", () => {
     });
     it("user preferences read returns ApiError message", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("exit");
+        });
         mockApiError(401, "Unauthorized");
         await expect(userPreferencesReadCommand.parseAsync(["node", "cli"])).rejects.toThrow();
         expect(consoleSpy).toHaveBeenCalledWith("Error: Unauthorized");
@@ -2127,9 +3085,18 @@ describe("branch coverage: ApiError error paths", () => {
     });
     it("user preferences write returns ApiError message", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("exit");
+        });
         mockApiError(400, "Invalid font size");
-        await expect(userPreferencesWriteCommand.parseAsync(["node", "cli", "--font-size", "xxx"])).rejects.toThrow();
+        await expect(userPreferencesWriteCommand.parseAsync([
+            "node",
+            "cli",
+            "--font-size",
+            "xxx",
+        ])).rejects.toThrow();
         expect(consoleSpy).toHaveBeenCalledWith("Error: Invalid font size");
         consoleSpy.mockRestore();
         exitSpy.mockRestore();
@@ -2145,27 +3112,40 @@ describe("branch coverage: empty/optional data branches", () => {
     });
     it("automation list with workspace option", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        mockApiRequest.mockResolvedValueOnce([{ id: "a1", name: "Test", status: "active", triggers: [] }]);
+        mockApiRequest.mockResolvedValueOnce([
+            { id: "a1", name: "Test", status: "active", triggers: [] },
+        ]);
         await automationListCommand.parseAsync(["node", "cli", "-w", "ws1"]);
         expect(mockApiRequest).toHaveBeenCalledWith(expect.stringContaining("workspace_id=ws1"), expect.anything());
         consoleSpy.mockRestore();
     });
     it("automation list shows 'none' when triggers are empty", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        mockApiRequest.mockResolvedValueOnce([{ id: "a1", name: "Untriggered", status: "active", triggers: [] }]);
+        mockApiRequest.mockResolvedValueOnce([
+            { id: "a1", name: "Untriggered", status: "active", triggers: [] },
+        ]);
         await automationListCommand.parseAsync(["node", "cli"]);
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("triggers=none"));
         consoleSpy.mockRestore();
     });
     it("image create with save-to option", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        mockApiRequest.mockResolvedValueOnce({ id: "img1", url: "https://cdn.example.com/img.png", created_at: "2026-06-08", workspace_id: "ws1" });
+        mockApiRequest.mockResolvedValueOnce({
+            id: "img1",
+            url: "https://cdn.example.com/img.png",
+            created_at: "2026-06-08",
+            workspace_id: "ws1",
+        });
         await imageCreateCommand.parseAsync(["node", "cli", "-p", "A cat"]);
         consoleSpy.mockRestore();
     });
     it("conversation chat ApiError path", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("exit");
+        });
         mockApiError(401, "Not authenticated");
         await expect(conversationChatCommand.parseAsync(["node", "cli", "-m", "Hello"])).rejects.toThrow();
         expect(consoleSpy).toHaveBeenCalledWith("Error: Not authenticated");
@@ -2174,7 +3154,11 @@ describe("branch coverage: empty/optional data branches", () => {
     });
     it("workspace list ApiError path", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("exit");
+        });
         mockApiError(403, "Org not found");
         await expect(workspaceListCommand.parseAsync(["node", "cli"])).rejects.toThrow();
         expect(consoleSpy).toHaveBeenCalledWith("Error: Org not found");
@@ -2183,7 +3167,11 @@ describe("branch coverage: empty/optional data branches", () => {
     });
     it("org list ApiError path", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("exit");
+        });
         mockApiError(401, "Token expired");
         await expect(orgListCommand.parseAsync(["node", "cli"])).rejects.toThrow();
         expect(consoleSpy).toHaveBeenCalledWith("Error: Token expired");
@@ -2192,7 +3180,11 @@ describe("branch coverage: empty/optional data branches", () => {
     });
     it("api-key create ApiError path", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("exit");
+        });
         mockApiError(429, "Rate limit exceeded");
         await expect(apiKeyCreateCommand.parseAsync(["node", "cli", "mykey"])).rejects.toThrow();
         expect(consoleSpy).toHaveBeenCalledWith("Error: Rate limit exceeded");
@@ -2201,7 +3193,11 @@ describe("branch coverage: empty/optional data branches", () => {
     });
     it("plugin list ApiError path", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("exit");
+        });
         mockApiError(403, "Permission denied");
         await expect(pluginListCommand.parseAsync(["node", "cli"])).rejects.toThrow();
         expect(consoleSpy).toHaveBeenCalledWith("Error: Permission denied");
@@ -2210,7 +3206,11 @@ describe("branch coverage: empty/optional data branches", () => {
     });
     it("billing status ApiError path", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("exit");
+        });
         mockApiError(402, "Billing error");
         await expect(billingStatusCommand.parseAsync(["node", "cli"])).rejects.toThrow();
         expect(consoleSpy).toHaveBeenCalledWith("Error: Billing error");
@@ -2219,7 +3219,11 @@ describe("branch coverage: empty/optional data branches", () => {
     });
     it("chat send ApiError path", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("exit");
+        });
         // chat.send uses native fetch (not apiRequest); mock fetch directly.
         vi.spyOn(global, "fetch").mockResolvedValueOnce(new Response(JSON.stringify({ error: "Service unavailable" }), {
             status: 503,
@@ -2231,7 +3235,11 @@ describe("branch coverage: empty/optional data branches", () => {
     });
     it("document read ApiError path", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("exit");
+        });
         mockApiError(404, "Document not found");
         await expect(documentReadCommand.parseAsync(["node", "cli", "-d", "doc1"])).rejects.toThrow();
         expect(consoleSpy).toHaveBeenCalledWith("Error: Document not found");
@@ -2246,7 +3254,11 @@ describe("branch coverage: empty/optional data branches", () => {
     });
     it("workflow run ApiError path", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("exit"); });
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((_code) => {
+            throw new Error("exit");
+        });
         mockApiError(400, "Invalid workflow spec");
         await expect(workflowRunCommand.parseAsync(["node", "cli", "-w", "wf1"])).rejects.toThrow();
         expect(consoleSpy).toHaveBeenCalledWith("Error: Invalid workflow spec");
@@ -2271,7 +3283,13 @@ describe("Environment Variable Defaults", () => {
             const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
             mockGetOrgId.mockReturnValue("env-org-123");
             mockApiRequest.mockResolvedValueOnce({ members: [] });
-            await orgMemberAddCommand.parseAsync(["node", "cli", "user@example.com", "--role", "admin"]);
+            await orgMemberAddCommand.parseAsync([
+                "node",
+                "cli",
+                "user@example.com",
+                "--role",
+                "admin",
+            ]);
             expect(mockApiRequest).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
                 body: expect.stringContaining("env-org-123"),
             }));
@@ -2281,7 +3299,15 @@ describe("Environment Variable Defaults", () => {
             const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
             mockGetOrgId.mockReturnValue("env-org-123");
             mockApiRequest.mockResolvedValueOnce({ members: [] });
-            await orgMemberAddCommand.parseAsync(["node", "cli", "user@example.com", "--role", "admin", "--org", "cli-org-456"]);
+            await orgMemberAddCommand.parseAsync([
+                "node",
+                "cli",
+                "user@example.com",
+                "--role",
+                "admin",
+                "--org",
+                "cli-org-456",
+            ]);
             expect(mockApiRequest).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
                 body: expect.stringContaining("cli-org-456"),
             }));
@@ -2306,7 +3332,12 @@ describe("Environment Variable Defaults", () => {
             const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
             mockGetWorkspaceId.mockReturnValue("env-workspace-789");
             mockApiRequest.mockResolvedValueOnce([]);
-            await workspaceMemberListCommand.parseAsync(["node", "cli", "-w", "cli-workspace-xyz"]);
+            await workspaceMemberListCommand.parseAsync([
+                "node",
+                "cli",
+                "-w",
+                "cli-workspace-xyz",
+            ]);
             const calls = mockApiRequest.mock.calls;
             expect(calls.length).toBeGreaterThan(0);
             expect(calls[0]?.[0]).toContain("workspace_id=cli-workspace-xyz");
@@ -2331,11 +3362,17 @@ describe("Environment Variable Defaults", () => {
                 discoveredTools: ["tool1"],
             });
             await agentMcpRegisterCommand.parseAsync([
-                "node", "cli", "register",
-                "-n", "my-mcp",
-                "-u", "http://localhost:9000",
-                "-t", "streamable-http",
-                "-w", "explicit-workspace-888"
+                "node",
+                "cli",
+                "register",
+                "-n",
+                "my-mcp",
+                "-u",
+                "http://localhost:9000",
+                "-t",
+                "streamable-http",
+                "-w",
+                "explicit-workspace-888",
             ]);
             expect(mockApiRequest).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
                 body: expect.stringContaining("explicit-workspace-888"),
@@ -2352,10 +3389,15 @@ describe("Environment Variable Defaults", () => {
                 discoveredTools: [],
             });
             await agentMcpRegisterCommand.parseAsync([
-                "node", "cli", "register",
-                "-n", "my-mcp",
-                "-u", "http://localhost:9000",
-                "-t", "streamable-http"
+                "node",
+                "cli",
+                "register",
+                "-n",
+                "my-mcp",
+                "-u",
+                "http://localhost:9000",
+                "-t",
+                "streamable-http",
             ]);
             expect(mockApiRequest).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
                 body: expect.stringContaining("fallback-org-111"),
@@ -2373,7 +3415,12 @@ describe("Environment Variable Defaults", () => {
         it("workspace member list uses OXAGEN_WORKSPACE_ID as default when no --workspace flag", async () => {
             const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
             mockApiRequest.mockResolvedValueOnce([
-                { id: "user1", email: "user@test.com", role: "member", joined_at: "2024-01-01" }
+                {
+                    id: "user1",
+                    email: "user@test.com",
+                    role: "member",
+                    joined_at: "2024-01-01",
+                },
             ]);
             await workspaceMemberListCommand.parseAsync(["node", "cli"]);
             const calls = mockApiRequest.mock.calls;
@@ -2384,11 +3431,18 @@ describe("Environment Variable Defaults", () => {
         it("workspace member list uses explicit --workspace to override OXAGEN_WORKSPACE_ID", async () => {
             const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
             mockApiRequest.mockResolvedValueOnce([
-                { id: "user1", email: "user@test.com", role: "member", joined_at: "2024-01-01" }
+                {
+                    id: "user1",
+                    email: "user@test.com",
+                    role: "member",
+                    joined_at: "2024-01-01",
+                },
             ]);
             await workspaceMemberListCommand.parseAsync([
-                "node", "cli",
-                "-w", "explicit-ws"
+                "node",
+                "cli",
+                "-w",
+                "explicit-ws",
             ]);
             const calls = mockApiRequest.mock.calls;
             expect(calls.length).toBeGreaterThan(0);