@sakupa/mcp 0.7.45 → 0.7.46

package/dist/bin.js

@@ -380,7 +380,7 @@ var FORBIDDEN_PATH_SEGMENTS = [
 var ALLOWED_HIDDEN_PATHS = [".well-known/"];
 
 // ../core/dist/domain/version.js
-var SAKUPA_MCP_VERSION = "0.7.45";
+var SAKUPA_MCP_VERSION = "0.7.46";
 
 // ../core/dist/domain/errors.js
 var HTTP_STATUS = {
@@ -3185,6 +3185,24 @@ function boundDiagnostics(processCwd, selected, snapshot = { supported: false, r
 
 // src/tools/result.ts
 import { z } from "zod";
+var TARGET_MCP_TOOL_NAMES = [
+  "init",
+  "help",
+  "analyze",
+  "deploy",
+  "refresh",
+  "status",
+  "rotate",
+  "plans",
+  "subscribe",
+  "bind",
+  "billing",
+  "portal",
+  "recover",
+  "change",
+  "support",
+  "report"
+];
 var STRUCTURED_TOOL_OUTPUT_SCHEMA = {
   schemaVersion: z.literal(1),
   outcome: z.enum([
@@ -3200,13 +3218,41 @@ var STRUCTURED_TOOL_OUTPUT_SCHEMA = {
   operationId: z.string().optional(),
   summary: z.string(),
   data: z.record(z.string(), z.unknown()),
+  decision: z.object({
+    decisionVersion: z.literal(1),
+    prompt: z.string(),
+    selectionMode: z.literal("single"),
+    selectionRequired: z.literal(true),
+    defaultOptionId: z.null(),
+    options: z.array(
+      z.object({
+        id: z.string(),
+        label: z.string(),
+        description: z.string(),
+        consequences: z.array(z.string()),
+        nextAction: z.discriminatedUnion("type", [
+          z.object({
+            type: z.literal("call_tool"),
+            tool: z.enum(TARGET_MCP_TOOL_NAMES),
+            arguments: z.record(z.string(), z.unknown()),
+            reasonCode: z.string().optional()
+          }),
+          z.object({ type: z.literal("open_url"), url: z.string() }),
+          z.object({ type: z.literal("none") })
+        ])
+      })
+    )
+  }).optional(),
   userAction: z.object({
     type: z.enum(["open_url", "confirm_in_mcp", "configure_dns", "select_site"]),
     provider: z.enum(["stripe", "sakupa"]).optional(),
     url: z.string().optional(),
     expiresAt: z.string().optional(),
     expectedOutcome: z.string(),
-    resumeWith: z.object({ tool: z.string(), arguments: z.record(z.string(), z.unknown()) }).optional(),
+    resumeWith: z.object({
+      tool: z.enum(TARGET_MCP_TOOL_NAMES),
+      arguments: z.record(z.string(), z.unknown())
+    }).optional(),
     options: z.array(
       z.object({
         label: z.string(),
@@ -3217,7 +3263,7 @@ var STRUCTURED_TOOL_OUTPUT_SCHEMA = {
   }).optional(),
   nextActions: z.array(
     z.object({
-      tool: z.string(),
+      tool: z.enum(TARGET_MCP_TOOL_NAMES),
       arguments: z.record(z.string(), z.unknown()).optional(),
       allowed: z.boolean(),
       reasonCode: z.string().optional()
@@ -3400,6 +3446,176 @@ function toolError(e) {
   return { ...result, isError: true };
 }
 
+// src/tools/decision.ts
+var FORBIDDEN_DECISION_ARGUMENT_KEYS = /* @__PURE__ */ new Set([
+  "credential",
+  "candidatecredential",
+  "devicecredential",
+  "password",
+  "secret",
+  "privatekey",
+  "accesstoken",
+  "refreshtoken"
+]);
+function assertDecisionArgumentsSafe(value, path = "arguments") {
+  if (typeof value === "string") {
+    if (/^sk_[A-Za-z0-9_-]{20,}$/.test(value)) {
+      throw new Error(`Decision ${path} contains a credential-like value.`);
+    }
+    return;
+  }
+  if (Array.isArray(value)) {
+    value.forEach((entry, index) => assertDecisionArgumentsSafe(entry, `${path}[${index}]`));
+    return;
+  }
+  if (typeof value !== "object" || value === null) return;
+  for (const [key, entry] of Object.entries(value)) {
+    const normalizedKey = key.replace(/[_-]/g, "").toLowerCase();
+    if (FORBIDDEN_DECISION_ARGUMENT_KEYS.has(normalizedKey)) {
+      throw new Error(`Decision ${path}.${key} contains a forbidden secret field.`);
+    }
+    assertDecisionArgumentsSafe(entry, `${path}.${key}`);
+  }
+}
+function buildDecisionContract(prompt, options) {
+  const normalizedPrompt = prompt.trim();
+  if (!normalizedPrompt) throw new Error("Decision prompt must not be empty.");
+  if (options.length < 2) throw new Error("A decision must contain at least two options.");
+  const ids = /* @__PURE__ */ new Set();
+  let actionableOptions = 0;
+  let noActionOptions = 0;
+  for (const option of options) {
+    if (!/^[a-z][a-z0-9_]*$/.test(option.id)) {
+      throw new Error(`Invalid decision option id: ${option.id}`);
+    }
+    if (ids.has(option.id)) throw new Error(`Duplicate decision option id: ${option.id}`);
+    ids.add(option.id);
+    if (!option.label.trim() || !option.description.trim()) {
+      throw new Error(`Decision option ${option.id} requires a label and description.`);
+    }
+    if (option.nextAction.type === "none") {
+      noActionOptions += 1;
+      continue;
+    }
+    actionableOptions += 1;
+    if (option.nextAction.type === "call_tool" && !TARGET_MCP_TOOL_NAMES.includes(option.nextAction.tool)) {
+      throw new Error(`Unknown MCP decision tool: ${String(option.nextAction.tool)}`);
+    }
+    if (option.nextAction.type === "call_tool") {
+      assertDecisionArgumentsSafe(option.nextAction.arguments);
+    }
+  }
+  if (actionableOptions === 0) throw new Error("A decision requires an actionable option.");
+  if (noActionOptions === 0) throw new Error("A decision requires a no-action exit option.");
+  return {
+    decisionVersion: 1,
+    prompt: normalizedPrompt,
+    selectionMode: "single",
+    selectionRequired: true,
+    defaultOptionId: null,
+    options
+  };
+}
+function formatDecisionFallback(decision) {
+  const options = decision.options.map((option, index) => {
+    const consequences = option.consequences.length === 0 ? "" : `
+   Consequences: ${option.consequences.join(" ")}`;
+    let exactAction;
+    switch (option.nextAction.type) {
+      case "call_tool":
+        exactAction = `If the user selects this option, call ${option.nextAction.tool} with these exact arguments: ${JSON.stringify(option.nextAction.arguments)}.`;
+        break;
+      case "open_url":
+        exactAction = `If the user selects this option, present this exact URL: ${option.nextAction.url}.`;
+        break;
+      case "none":
+        exactAction = "If the user selects this option, call no tool and make no change.";
+        break;
+    }
+    return `${index + 1}. [${option.id}] ${option.label}
+   ${option.description}${consequences}
+   ${exactAction}`;
+  });
+  return `USER DECISION REQUIRED: ${decision.prompt}
+No option is selected by default. Present every option to the user, do not choose on their behalf, and never reconstruct or guess tool arguments.
+
+` + options.join("\n\n");
+}
+function decisionToolResult(input) {
+  const decision = buildDecisionContract(input.prompt, input.options);
+  const actionable = decision.options.filter(
+    (option) => option.nextAction.type === "call_tool"
+  );
+  const nextActions = actionable.map((option) => ({
+    tool: option.nextAction.tool,
+    arguments: option.nextAction.arguments,
+    allowed: true,
+    ...option.nextAction.reasonCode === void 0 ? {} : { reasonCode: option.nextAction.reasonCode }
+  }));
+  let userAction;
+  if (input.legacyUserAction?.type === "confirm_in_mcp" && actionable.length === 1) {
+    const option = actionable[0];
+    if (option !== void 0) {
+      userAction = {
+        type: "confirm_in_mcp",
+        provider: input.legacyUserAction.provider,
+        expectedOutcome: option.description,
+        resumeWith: {
+          tool: option.nextAction.tool,
+          arguments: option.nextAction.arguments
+        }
+      };
+    }
+  } else if (input.legacyUserAction?.type === "select_site") {
+    userAction = {
+      type: "select_site",
+      provider: input.legacyUserAction.provider,
+      expectedOutcome: "Apply only the option explicitly selected by the user.",
+      options: actionable.map((option) => ({
+        label: option.label,
+        value: typeof option.nextAction.arguments["reuseSiteUrl"] === "string" ? option.nextAction.arguments["reuseSiteUrl"] : option.id,
+        expectedOutcome: option.description
+      }))
+    };
+  }
+  return structuredToolResult({
+    schemaVersion: 1,
+    outcome: input.outcome ?? "waiting_user",
+    resultCode: input.resultCode,
+    ...input.operationId === void 0 ? {} : { operationId: input.operationId },
+    summary: `${input.summary}
+
+${formatDecisionFallback(decision)}`,
+    data: input.data,
+    decision,
+    ...userAction === void 0 ? {} : { userAction },
+    nextActions
+  });
+}
+function callToolDecisionOption(input) {
+  return {
+    id: input.id,
+    label: input.label,
+    description: input.description,
+    consequences: input.consequences ?? [],
+    nextAction: {
+      type: "call_tool",
+      tool: input.tool,
+      arguments: input.arguments,
+      ...input.reasonCode === void 0 ? {} : { reasonCode: input.reasonCode }
+    }
+  };
+}
+function noActionDecisionOption(input) {
+  return {
+    id: input?.id ?? "cancel",
+    label: input?.label ?? "Do not continue",
+    description: input?.description ?? "Keep the current local and cloud state unchanged.",
+    consequences: [],
+    nextAction: { type: "none" }
+  };
+}
+
 // src/tools/definitions.ts
 function text(resultCode, t, data = {}, outcome = "completed", nextActions = []) {
   return structuredToolResult({
@@ -3539,17 +3755,10 @@ ${block}`, checklist: toDnsChecklist(diag.checks) };
   }
 }
 function freeSiteCreationBarrier(sites, deployArguments) {
-  const userSiteOptions = sites.map((site) => ({
-    label: `Replace content at ${site.url}`,
-    value: site.url,
-    expectedOutcome: "A site handoff keeps this existing free-site URL, replaces its online content, issues a fresh project credential, and revokes every previous credential."
-  }));
   const summary = `Sakupa cloud confirmed that this network already has ${FREE_ACTIVE_SITES_PER_IP} active free sites, so no new site was created. Authenticated device discovery found ${sites.length} free site(s) this device can hand off.
 
 ` + sites.map((site) => `- ${site.url} (expires ${site.expiresAt})`).join("\n") + "\n\nThe free-site allowance is full. Ask the user which existing free URL may have its content REPLACED by the current project. Selecting one authorizes a site handoff: deploy keeps that URL, overwrites its online content with the current files, issues a fresh project credential, and revokes every previous credential. The cloud site is NOT deleted. No prior project directory, browser history, workspace switch, or user-run command is required. YOU then call deploy with the exact nextAction arguments. Never ask the user to locate an old directory or run a CLI, and never recommend another hosting provider.";
-  return structuredToolResult({
-    schemaVersion: 1,
-    outcome: "waiting_user",
+  return decisionToolResult({
     resultCode: "free_site_slot_selection_required",
     summary,
     data: {
@@ -3561,23 +3770,32 @@ function freeSiteCreationBarrier(sites, deployArguments) {
       cloudSiteWillBeDeleted: false,
       previousProjectWillBeUnbound: true
     },
-    userAction: {
-      type: "select_site",
-      provider: "sakupa",
-      expectedOutcome: "The selected URL remains while its content is replaced and all previous credentials are revoked.",
-      options: userSiteOptions
-    },
-    nextActions: sites.map((site) => ({
-      tool: "deploy",
-      arguments: {
-        ...deployArguments,
-        publicConfirmed: true,
-        reuseSiteUrl: site.url,
-        reuseConfirmed: true
-      },
-      allowed: true,
-      reasonCode: "user_selected_reusable_free_site"
-    }))
+    prompt: "Choose exactly one existing free URL that the current project may take over.",
+    options: [
+      ...sites.map(
+        (site, index) => callToolDecisionOption({
+          id: `handoff_site_${index + 1}`,
+          label: `Replace content at ${site.url}`,
+          description: "Keep this existing free-site URL and replace its online content with the current project.",
+          consequences: [
+            "A fresh project credential is issued and every previous credential is revoked.",
+            "The cloud site is not deleted and no previous project directory is needed."
+          ],
+          tool: "deploy",
+          arguments: {
+            ...deployArguments,
+            publicConfirmed: true,
+            reuseSiteUrl: site.url,
+            reuseConfirmed: true
+          },
+          reasonCode: "user_selected_reusable_free_site"
+        })
+      ),
+      noActionDecisionOption({
+        description: "Do not take over any existing free site and create no new site."
+      })
+    ],
+    legacyUserAction: { type: "select_site", provider: "sakupa" }
   });
 }
 async function discoverDeviceFreeSites(client, apiBaseUrl, device) {
@@ -3709,18 +3927,39 @@ Next action: ${analysis.suggestedNextAction}`,
         const effectiveOutputDir = analysis.recommendedOutputDir ?? ".";
         const recordedOutputDir = ctx.projectMarker?.outputDir;
         if (recordedOutputDir !== void 0 && resolve5(ctx.projectDir, recordedOutputDir) !== resolve5(ctx.projectDir, effectiveOutputDir) && args.outputDirChangeConfirmed !== true) {
-          return structuredToolResult({
-            schemaVersion: 1,
-            outcome: "waiting_user",
+          const confirmation = { outputDirChangeConfirmed: true };
+          const confirmArguments = {
+            ...args,
+            outputDir: effectiveOutputDir,
+            ...confirmation
+          };
+          return decisionToolResult({
             resultCode: "publish_directory_change_confirmation_required",
             summary: `This initialized project last published from "${recordedOutputDir}", but this request selected "${effectiveOutputDir}". Nothing was uploaded and the site was not changed. Show both paths to the user; only after explicit confirmation call deploy again with outputDirChangeConfirmed: true.`,
             data: {
               projectDir: ctx.projectDir,
               previousOutputDir: recordedOutputDir,
               requestedOutputDir: effectiveOutputDir,
-              confirmationField: "outputDirChangeConfirmed"
+              confirmationField: "outputDirChangeConfirmed",
+              confirmation,
+              confirmArguments
             },
-            nextActions: [{ tool: "deploy", allowed: true, reasonCode: "explicit_confirmation" }]
+            prompt: `Use the newly selected publish directory "${effectiveOutputDir}"?`,
+            options: [
+              callToolDecisionOption({
+                id: "use_new_publish_directory",
+                label: `Use ${effectiveOutputDir}`,
+                description: "Publish this project from the newly selected directory.",
+                consequences: [`The recorded publish directory changes from ${recordedOutputDir}.`],
+                tool: "deploy",
+                arguments: confirmArguments,
+                reasonCode: "explicit_confirmation"
+              }),
+              noActionDecisionOption({
+                description: "Keep the recorded publish directory and upload nothing."
+              })
+            ],
+            legacyUserAction: { type: "confirm_in_mcp", provider: "sakupa" }
           });
         }
         const files = analysis.files;
@@ -3775,24 +4014,37 @@ Next action: ${analysis.suggestedNextAction}`,
           }
           if (nestedMarker.kind === "ok") {
             if (args.sakupaRelocationConfirmed !== true) {
-              return structuredToolResult({
-                schemaVersion: 1,
-                outcome: "waiting_user",
+              const confirmation = { sakupaRelocationConfirmed: true };
+              const confirmArguments = { ...args, ...confirmation };
+              return decisionToolResult({
                 resultCode: "sakupa_relocation_confirmation_required",
                 summary: `A nested Sakupa project marker exists at ${candidateDir}/.sakupa, but the active MCP Root is ${ctx.projectDir}. Nothing was moved or deployed. Show both paths to the user; after confirmation retry deploy with sakupaRelocationConfirmed:true. Sakupa will preserve credentials and refuse conflicts.`,
                 data: {
                   projectRoot: ctx.projectDir,
                   misplacedSakupaDirectory: join9(candidateDir, ".sakupa"),
                   targetSakupaDirectory: join9(ctx.projectDir, ".sakupa"),
-                  confirmationField: "sakupaRelocationConfirmed"
+                  confirmationField: "sakupaRelocationConfirmed",
+                  confirmation,
+                  confirmArguments
                 },
-                nextActions: [
-                  {
+                prompt: "Move the nested Sakupa project binding to the active workspace Root?",
+                options: [
+                  callToolDecisionOption({
+                    id: "relocate_sakupa_binding",
+                    label: "Move the Sakupa binding to the workspace Root",
+                    description: "Validate and relocate the nested Sakupa binding, then continue this deployment.",
+                    consequences: [
+                      "Sakupa preserves valid credentials and refuses conflicting bindings."
+                    ],
                     tool: "deploy",
-                    allowed: true,
+                    arguments: confirmArguments,
                     reasonCode: "explicit_sakupa_relocation_confirmation"
-                  }
-                ]
+                  }),
+                  noActionDecisionOption({
+                    description: "Leave both directories unchanged and upload nothing."
+                  })
+                ],
+                legacyUserAction: { type: "confirm_in_mcp", provider: "sakupa" }
               });
             }
             markerRelocatedFrom.push(candidateDir);
@@ -3915,19 +4167,41 @@ Next action: ${analysis.suggestedNextAction}`,
           deleteProjectMarker(dir);
         }
         if (!existing && args.reuseSiteUrl === void 0 && args.publicConfirmed !== true) {
-          return text(
-            "public_deployment_confirmation_required",
-            `First deployment creates a public URL that anyone with the link can open. The free preview stays live for ${FREE_SITE_TTL_HOURS} hours. Explain this to the user and obtain explicit confirmation before retrying deploy with publicConfirmed: true.`,
-            { publicUrlLifetimeHours: FREE_SITE_TTL_HOURS, confirmationField: "publicConfirmed" },
-            "waiting_user"
-          );
+          const confirmation = { publicConfirmed: true };
+          const confirmArguments = { ...args, ...confirmation };
+          return decisionToolResult({
+            resultCode: "public_deployment_confirmation_required",
+            summary: `First deployment creates a public URL that anyone with the link can open. The free preview stays live for ${FREE_SITE_TTL_HOURS} hours. Nothing has been uploaded or made public yet. The exact confirmation field is publicConfirmed: true.`,
+            data: {
+              publicUrlLifetimeHours: FREE_SITE_TTL_HOURS,
+              confirmationField: "publicConfirmed",
+              confirmation,
+              confirmArguments
+            },
+            prompt: "Create the first public free-site preview for this project?",
+            options: [
+              callToolDecisionOption({
+                id: "create_public_preview",
+                label: "Create the public preview",
+                description: `Publish the selected files at a public URL for ${FREE_SITE_TTL_HOURS} hours.`,
+                consequences: ["Anyone with the generated URL can open the site."],
+                tool: "deploy",
+                arguments: confirmArguments,
+                reasonCode: "explicit_public_deployment_confirmation"
+              }),
+              noActionDecisionOption({
+                description: "Keep the project private and upload nothing."
+              })
+            ],
+            legacyUserAction: { type: "confirm_in_mcp", provider: "sakupa" }
+          });
         }
         if (!existing) {
           if (args.reuseSiteUrl !== void 0) {
             if (args.reuseConfirmed !== true) {
-              return structuredToolResult({
-                schemaVersion: 1,
-                outcome: "waiting_user",
+              const confirmation = { reuseConfirmed: true };
+              const confirmArguments = { ...args, publicConfirmed: true, ...confirmation };
+              return decisionToolResult({
                 resultCode: "free_site_reuse_confirmation_required",
                 summary: `Nothing was changed. Reusing ${args.reuseSiteUrl} will replace all online content at that URL with the current project, issue a fresh credential here, and revoke every previous credential automatically. No old directory is needed. Show these consequences and call deploy with reuseConfirmed:true only after the user explicitly selects this URL.`,
                 data: {
@@ -3935,25 +4209,29 @@ Next action: ${analysis.suggestedNextAction}`,
                   cloudSiteWillBeDeleted: false,
                   onlineContentWillBeReplaced: true,
                   previousProjectWillBeUnbound: true,
-                  confirmationField: "reuseConfirmed"
-                },
-                userAction: {
-                  type: "confirm_in_mcp",
-                  provider: "sakupa",
-                  expectedOutcome: "Replace the selected free URL content and move its local project binding.",
-                  resumeWith: {
-                    tool: "deploy",
-                    arguments: { ...args, publicConfirmed: true, reuseConfirmed: true }
-                  }
+                  confirmationField: "reuseConfirmed",
+                  confirmation,
+                  confirmArguments
                 },
-                nextActions: [
-                  {
+                prompt: `Take over ${args.reuseSiteUrl} with the current project?`,
+                options: [
+                  callToolDecisionOption({
+                    id: "confirm_site_handoff",
+                    label: `Take over ${args.reuseSiteUrl}`,
+                    description: "Keep the selected URL and replace all online content with the current project.",
+                    consequences: [
+                      "A fresh credential is issued here and every previous credential is revoked.",
+                      "The previous project becomes unbound; the cloud site is not deleted."
+                    ],
                     tool: "deploy",
-                    arguments: { ...args, publicConfirmed: true, reuseConfirmed: true },
-                    allowed: true,
+                    arguments: confirmArguments,
                     reasonCode: "explicit_free_site_reuse_confirmation"
-                  }
-                ]
+                  }),
+                  noActionDecisionOption({
+                    description: "Keep the selected site and current project unchanged."
+                  })
+                ],
+                legacyUserAction: { type: "confirm_in_mcp", provider: "sakupa" }
               });
             }
           }
@@ -4780,10 +5058,59 @@ After the DNS record resolves, re-run recover with verificationId: "${res2.verif
         }
         if (args.action === "status") {
           const res2 = await ctx.client.getRecoveryStatus(verificationId);
+          if (res2.readyToComplete) {
+            const revokeArguments = {
+              action: "complete",
+              verificationId,
+              preserveExistingCredentials: false,
+              ...args.outputDir !== void 0 ? { outputDir: args.outputDir } : {}
+            };
+            const preserveArguments = {
+              ...revokeArguments,
+              preserveExistingCredentials: true
+            };
+            return decisionToolResult({
+              resultCode: "domain_recovery_ready",
+              summary: "DNS control is verified and recovery is ready to complete. Nothing was completed yet. The user must choose whether previous site credentials remain valid.",
+              data: {
+                recovery: res2,
+                credentialPolicyChoices: ["revoke_previous", "preserve_previous"]
+              },
+              prompt: "How should Sakupa handle the site credentials that existed before recovery?",
+              options: [
+                callToolDecisionOption({
+                  id: "revoke_previous_credentials",
+                  label: "Revoke all previous credentials",
+                  description: "Complete recovery with the new local credential and revoke every previous credential.",
+                  consequences: [
+                    "Old project folders and credential backups can no longer manage the site."
+                  ],
+                  tool: "recover",
+                  arguments: revokeArguments,
+                  reasonCode: "user_selected_secure_recovery"
+                }),
+                callToolDecisionOption({
+                  id: "preserve_previous_credentials",
+                  label: "Keep previous credentials valid",
+                  description: "Complete recovery with the new local credential without revoking existing credentials.",
+                  consequences: [
+                    "Any old project folder or leaked credential that still works retains site authority."
+                  ],
+                  tool: "recover",
+                  arguments: preserveArguments,
+                  reasonCode: "user_selected_credential_preservation"
+                }),
+                noActionDecisionOption({
+                  label: "Do not complete recovery yet",
+                  description: "Keep the verified recovery pending and change no credential."
+                })
+              ]
+            });
+          }
           return structuredToolResult({
             schemaVersion: 1,
-            outcome: res2.status === "expired" ? "expired" : res2.readyToComplete ? "completed" : "pending_provider",
-            resultCode: res2.status === "expired" ? "domain_recovery_expired" : res2.readyToComplete ? "domain_recovery_ready" : "domain_recovery_pending_dns",
+            outcome: res2.status === "expired" ? "expired" : "pending_provider",
+            resultCode: res2.status === "expired" ? "domain_recovery_expired" : "domain_recovery_pending_dns",
             summary: `DNS recovery verification status: ${res2.status}`,
             data: { recovery: res2 },
             nextActions: [
@@ -4794,8 +5121,8 @@ After the DNS record resolves, re-run recover with verificationId: "${res2.verif
                   verificationId,
                   ...args.outputDir !== void 0 ? { outputDir: args.outputDir } : {}
                 },
-                allowed: res2.readyToComplete,
-                ...res2.readyToComplete ? {} : { reasonCode: res2.status }
+                allowed: false,
+                reasonCode: res2.status
               }
             ]
           });
@@ -4965,12 +5292,39 @@ Files: ${extracted.fileCount}; bytes: ${extracted.totalBytes}
         };
         if (args.confirmSubmit !== true) {
           const contactNote = args.contactEmail !== void 0 ? "note that their contact email is attached for follow-up. " : "ASK THEM ONCE whether they want to attach a contact email for follow-up (optional \u2014 omit if declined; include it as contactEmail when they do). ";
-          return textJson(
-            "bug_report_preview_ready",
-            `Bug report prepared but NOT submitted. This is the exact payload that would be sent (structured diagnostics only \u2014 no file contents, source code or secrets). Show it to the user, and ${contactNote}Then re-run report with confirmSubmit: true to submit.`,
-            payload,
-            "preview"
-          );
+          const confirmation = { confirmSubmit: true };
+          const confirmArguments = { ...args, ...confirmation };
+          return decisionToolResult({
+            resultCode: "bug_report_preview_ready",
+            outcome: "preview",
+            summary: `Bug report prepared but NOT submitted. This is the exact payload that would be sent (structured diagnostics only \u2014 no file contents, source code or secrets). Show it to the user, and ${contactNote}Exact payload:
+${JSON.stringify(payload, null, 2)}`,
+            data: {
+              result: payload,
+              confirmation,
+              confirmArguments,
+              submitted: false
+            },
+            prompt: "Submit this exact sanitized bug report?",
+            options: [
+              callToolDecisionOption({
+                id: "submit_bug_report",
+                label: "Submit the reviewed report",
+                description: "Submit exactly the sanitized payload shown above.",
+                consequences: [
+                  args.contactEmail === void 0 ? "No contact email is attached." : "The provided contact email is attached for follow-up."
+                ],
+                tool: "report",
+                arguments: confirmArguments,
+                reasonCode: "explicit_bug_report_submission_confirmation"
+              }),
+              noActionDecisionOption({
+                label: "Do not submit the report",
+                description: "Keep the report local and send nothing to Sakupa."
+              })
+            ],
+            legacyUserAction: { type: "confirm_in_mcp", provider: "sakupa" }
+          });
         }
         const res = await baseCtx.client.reportBug(payload, site?.credential);
         return text(
@@ -5367,8 +5721,18 @@ function registerHelpTools(server, baseCtx) {
             schemaVersion: 1,
             outcome: "completed",
             resultCode: "help_overview",
-            summary: 'Sakupa tool overview and parameter names returned. Site handoff moves an existing free URL to the current project and replaces its credential as a safety consequence; credential rotation changes the credential in place solely for security. Both revoke prior values. Use help topic:"terminology" for every site/credential distinction. On any failure call help with topic:"diagnose" before retrying, support or report.',
-            data: { tools: catalog, toolOrder: TOOL_TOPICS, terminology: HELP_TERMINOLOGY },
+            summary: `Sakupa tool overview and parameter names returned. Site handoff moves an existing free URL to the current project and replaces its credential as a safety consequence; credential rotation changes the credential in place solely for security. Both revoke prior values. When a result contains decision, present every option, select none by default, and copy only the user's selected option nextAction exactly. Use help topic:"terminology" for every site/credential distinction. On any failure call help with topic:"diagnose" before retrying, support or report.`,
+            data: {
+              tools: catalog,
+              toolOrder: TOOL_TOPICS,
+              terminology: HELP_TERMINOLOGY,
+              decisionOptions: {
+                selectionMode: "single",
+                defaultOptionId: null,
+                presentEveryOption: true,
+                exactNextActionRequired: true
+              }
+            },
             nextActions: []
           });
         }
@@ -5527,9 +5891,7 @@ function registerCredentialTools(server, baseCtx) {
         const status = await ctx.client.getCredentialStatus(site.siteId, site.credential);
         const confirmation = { confirmed: true };
         if (args.confirmed !== true) {
-          return structuredToolResult({
-            schemaVersion: 1,
-            outcome: "waiting_user",
+          return decisionToolResult({
             resultCode: "credential_rotation_confirmation_required",
             summary: `Nothing was changed. Rotating the management credential for ${site.url ?? site.siteId} will generate a new credential locally, save it as the current credential in this project .sakupa/site.json, and revoke EVERY previous credential for this site\u2014including copies in old folders and backups. Rotation is optional and deploy remains available. Current credential created at: ${status.credentialCreatedAt}. Exact confirm arguments: ${JSON.stringify(confirmation)}. Ask the user for explicit approval; never expose credential values.`,
             data: {
@@ -5542,20 +5904,26 @@ function registerCredentialTools(server, baseCtx) {
               previousCredentialsWillBeRevoked: true,
               optional: true
             },
-            userAction: {
-              type: "confirm_in_mcp",
-              provider: "sakupa",
-              expectedOutcome: "Generate one new local credential and revoke every previous credential for this site.",
-              resumeWith: { tool: "rotate", arguments: confirmation }
-            },
-            nextActions: [
-              {
+            prompt: `Rotate the management credential for ${site.url ?? site.siteId}?`,
+            options: [
+              callToolDecisionOption({
+                id: "rotate_credential",
+                label: "Rotate the management credential",
+                description: "Generate one new local credential and make it the only valid credential for this site.",
+                consequences: [
+                  "Every previous credential is revoked, including copies in old folders and backups.",
+                  "The site URL and online content do not change."
+                ],
                 tool: "rotate",
                 arguments: confirmation,
-                allowed: true,
                 reasonCode: "explicit_credential_rotation_confirmation"
-              }
-            ]
+              }),
+              noActionDecisionOption({
+                label: "Keep the current credential",
+                description: "Do not rotate; deployment remains available with the current credential."
+              })
+            ],
+            legacyUserAction: { type: "confirm_in_mcp", provider: "sakupa" }
           });
         }
         writeCredentialRotation(ctx.projectDir, {
@@ -5784,6 +6152,14 @@ Workflow:
    payment, refund and other customer-service requests. report is the LAST resort only when
    help explicitly recommends a product bug report, and submission still requires user review.
 
+Decision-options contract: when a result contains decision, present EVERY numbered option from the
+tool to the user and wait for their selection. No option is selected by default. Never choose from
+context, paraphrase a selection into different arguments, or invent another option. After the user
+selects, copy that option's exact nextAction. Legacy userAction and nextActions mirror the same
+choice for older clients; decision is the authoritative choice set. A type "none" option means call
+no tool and change nothing. Stripe-hosted links remain direct links because Stripe itself owns plan
+selection and confirmation.
+
 Project directory contract: before the first deploy or a new recovery, initialize the intended
 project by calling init with NO path argument. init uses the IDE's exact MCP Root and creates the
 non-secret .sakupa/project.json directly there. The CLI command