@autifyhq/aximo-cli 0.13.0 → 0.15.0

package/dist/commands/case/update.js

@@ -3,7 +3,7 @@ import { request } from "../../client.js";
 import { handleApiError } from "../../errors.js";
 import { dryRunEnvelope, resolveJsonOverride } from "../../mutate.js";
 import { formatSuccess, printResult, validationError } from "../../output.js";
-import { optionalString, parseCaseFormat, parseCaseType, requireId } from "../../validate.js";
+import { optionalString, parseCaseFormat, parseCaseType, parseJsonArray, parseJsonObject, requireId, } from "../../validate.js";
 export async function runCaseUpdate(options, deps) {
     let caseId;
     let body;
@@ -21,6 +21,7 @@ export async function runCaseUpdate(options, deps) {
     }
     else {
         try {
+            const desktopDevice = optionalString("desktopDevice", options.desktopDevice);
             body = {
                 title: optionalString("title", options.title),
                 description: optionalString("description", options.description),
@@ -28,6 +29,10 @@ export async function runCaseUpdate(options, deps) {
                 type: parseCaseType(options.type),
                 format: parseCaseFormat(options.format),
                 startUrl: optionalString("startUrl", options.startUrl),
+                apiMobileConfig: parseJsonObject("mobileConfig", options.mobileConfig),
+                apiDesktopConfig: desktopDevice === undefined ? undefined : { userDeviceId: desktopDevice },
+                apiMultiDeviceConfig: parseJsonArray("multiDeviceConfig", options.multiDeviceConfig),
+                apiWebConfig: parseJsonObject("webConfig", options.webConfig),
             };
         }
         catch (err) {
@@ -54,11 +59,33 @@ export default defineCommand({
     args: {
         caseId: { type: "positional", required: true },
         title: { type: "string" },
-        description: { type: "string" },
+        description: {
+            type: "string",
+            description: "Cannot clear; use --json '{\"description\": null}' for that",
+        },
         scenario: { type: "string" },
         type: { type: "string", description: "web | mobile | desktop | multi_device" },
         format: { type: "string", description: "gherkin | markdown | plain_text" },
-        "start-url": { type: "string" },
+        "start-url": {
+            type: "string",
+            description: "Cannot clear; use --json '{\"startUrl\": null}' for that",
+        },
+        "mobile-config": {
+            type: "string",
+            description: "JSON object for apiMobileConfig ({deviceArn, deviceName, platform?, uploadArn?, uploadType?, appName?, bundleId?, apps?}); replaces the whole config. Clear with --json '{\"apiMobileConfig\":null}'",
+        },
+        "desktop-device": {
+            type: "string",
+            description: "Registered BYOD desktop device id (aximo device status) for apiDesktopConfig. Clear with --json '{\"apiDesktopConfig\":null}'",
+        },
+        "multi-device-config": {
+            type: "string",
+            description: "JSON array of 2-3 device entries ({kind: web|mobile, name, ...}) for apiMultiDeviceConfig; replaces the whole config. Clear with --json '{\"apiMultiDeviceConfig\":null}'",
+        },
+        "web-config": {
+            type: "string",
+            description: "JSON object for apiWebConfig ({hostnameOverrideIds: [...]}); replaces the whole config. Clear with --json '{\"apiWebConfig\":null}'",
+        },
         json: { type: "string", description: "Raw JSON request body (replaces individual flags)" },
         "dry-run": { type: "boolean", description: "Validate and show request without calling API" },
     },
@@ -71,6 +98,10 @@ export default defineCommand({
             type: args.type,
             format: args.format,
             startUrl: args["start-url"],
+            mobileConfig: args["mobile-config"],
+            desktopDevice: args["desktop-device"],
+            multiDeviceConfig: args["multi-device-config"],
+            webConfig: args["web-config"],
             json: args.json,
             dryRun: args["dry-run"],
         }));

package/dist/commands/device/status.d.ts

@@ -1,14 +1,5 @@
 import { type ClientDeps } from "../../client.js";
-import type { Envelope } from "../../types.js";
-interface UserDevice {
-    id: string;
-    name: string;
-    platform: string;
-    os?: string;
-    status: string;
-    lastSeenAt?: string;
-    createdAt: string;
-}
+import type { Envelope, UserDevice } from "../../types.js";
 export declare function runDeviceStatus(deps?: ClientDeps): Promise<Envelope<{
     devices: UserDevice[];
 }>>;

package/dist/commands/mcp/index.js

@@ -10,15 +10,18 @@ export default defineCommand({
     },
     args: {},
     async run() {
-        // Fail fast before the JSON-RPC handshake; diagnostics go to stderr only.
+        // Serve even without a key. A server that exits before the handshake shows
+        // up in the client as an empty tool list with no explanation; a server that
+        // answers every call with the `aximo configure` hint tells the agent what
+        // to do. The key is re-read on each request, so no restart is needed after
+        // configuring. Diagnostics go to stderr only.
         try {
             getApiKey();
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);
             process.stderr.write(`aximo mcp: ${message}\n`);
-            process.exitCode = 1;
-            return;
+            process.stderr.write("aximo mcp: serving anyway; tools return this error until a key is set\n");
         }
         const baseUrl = getBaseUrl();
         process.stderr.write(`aximo mcp: serving stdio MCP against ${baseUrl}\n`);

package/dist/commands/mcp/server.test.js

@@ -24,31 +24,43 @@ async function connect() {
     };
 }
 describe("createMcpServer wiring", () => {
-    it("exposes all 24 tools through tools/list with valid JSON Schema", async () => {
+    it("exposes all 36 tools through tools/list with valid JSON Schema", async () => {
         const { client, cleanup } = await connect();
         try {
             const { tools } = await client.listTools();
             expect(tools.map((t) => t.name).sort()).toEqual([
                 "aximo_get_case",
                 "aximo_get_session",
+                "aximo_wait_for_session",
                 "aximo_get_session_capture",
                 "aximo_get_session_snapshot",
+                "aximo_export_session_pdf",
+                "aximo_export_session_screenshots",
                 "aximo_get_session_messages",
                 "aximo_get_session_screenshots",
                 "aximo_get_session_timeline",
                 "aximo_list_cases",
+                "aximo_list_devices",
                 "aximo_list_projects",
                 "aximo_list_sessions",
+                "aximo_list_uploads",
+                "aximo_list_user_devices",
                 "aximo_create_case",
                 "aximo_update_case",
+                "aximo_archive_case",
+                "aximo_restore_case",
                 "aximo_delete_case",
                 "aximo_run_case",
+                "aximo_create_session",
                 "aximo_create_plan",
                 "aximo_add_case_to_plan",
                 "aximo_remove_case_from_plan",
                 "aximo_list_plans",
                 "aximo_get_plan",
                 "aximo_update_plan",
+                "aximo_archive_plan",
+                "aximo_restore_plan",
+                "aximo_delete_plan",
                 "aximo_run_plan",
                 "aximo_list_plan_runs",
                 "aximo_get_plan_run",
@@ -80,6 +92,25 @@ describe("createMcpServer wiring", () => {
             await cleanup();
         }
     });
+    it("serves the full tool list without an API key and answers calls with the configure hint", async () => {
+        const prev = process.env["AXIMO_API_KEY"];
+        delete process.env["AXIMO_API_KEY"];
+        const { client, cleanup } = await connect();
+        try {
+            const { tools } = await client.listTools();
+            expect(tools.length).toBe(36);
+            const result = await client.callTool({ name: "aximo_list_projects", arguments: {} });
+            expect(result.isError).toBe(true);
+            const content = result.content;
+            const payload = JSON.parse(content[0].text);
+            expect(payload.error).toBe("API key not configured");
+            expect(payload.hint).toBe("Run `aximo configure`, then call the tool again.");
+        }
+        finally {
+            process.env["AXIMO_API_KEY"] = prev;
+            await cleanup();
+        }
+    });
     it("returns isError with a validation message when input fails the schema", async () => {
         const { client, cleanup } = await connect();
         try {

package/dist/commands/mcp/tools.js

@@ -1,5 +1,9 @@
+import { isAbsolute } from "node:path";
 import { z } from "zod";
 import { request } from "../../client.js";
+import { WAIT_DEFAULT_SECONDS, WAIT_MAX_SECONDS, waitForSession } from "./wait.js";
+import { exportSession, SESSION_EXPORT_LOCALES, } from "../../session-export.js";
+import { ARCHIVE_FIRST_HINT, featureHint, isArchiveFirstConflict, withDetails, } from "../../errors.js";
 function ok(payload) {
     return {
         content: [{ type: "text", text: JSON.stringify(payload, null, 2) }],
@@ -23,24 +27,33 @@ async function call(fn) {
     catch (e) {
         if (!(e instanceof Error))
             return err(String(e));
-        const status = e.status;
+        const { status, details } = e;
+        const message = withDetails(e.message, details);
         if (status === 401)
             return err("Unauthorized: check AXIMO_API_KEY", "Run `aximo configure`.");
         if (status === 403) {
-            return err(e.message || "Forbidden", "API key may not have access to this resource.");
+            return err(message || "Forbidden", featureHint(e.message, details) ?? "API key may not have access to this resource.");
         }
         if (status === 404)
-            return err(e.message || "Not found");
+            return err(message || "Not found");
         if (status === 429) {
             const retryAfter = e.retryAfter;
             return err("Rate limited", retryAfter
                 ? `Back off and retry after ${retryAfter} seconds.`
                 : "Back off before retrying; Aximo rate-limits requests per organization.");
         }
+        // Mirrors the 409 branch in handleApiError. Without this, an archive-first
+        // 409 falls through to the bare `HTTP 409: ...` case below and the agent is
+        // told to call a REST endpoint it has no way to reach, while the tool that
+        // would work goes unmentioned. Keyed on the details-enriched message, the
+        // same input handleApiError feeds the predicate, so the two cannot disagree.
+        if (status === 409) {
+            return err(message || "Conflict", isArchiveFirstConflict(message) ? ARCHIVE_FIRST_HINT : undefined);
+        }
         if (typeof status === "number")
-            return err(`HTTP ${status}: ${e.message}`);
+            return err(`HTTP ${status}: ${message}`);
         if (e.message.startsWith("No API key configured")) {
-            return err("API key not configured", "Run `aximo configure` and restart the MCP server.");
+            return err("API key not configured", "Run `aximo configure`, then call the tool again.");
         }
         const cause = e.cause;
         const networkCode = cause?.code;
@@ -70,6 +83,22 @@ const runAppsSchema = z
     bundleId: z.string().optional(),
 }))
     .max(3);
+const exportOutputPathSchema = z
+    .string()
+    .min(1)
+    .describe("Absolute file path to write, e.g. /tmp/result.pdf. Parent directories are created and an existing file is replaced.");
+const exportLocaleSchema = z
+    .enum(SESSION_EXPORT_LOCALES)
+    .optional()
+    .describe("Language of the report labels. Default en.");
+// The MCP server's working directory is wherever the client launched it, so a
+// relative path would land somewhere the caller cannot predict.
+function exportSessionTo(input, deps) {
+    if (!isAbsolute(input.outputPath)) {
+        throw new Error("outputPath must be an absolute path");
+    }
+    return exportSession(input, deps);
+}
 export function defineTools(deps = {}) {
     return [
         {
@@ -82,6 +111,53 @@ export function defineTools(deps = {}) {
                 return res;
             }),
         },
+        {
+            name: "aximo_list_devices",
+            title: "List Device Farm devices",
+            description: "List the cloud (AWS Device Farm) mobile devices available to your organization — not BYOD devices (see aximo_list_user_devices). Each device's arn is the encrypted token to pass as deviceArn, and its name as deviceName, in a case's apiMobileConfig or multi-device mobile entries (aximo_update_case) and in per-run overrides (aximo_run_case, aximo_run_plan). Filter by platform (ANDROID | IOS) or availableOnly.",
+            inputSchema: {
+                platform: z.enum(["ANDROID", "IOS"]).optional(),
+                availableOnly: z
+                    .boolean()
+                    .optional()
+                    .describe("Only devices that are currently free to run on."),
+            },
+            handler: async ({ platform, availableOnly }) => call(async () => {
+                return await request("/api/devices", { query: { platform, availableOnly: availableOnly || undefined } }, deps);
+            }),
+        },
+        {
+            name: "aximo_list_user_devices",
+            title: "List registered BYOD devices",
+            description: "List the BYOD (bring-your-own) desktop and mobile devices registered with `aximo device register` by the owner of this API key — other members' devices are not included. Each device's id is the userDeviceId to pass in a case's apiDesktopConfig or multi-device local entries (aximo_update_case) and in per-run overrides. status shows whether the device is online. Returns 404 when BYOD is not enabled for the organization.",
+            inputSchema: {},
+            handler: async () => call(async () => {
+                try {
+                    return await request("/api/devices/user", {}, deps);
+                }
+                catch (e) {
+                    // The route answers a bare 404 when the org has no BYOD feature.
+                    if (e.status === 404) {
+                        throw Object.assign(new Error("BYOD is not enabled for this organization"), {
+                            status: 403,
+                            details: { feature: "byodEnabled" },
+                        });
+                    }
+                    throw e;
+                }
+            }),
+        },
+        {
+            name: "aximo_list_uploads",
+            title: "List app uploads",
+            description: "List the mobile app binaries (APK / IPA) uploaded to your organization. Each upload's uploadArn is the encrypted token to pass as uploadArn in a case's apiMobileConfig or multi-device mobile entries (aximo_update_case) and in per-run overrides; only uploads with status succeeded can be installed. identifier is the app's bundleId. Filter by fileType (ANDROID_APP | IOS_APP).",
+            inputSchema: {
+                fileType: z.enum(["ANDROID_APP", "IOS_APP"]).optional(),
+            },
+            handler: async ({ fileType }) => call(async () => {
+                return await request("/api/uploads", { query: { fileType } }, deps);
+            }),
+        },
         {
             name: "aximo_list_sessions",
             title: "List sessions",
@@ -108,6 +184,22 @@ export function defineTools(deps = {}) {
                 return await request(`/api/sessions/${encodeURIComponent(sessionId)}`, {}, deps);
             }),
         },
+        {
+            name: "aximo_wait_for_session",
+            title: "Wait for session",
+            description: "Wait for a session to finish and return within timeoutSeconds whatever its state. Polls every 5 seconds. Returns done=true with the final session (status succeeded, failed, terminated, error, or archived), or done=false with the current status so you can call again. Default 45 seconds, maximum 90: most MCP clients cut a tool call off at 60, so only go above that where the client has no limit. A multi-minute run is a handful of these calls.",
+            inputSchema: {
+                sessionId: z.string().uuid(),
+                timeoutSeconds: z
+                    .number()
+                    .int()
+                    .min(1)
+                    .max(WAIT_MAX_SECONDS)
+                    .optional()
+                    .describe(`Seconds to wait before returning. Default ${WAIT_DEFAULT_SECONDS}.`),
+            },
+            handler: async ({ sessionId, timeoutSeconds }) => call(() => waitForSession(sessionId, timeoutSeconds ?? WAIT_DEFAULT_SECONDS, deps)),
+        },
         {
             name: "aximo_get_session_messages",
             title: "Get session messages",
@@ -183,6 +275,28 @@ export function defineTools(deps = {}) {
                 return await request(`/api/sessions/${encodeURIComponent(sessionId)}/snapshots/${encodeURIComponent(snapshotId)}`, {}, deps);
             }),
         },
+        {
+            name: "aximo_export_session_pdf",
+            title: "Export session result as PDF",
+            description: "Download a session's test result report (overview, result summary, and every step with its screenshot) as a PDF and write it to outputPath on this machine. Returns the written path and size, not the file bytes. A running session exports the steps recorded so far. Sessions over 500 steps return HTTP 413: export the screenshots archive instead. For a plan run, take each case's sessionId from aximo_get_plan_run.",
+            inputSchema: {
+                sessionId: z.string().uuid(),
+                outputPath: exportOutputPathSchema,
+                locale: exportLocaleSchema,
+            },
+            handler: async ({ sessionId, outputPath, locale }) => call(() => exportSessionTo({ sessionId, format: "pdf", outputPath, locale }, deps)),
+        },
+        {
+            name: "aximo_export_session_screenshots",
+            title: "Export session screenshots as ZIP",
+            description: "Download a ZIP of every step screenshot of a session (screenshots/step-001.png or .jpg, as stored) plus metadata.csv (one row per step: screenshot file, AI thoughts, tool, details) and session.csv, and write it to outputPath on this machine. Returns the written path and size, not the file bytes. The download is verified complete before success is reported; a truncated archive is deleted and returned as an error. A session with no screenshots returns HTTP 409.",
+            inputSchema: {
+                sessionId: z.string().uuid(),
+                outputPath: exportOutputPathSchema,
+                locale: exportLocaleSchema,
+            },
+            handler: async ({ sessionId, outputPath, locale }) => call(() => exportSessionTo({ sessionId, format: "screenshots", outputPath, locale }, deps)),
+        },
         {
             name: "aximo_list_cases",
             title: "List test cases",
@@ -231,15 +345,36 @@ export function defineTools(deps = {}) {
         {
             name: "aximo_update_case",
             title: "Update test case",
-            description: "Update a test case's title, description, scenario, type, format, or startUrl (pass null to clear startUrl). Omitted fields are left unchanged; at least one field is required. Per-target device configuration cannot be changed over the API, and changing type does not create or clear it (e.g. switching to mobile leaves apiMobileConfig null until set in the dashboard).",
+            description: "Update a test case's title, description, scenario, type, format, or startUrl (pass null to clear description or startUrl; an empty description string is stored as-is, not a clear). Omitted fields are left unchanged; at least one field is required. Pass apiMobileConfig / apiDesktopConfig / apiMultiDeviceConfig / apiWebConfig to set the case's default targets — the same shapes aximo_get_case returns; null clears one, omit leaves it unchanged. Each config value is replaced whole — send the complete config object you want stored (never a partial), and omit a config key entirely to leave that target unchanged. deviceArn = aximo_list_devices devices[].arn and deviceName = devices[].name; uploadArn = aximo_list_uploads uploads[].uploadArn (status succeeded), bundleId = uploads[].identifier, uploadType is usually \"own_app\"; userDeviceId = aximo_list_user_devices devices[].id. apiMobileConfig.platform is ANDROID|IOS; multi-device mobilePlatform is android|ios. There is no top-level userDeviceId/deviceArn here — they live inside the config objects. Desktop and multi-device require the organization's BYOD / multi-device feature. You can set type in the same call.",
             inputSchema: {
                 caseId: z.string().uuid(),
                 title: z.string().min(1).max(500).optional(),
-                description: z.string().optional(),
+                description: z.string().nullable().optional(),
                 scenario: z.string().min(1).optional(),
                 type: z.enum(["web", "mobile", "desktop", "multi_device"]).optional(),
                 format: z.enum(["gherkin", "markdown", "plain_text"]).optional(),
                 startUrl: z.string().url().nullable().optional(),
+                apiMobileConfig: z
+                    .record(z.unknown())
+                    .nullable()
+                    .optional()
+                    .describe("{ deviceArn, deviceName, platform?: ANDROID|IOS, uploadArn?, uploadType?: own_app|existing|sample, appName?, bundleId?, apps?: [{ uploadArn, uploadType, appName, bundleId? }] (max 3) }. null clears."),
+                apiDesktopConfig: z
+                    .object({ userDeviceId: z.string().uuid() })
+                    .passthrough()
+                    .nullable()
+                    .optional()
+                    .describe("{ userDeviceId } of a registered BYOD desktop device (aximo_list_user_devices); name/platform/os are resolved server-side. null clears."),
+                apiMultiDeviceConfig: z
+                    .array(z.record(z.unknown()))
+                    .nullable()
+                    .optional()
+                    .describe('2-3 entries, each { kind: "web", name, startUrl?, userDeviceId? } or { kind: "mobile", name, mobilePlatform: android|ios, deviceArn?, deviceName?, userDeviceId?, uploadArn?, uploadType?, appName?, bundleId?, apps? }. null clears.'),
+                apiWebConfig: z
+                    .record(z.unknown())
+                    .nullable()
+                    .optional()
+                    .describe("{ hostnameOverrideIds?: string[] }. null clears."),
             },
             handler: async ({ caseId, ...body }) => call(async () => {
                 if (Object.keys(body).length === 0) {
@@ -248,10 +383,32 @@ export function defineTools(deps = {}) {
                 return await request(`/api/cases/${encodeURIComponent(caseId)}`, { method: "PATCH", body }, deps);
             }),
         },
+        {
+            name: "aximo_archive_case",
+            title: "Archive test case",
+            description: "Archive a test case: hidden from lists, plans, and new runs; run history kept. Idempotent. Required before aximo_delete_case can permanently delete it.",
+            inputSchema: {
+                caseId: z.string().uuid(),
+            },
+            handler: async ({ caseId }) => call(async () => {
+                return await request(`/api/cases/${encodeURIComponent(caseId)}/archive`, { method: "POST" }, deps);
+            }),
+        },
+        {
+            name: "aximo_restore_case",
+            title: "Restore test case",
+            description: "Restore an archived test case: it returns to lists, directory counts, and plan membership. Idempotent. A case whose directory was deleted while archived returns to the project root.",
+            inputSchema: {
+                caseId: z.string().uuid(),
+            },
+            handler: async ({ caseId }) => call(async () => {
+                return await request(`/api/cases/${encodeURIComponent(caseId)}/restore`, { method: "POST" }, deps);
+            }),
+        },
         {
             name: "aximo_delete_case",
             title: "Delete test case",
-            description: "Permanently delete a test case. It is removed from any plans it belongs to; past run sessions are kept but detached. This cannot be undone.",
+            description: "Permanently delete an already-archived test case. Archive it first with aximo_archive_case. Requires an organization admin or owner API key. It is removed from any plans it belongs to, and its rows in past plan runs go with it, so those runs list fewer cases than their stored totals; the agent sessions themselves are kept but detached. This cannot be undone.",
             inputSchema: {
                 caseId: z.string().uuid(),
             },
@@ -298,6 +455,49 @@ export function defineTools(deps = {}) {
                 return await request(`/api/triggers/cases/${encodeURIComponent(caseId)}/run`, { method: "POST", body }, deps);
             }),
         },
+        {
+            name: "aximo_create_session",
+            title: "Create session",
+            description: "Start an agent session from a prompt, without saving a test case. Consumes organization credits. Returns the new sessionId; follow it with aximo_wait_for_session. Runs in Aximo's cloud browser unless userDeviceId names a registered local device (aximo_list_user_devices); for an app on localhost use a local device and put the app's URL in the prompt itself.",
+            inputSchema: {
+                title: z.string().min(1).max(500).describe("Shown in the session list."),
+                prompt: z
+                    .string()
+                    .min(1)
+                    .max(10000)
+                    .describe("What to test, in plain language: the steps and what counts as a pass."),
+                projectId: z.string().uuid(),
+                platform: z.enum(["desktop", "android", "ios"]).optional().describe("Default desktop."),
+                model: z
+                    .string()
+                    .optional()
+                    .describe("Agent model (e.g. 'sonnet', 'haiku', 'auto'). Server-validated."),
+                startUrl: z
+                    .string()
+                    .url()
+                    .optional()
+                    .describe("Web sessions on cloud browsers: first URL to open."),
+                tags: z.array(z.string().max(64)).max(10).optional(),
+                hostnameOverrideIds: z.array(z.string().uuid()).optional(),
+                userDeviceId: z
+                    .string()
+                    .uuid()
+                    .optional()
+                    .describe("A user-owned (BYOD) device id; runs there instead of the cloud."),
+                deviceArn: z.string().optional().describe("Mobile: encrypted Device Farm device token."),
+                deviceName: z.string().optional(),
+                uploadArn: z.string().optional().describe("Mobile: encrypted app upload token."),
+                uploadType: z.enum(["own_app", "existing", "sample"]).optional(),
+                appName: z.string().optional(),
+                bundleId: z.string().optional(),
+                apps: runAppsSchema
+                    .optional()
+                    .describe("Mobile multi-app sessions: up to 3 apps; takes precedence over the single-app fields."),
+            },
+            handler: async (body) => call(async () => {
+                return await request("/api/sessions", { method: "POST", body }, deps);
+            }),
+        },
         {
             name: "aximo_create_plan",
             title: "Create test plan",
@@ -378,6 +578,39 @@ export function defineTools(deps = {}) {
                 return await request(`/api/plans/${encodeURIComponent(planId)}`, { method: "PATCH", body }, deps);
             }),
         },
+        {
+            name: "aximo_archive_plan",
+            title: "Archive test plan",
+            description: "Archive a test plan: hidden from lists and blocked from new runs; its cases, run history, and schedule are all kept. The scheduler skips archived plans, so restoring one resumes its normal cadence. Idempotent. Required before aximo_delete_plan can permanently delete it.",
+            inputSchema: {
+                planId: z.string().uuid(),
+            },
+            handler: async ({ planId }) => call(async () => {
+                return await request(`/api/plans/${encodeURIComponent(planId)}/archive`, { method: "POST" }, deps);
+            }),
+        },
+        {
+            name: "aximo_restore_plan",
+            title: "Restore test plan",
+            description: "Restore an archived test plan: it returns to lists and can be run again, and its schedule resumes exactly as configured. Idempotent.",
+            inputSchema: {
+                planId: z.string().uuid(),
+            },
+            handler: async ({ planId }) => call(async () => {
+                return await request(`/api/plans/${encodeURIComponent(planId)}/restore`, { method: "POST" }, deps);
+            }),
+        },
+        {
+            name: "aximo_delete_plan",
+            title: "Delete test plan",
+            description: "Permanently delete an already-archived test plan. Archive it first with aximo_archive_plan. Requires an organization admin or owner API key. Its member cases are kept, and so is its run history: those runs are detached from the plan and remain readable as standalone results. This cannot be undone.",
+            inputSchema: {
+                planId: z.string().uuid(),
+            },
+            handler: async ({ planId }) => call(async () => {
+                return await request(`/api/plans/${encodeURIComponent(planId)}`, { method: "DELETE" }, deps);
+            }),
+        },
         {
             name: "aximo_run_plan",
             title: "Run test plan",
@@ -467,7 +700,7 @@ export function defineTools(deps = {}) {
         {
             name: "aximo_get_plan_run",
             title: "Get plan run status",
-            description: "Get the overall status and per-case breakdown of a plan run (from aximo_list_plan_runs, or the planRunId returned when a run was triggered). Poll this to observe a run in progress; wait at least 5 seconds between polls. A run's status reflects execution, not the test verdict: a run can complete with failedCases > 0, so read passedCases/failedCases and the per-case statuses to judge outcomes.",
+            description: "Get the overall status and per-case breakdown of a plan run (from aximo_list_plan_runs, or the planRunId returned when a run was triggered). Poll this to observe a run in progress; wait at least 5 seconds between polls. A run's status reflects execution, not the test verdict: a run can complete with failedCases > 0, so read passedCases/failedCases and the per-case statuses to judge outcomes. Each case carries its sessionId (null until its session is created) for aximo_get_session and the export tools.",
             inputSchema: {
                 planId: z.string().uuid(),
                 planRunId: z.string().uuid(),