@sakupa/mcp 0.7.7 → 0.7.9

package/dist/bin.js

@@ -10,6 +10,7 @@ var FREE_SITE_URL_SUFFIX = `.${SERVICE_DOMAIN}`;
 var TEST_ACCESS_HEADER = "x-sakupa-test-token";
 var FREE_SITE_TTL_HOURS = 24;
 var FREE_SITE_MAX_TOTAL_BYTES = 10 * 1024 * 1024;
+var FREE_ACTIVE_SITES_PER_IP = 3;
 var PAID_SITE_MAX_TOTAL_BYTES = 2 * 1024 * 1024 * 1024;
 var MAX_FILE_COUNT = 5e3;
 var MAX_SINGLE_FILE_BYTES = 25 * 1024 * 1024;
@@ -128,7 +129,7 @@ var FORBIDDEN_PATH_SEGMENTS = [
 var ALLOWED_HIDDEN_PATHS = [".well-known/"];
 
 // ../core/dist/domain/version.js
-var SAKUPA_MCP_VERSION = "0.7.7";
+var SAKUPA_MCP_VERSION = "0.7.9";
 
 // ../core/dist/domain/errors.js
 var HTTP_STATUS = {
@@ -457,10 +458,10 @@ var WEBHOOK_PROCESSING_LEASE_MS = 5 * 60 * 1e3;
 // src/config.ts
 var TEST_API_BASE_URL = "https://api-test.sakupa.com";
 function previewHostPatternFor(apiBaseUrl) {
-  return apiBaseUrl === TEST_API_BASE_URL ? "{shortId}-test.sakupa.com" : "{shortId}.sakupa.com";
+  return environmentFor(apiBaseUrl) === "test" ? "{shortId}-test.sakupa.com" : "{shortId}.sakupa.com";
 }
 function loadMcpRuntimeConfig(env = process.env, cwd = process.cwd()) {
-  const apiBaseUrl = (env["SAKUPA_API_URL"] ?? DEFAULT_API_BASE_URL).replace(/\/+$/, "");
+  const apiBaseUrl = (env["SAKUPA_API_URL"] ?? env["SAKUPA_API_BASE_URL"] ?? DEFAULT_API_BASE_URL).replace(/\/+$/, "");
   const projectDir = env["SAKUPA_PROJECT_DIR"] ?? cwd;
   const testAccessToken = env["SAKUPA_TEST_ACCESS_TOKEN"]?.trim() ?? "";
   if (apiBaseUrl === TEST_API_BASE_URL) {
@@ -478,6 +479,9 @@ function loadMcpRuntimeConfig(env = process.env, cwd = process.cwd()) {
   }
   return { apiBaseUrl, projectDir };
 }
+function environmentFor(apiBaseUrl) {
+  return apiBaseUrl === TEST_API_BASE_URL ? "test" : "production";
+}
 
 // src/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -590,11 +594,14 @@ var HttpApiClient = class {
   async bindDomain(credential, req) {
     return this.call("POST", "/v1/domains/bind", { credential, body: req });
   }
-  async checkVerification(verificationId, credential) {
+  async checkVerification(verificationId, credential, latestForSiteId) {
     return this.call(
       "POST",
       `/v1/domains/verifications/${encodeURIComponent(verificationId)}/check`,
-      { credential }
+      {
+        credential,
+        ...latestForSiteId !== void 0 ? { body: { siteId: latestForSiteId } } : {}
+      }
     );
   }
   async unbindDomain(siteId, credential, req) {
@@ -680,8 +687,8 @@ var HttpApiClient = class {
 // src/tools/definitions.ts
 import { randomUUID } from "node:crypto";
 import { promises as fs2 } from "node:fs";
-import { join as join3, resolve as resolve2 } from "node:path";
-import { z as z2 } from "zod";
+import { join as join4, resolve as resolve3 } from "node:path";
+import { z as z3 } from "zod";
 
 // src/analyze/analyzer.ts
 import { promises as fs } from "node:fs";
@@ -1203,10 +1210,165 @@ function credentialGitReminder(projectDir) {
   return '\nNOTE: this project is inside a git repository. The management credential in .sakupa/site.json is the key to this site \u2014 do NOT commit it to a PUBLIC repository (add ".sakupa/" to .gitignore yourself if you want to keep it out of version control).';
 }
 
+// src/creation-registry.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { homedir } from "node:os";
+import { dirname as dirname2, join as join3 } from "node:path";
+var RECENT_WINDOW_MS = FREE_SITE_TTL_HOURS * 60 * 60 * 1e3;
+function creationRegistryPath() {
+  const base = process.env["SAKUPA_STATE_DIR"] ?? homedir();
+  return join3(base, ".sakupa", "created-sites.json");
+}
+function readAll() {
+  const path = creationRegistryPath();
+  if (!existsSync2(path)) return [];
+  try {
+    const parsed = JSON.parse(readFileSync2(path, "utf-8"));
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter(
+      (e) => typeof e === "object" && e !== null && typeof e.siteId === "string" && typeof e.createdAt === "string"
+    );
+  } catch {
+    return [];
+  }
+}
+function writeAll(records) {
+  const path = creationRegistryPath();
+  mkdirSync2(dirname2(path), { recursive: true });
+  writeFileSync2(path, `${JSON.stringify(records, null, 2)}
+`, "utf-8");
+}
+function listRecentCreations(nowMs) {
+  return readAll().filter((e) => {
+    const t = Date.parse(e.createdAt);
+    return Number.isFinite(t) && nowMs - t < RECENT_WINDOW_MS;
+  });
+}
+function recordCreation(record) {
+  const rest = readAll().filter((e) => e.siteId !== record.siteId);
+  writeAll([...rest, record]);
+}
+function removeCreation(siteId) {
+  const all = readAll();
+  const rest = all.filter((e) => e.siteId !== siteId);
+  if (rest.length !== all.length) writeAll(rest);
+}
+
+// src/dns-doh.ts
+var dohFetch = (input, init) => fetch(input, init);
+var TYPE_CODES = { TXT: 16, CNAME: 5, A: 1 };
+async function resolveDns(name, type) {
+  const endpoints = [
+    `https://cloudflare-dns.com/dns-query?name=${encodeURIComponent(name)}&type=${type}`,
+    `https://dns.google/resolve?name=${encodeURIComponent(name)}&type=${type}`
+  ];
+  for (const url of endpoints) {
+    try {
+      const res = await dohFetch(url, { headers: { accept: "application/dns-json" } });
+      if (!res.ok) continue;
+      const body = await res.json();
+      return (body.Answer ?? []).filter((a) => a.type === TYPE_CODES[type]).map((a) => a.data.replace(/^"|"$/g, "").replace(/"\s+"/g, "")).map((v) => type === "CNAME" ? v.replace(/\.$/, "").toLowerCase() : v);
+    } catch {
+    }
+  }
+  return [];
+}
+function shortHostFor(fullName, apexDomain) {
+  const suffix = `.${apexDomain}`;
+  if (fullName === apexDomain) return "@";
+  return fullName.endsWith(suffix) ? fullName.slice(0, -suffix.length) : fullName;
+}
+function matches(record, values) {
+  if (record.type === "CNAME") {
+    const want = record.value.replace(/\.$/, "").toLowerCase();
+    return values.some((v) => v === want);
+  }
+  return values.includes(record.value);
+}
+async function checkRecord(record, apexDomain) {
+  const shortHost = shortHostFor(record.name, apexDomain);
+  const found = await resolveDns(record.name, record.type);
+  if (matches(record, found)) {
+    return { record, shortHost, state: "ok", found, fix: "" };
+  }
+  const doubled = await resolveDns(`${record.name}.${apexDomain}`, record.type);
+  if (matches(record, doubled)) {
+    return {
+      record,
+      shortHost,
+      state: "double_domain",
+      found: doubled,
+      fix: `The record exists at ${record.name}.${apexDomain} \u2014 the host field was filled with the full name and your DNS panel appended ${apexDomain} again. Edit that record's host to exactly: ${shortHost}`
+    };
+  }
+  if (found.length > 0) {
+    return {
+      record,
+      shortHost,
+      state: "wrong_value",
+      found,
+      fix: `A ${record.type} record exists at ${record.name} but its value is ${JSON.stringify(found)} instead of "${record.value}". Update the value exactly.`
+    };
+  }
+  return {
+    record,
+    shortHost,
+    state: "missing",
+    found,
+    fix: `Create it now \u2014 type: ${record.type}, host: ${shortHost} (most panels append .${apexDomain} automatically; if yours wants the full name use ${record.name}), value: ${record.value}`
+  };
+}
+function renderCheck(c) {
+  const label = `${c.record.type} ${c.shortHost}`;
+  switch (c.state) {
+    case "ok":
+      return `  [OK] ${label} \u2014 live on public DNS.`;
+    case "double_domain":
+      return `  [FIX] ${label} \u2014 ${c.fix}`;
+    case "wrong_value":
+      return `  [FIX] ${label} \u2014 ${c.fix}`;
+    case "missing":
+      return `  [MISSING] ${label} \u2014 ${c.fix}`;
+  }
+}
+async function diagnoseBinding(input) {
+  const apex = input.apexDomain;
+  const byKey = /* @__PURE__ */ new Map();
+  if (input.verificationRecord) {
+    byKey.set(`TXT:${input.verificationRecord.name}`, input.verificationRecord);
+  }
+  const www = {
+    name: `www.${apex}`,
+    type: "CNAME",
+    value: input.servingTarget
+  };
+  byKey.set(`CNAME:${www.name}`, www);
+  for (const rec of input.pendingDnsRecords) {
+    const key = `${rec.type}:${rec.name}`;
+    if (!byKey.has(key)) byKey.set(key, rec);
+  }
+  const [checks, apexAnswers] = await Promise.all([
+    Promise.all([...byKey.values()].map((rec) => checkRecord(rec, apex))),
+    resolveDns(apex, "A")
+  ]);
+  const apexResolves = apexAnswers.length > 0;
+  const allOk = checks.every((c) => c.state === "ok");
+  const checklist = checks.map(renderCheck).join("\n") + `
+  [${apexResolves ? "OK" : "MISSING"}] APEX ${apex} \u2014 ` + (apexResolves ? "resolves." : `does not resolve yet: point it at ${input.servingTarget} using your DNS panel's ALIAS / ANAME / CNAME-flattening feature (an apex cannot use a plain CNAME).`);
+  const layers = `Pipeline: [1] public DNS (checked LIVE above) -> [2] Sakupa ownership verification: ${input.verificationStatus} -> [3] HTTPS certificate & serving: ` + (input.provisioning ? "provisioning (Cloudflare validates and issues within minutes once the records above are all OK; Sakupa retries automatically every ~5 minutes)." : "starts after verification.");
+  return { checks, apexResolves, allOk, checklist, layers };
+}
+
 // src/version.ts
 var MCP_VERSION = SAKUPA_MCP_VERSION;
 var CLIENT_TYPE = "sakupa-mcp";
 
+// src/tools/context.ts
+import { z as z2 } from "zod";
+import { statSync } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { isAbsolute, parse, resolve as resolve2 } from "node:path";
+
 // src/tools/result.ts
 import { z } from "zod";
 var STRUCTURED_TOOL_OUTPUT_SCHEMA = {
@@ -1249,22 +1411,64 @@ function structuredToolResult(envelope) {
 }
 
 // src/tools/context.ts
+var LocalGuidanceError = class extends SakupaError {
+  constructor(code, message) {
+    super(code, message);
+  }
+};
+var projectDirInput = z2.string().optional().describe(
+  "Absolute path of the project directory the user is CURRENTLY working in (the folder holding the site files and .sakupa). Always pass it explicitly; when omitted the server falls back to its startup directory, which may not be where the user is working now."
+);
+function withProjectDir(ctx, projectDirArg) {
+  if (projectDirArg === void 0) return ctx;
+  if (!isAbsolute(projectDirArg)) {
+    throw new LocalGuidanceError(
+      "invalid_request",
+      `projectDir must be an ABSOLUTE path (got "${projectDirArg}"). Pass the full path of the directory the user is currently working in.`
+    );
+  }
+  const dir = resolve2(projectDirArg);
+  if (parse(dir).root === dir || dir === homedir2()) {
+    throw new LocalGuidanceError(
+      "invalid_request",
+      `projectDir "${dir}" is a filesystem root or the home directory. Pass the specific project folder that holds the site's files, not a top-level directory.`
+    );
+  }
+  const stat = statSync(dir, { throwIfNoEntry: false });
+  if (!stat?.isDirectory()) {
+    throw new LocalGuidanceError(
+      "invalid_request",
+      `projectDir "${dir}" does not exist or is not a directory. Pass the absolute path of the directory the user is currently working in.`
+    );
+  }
+  return { ...ctx, projectDir: dir };
+}
 function requireSiteFile(ctx) {
   const state = loadSiteFile(ctx.projectDir);
   if (state.kind === "corrupted") {
-    throw new SakupaError(
+    throw new LocalGuidanceError(
       "invalid_request",
       `.sakupa/site.json in ${ctx.projectDir} is damaged: ${state.problem}. ` + siteFileRecoveryGuidance(ctx.projectDir)
     );
   }
   if (state.kind === "absent") {
-    throw new SakupaError(
+    throw new LocalGuidanceError(
       "not_found",
       `No .sakupa/site.json found in ${ctx.projectDir}. This project has no Sakupa site binding yet \u2014 run deploy_site first to publish it (the management credential will be stored locally in .sakupa/site.json). If this was a paid custom-domain site whose project file was lost, use recover_domain_site instead.`
     );
   }
   return state.file;
 }
+var STATIC_SUMMARY = {
+  not_found: "The required local project binding or resource is unavailable; if this project has no .sakupa/site.json yet, run deploy_site first.",
+  unauthorized: "The server rejected the site credential: the one in .sakupa/site.json no longer matches the server-side verifier. The site itself is intact on the server \u2014 only the local binding file is the problem. Repair the file (restore a backup or undo the local edit). Do NOT delete the .sakupa directory to work around this: the credential is unrecoverable by design, so abandoning it permanently orphans the existing site.",
+  invalid_request: "The request arguments or local project checks did not pass.",
+  validation_failed: "The request arguments or local project checks did not pass.",
+  state_conflict: "The resource state has changed; re-query the current status before deciding the next step.",
+  confirmation_required: "The site or billing state changed, so the previous confirmation is stale; run the preview again and confirm against the fresh snapshot.",
+  payment_required: "This operation requires an active subscription; check billing_status first.",
+  rate_limited: "The server rate limit was reached; retry after the returned wait time."
+};
 function toolError(e) {
   const errorCode = isSakupaError(e) ? e.code : "internal";
   const retryable = errorCode === "rate_limited" || errorCode === "internal";
@@ -1283,7 +1487,7 @@ function toolError(e) {
     )
   ) : void 0;
   const minimumVersion = rawDetails && typeof rawDetails["minimumVersion"] === "string" ? rawDetails["minimumVersion"] : void 0;
-  const safeSummary = errorCode === "upgrade_required" ? `This Sakupa MCP client is v${MCP_VERSION}, older than the server's minimum supported version${minimumVersion !== void 0 ? ` (v${minimumVersion})` : ""}, so the server refused the call. To fix it: ask the user to fully restart their MCP client session \u2014 "npx -y @sakupa/mcp@latest" setups fetch the current version on restart (run "npx clear-npx-cache" first if the old version persists); global installs need "npm install -g @sakupa/mcp@latest". After the restart, retry this exact tool call.` : errorCode === "not_found" ? "The required local project binding or resource is unavailable; if this project has no .sakupa/site.json yet, run deploy_site first." : errorCode === "unauthorized" ? "The server rejected the site credential: the one in .sakupa/site.json no longer matches the server-side verifier. The site itself is intact on the server \u2014 only the local binding file is the problem. Repair the file (restore a backup or undo the local edit). Do NOT delete the .sakupa directory to work around this: the credential is unrecoverable by design, so abandoning it permanently orphans the existing site." : errorCode === "invalid_request" || errorCode === "validation_failed" ? "The request arguments or local project checks did not pass." : errorCode === "state_conflict" ? "The resource state has changed; re-query the current status before deciding the next step." : errorCode === "confirmation_required" ? "The site or billing state changed, so the previous confirmation is stale; run the preview again and confirm against the fresh snapshot." : errorCode === "payment_required" ? "This operation requires an active subscription; check billing_status first." : errorCode === "rate_limited" ? "The server rate limit was reached; retry after the returned wait time." : retryable ? "An upstream service is temporarily unavailable or busy; retry shortly." : "The operation failed; no server-internal details are exposed.";
+  const safeSummary = e instanceof LocalGuidanceError ? e.message : errorCode === "upgrade_required" ? `This Sakupa MCP client is v${MCP_VERSION}, older than the server's minimum supported version${minimumVersion !== void 0 ? ` (v${minimumVersion})` : ""}, so the server refused the call. To fix it: ask the user to fully restart their MCP client session \u2014 "npx -y @sakupa/mcp@latest" setups fetch the current version on restart (run "npx clear-npx-cache" first if the old version persists); global installs need "npm install -g @sakupa/mcp@latest". After the restart, retry this exact tool call.` : STATIC_SUMMARY[errorCode] ?? (retryable ? "An upstream service is temporarily unavailable or busy; retry shortly." : "The operation failed; no server-internal details are exposed.");
   const result = structuredToolResult({
     schemaVersion: 1,
     outcome: "failed",
@@ -1322,12 +1526,12 @@ ${JSON.stringify(obj, null, 2)}`;
     nextActions: []
   });
 }
-var planEnum = z2.enum(["water", "personal", "share", "business"]);
-var severityEnum = z2.enum(["low", "medium", "high", "critical"]);
+var planEnum = z3.enum(["water", "personal", "share", "business"]);
+var severityEnum = z3.enum(["low", "medium", "high", "critical"]);
 function planCatalog() {
   return TIER_ORDER.map((p) => `${p} JPY ${tierPriceJpy(p)}/month`).join(", ");
 }
-var ticketCategoryEnum = z2.enum([
+var ticketCategoryEnum = z3.enum([
   "billing",
   "payment",
   "refund_review",
@@ -1375,7 +1579,7 @@ function ensureUploadSizeWithinLimits(manifest, isFirstFreeDeploy) {
 async function buildHashedManifest(files, outputAbs) {
   const manifest = [];
   for (const file of files) {
-    const bytes = new Uint8Array(await fs2.readFile(join3(outputAbs, file.path)));
+    const bytes = new Uint8Array(await fs2.readFile(join4(outputAbs, file.path)));
     manifest.push({ path: file.path, size: file.size, contentHash: await sha256Hex(bytes) });
   }
   return manifest;
@@ -1394,7 +1598,7 @@ async function uploadAll(ctx, targets, files, outputAbs) {
         `No local file matches upload target "${target.path}"; aborting upload.`
       );
     }
-    const bytes = new Uint8Array(await fs2.readFile(join3(outputAbs, match.path)));
+    const bytes = new Uint8Array(await fs2.readFile(join4(outputAbs, match.path)));
     if (bytes.byteLength !== match.size) {
       throw new SakupaError(
         "validation_failed",
@@ -1405,8 +1609,25 @@ async function uploadAll(ctx, targets, files, outputAbs) {
   }
   return targets.length;
 }
-function registerTools(server, ctx) {
-  const previewHostPattern = previewHostPatternFor(ctx.apiBaseUrl);
+var DNS_RETRY_AFTER_SECONDS = 300;
+var DNS_MAX_ATTEMPTS = 10;
+function freeSiteCreationBarrier() {
+  const recent = listRecentCreations(Date.now());
+  if (recent.length < FREE_ACTIVE_SITES_PER_IP) return null;
+  const registryPath = creationRegistryPath();
+  return text(
+    "local_site_limit_reached",
+    `This machine already created ${recent.length} free sites in the last 24 hours (the server also enforces ${FREE_ACTIVE_SITES_PER_IP} active free sites per IP). No new site was created.
+
+` + recent.map((r) => `- ${r.url} (project: ${r.projectDir}, created: ${r.createdAt})`).join("\n") + `
+
+Options: delete one of these sites (run delete_site with its projectDir), wait for a free site to expire, or \u2014 if this list is stale because sites were deleted or subscribed elsewhere \u2014 remove the local registry file at ${registryPath} and retry.`,
+    { recentCreations: recent, limit: FREE_ACTIVE_SITES_PER_IP, registryPath },
+    "blocked"
+  );
+}
+function registerTools(server, baseCtx) {
+  const previewHostPattern = previewHostPatternFor(baseCtx.apiBaseUrl);
   server.registerTool(
     "analyze_site",
     {
@@ -1414,11 +1635,13 @@ function registerTools(server, ctx) {
       outputSchema: STRUCTURED_TOOL_OUTPUT_SCHEMA,
       annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
       inputSchema: {
-        outputDir: z2.string().optional().describe("Output directory relative to the project root (overrides detection).")
+        projectDir: projectDirInput,
+        outputDir: z3.string().optional().describe("Output directory relative to the project root (overrides detection).")
       }
     },
     async (args) => {
       try {
+        const ctx = withProjectDir(baseCtx, args.projectDir);
         const analysis = await analyzeProject(ctx.projectDir, {
           ...args.outputDir !== void 0 ? { outputDir: args.outputDir } : {}
         });
@@ -1440,18 +1663,20 @@ Next action: ${analysis.suggestedNextAction}`,
       outputSchema: STRUCTURED_TOOL_OUTPUT_SCHEMA,
       annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: true },
       inputSchema: {
-        outputDir: z2.string().optional().describe("Output directory relative to the project root (overrides detection)."),
-        spaFallback: z2.boolean().optional().describe(
+        projectDir: projectDirInput,
+        outputDir: z3.string().optional().describe("Output directory relative to the project root (overrides detection)."),
+        spaFallback: z3.boolean().optional().describe(
           "Override automatic SPA-fallback detection (single index.html + JS auto-enables rewriting unknown paths to index.html; multiple HTML pages auto-disable it). Pass only to force the behavior against the detected structure."
         ),
-        publicConfirmed: z2.boolean().optional().describe(
+        publicConfirmed: z3.boolean().optional().describe(
           "Required only for the first deployment: user explicitly confirmed creation of a public 24-hour URL."
         ),
-        lang: z2.string().optional().describe("Site language override (en | ja | zh-CN); defaults to the html lang.")
+        lang: z3.string().optional().describe("Site language override (en | ja | zh-CN); defaults to the html lang.")
       }
     },
     async (args) => {
       try {
+        const ctx = withProjectDir(baseCtx, args.projectDir);
         const analysis = await analyzeProject(ctx.projectDir, {
           ...args.outputDir !== void 0 ? { outputDir: args.outputDir } : {}
         });
@@ -1459,7 +1684,7 @@ Next action: ${analysis.suggestedNextAction}`,
           return notDeployableResult(analysis);
         }
         const files = analysis.files;
-        const outputAbs = resolve2(ctx.projectDir, analysis.recommendedOutputDir ?? ".");
+        const outputAbs = resolve3(ctx.projectDir, analysis.recommendedOutputDir ?? ".");
         const manifest = await buildHashedManifest(files, outputAbs);
         const siteFileState = loadSiteFile(ctx.projectDir);
         if (siteFileState.kind === "corrupted") {
@@ -1473,6 +1698,10 @@ Next action: ${analysis.suggestedNextAction}`,
           );
         }
         const existing = siteFileState.kind === "ok" ? siteFileState.file : null;
+        if (!existing) {
+          const barrier = freeSiteCreationBarrier();
+          if (barrier) return barrier;
+        }
         if (!existing && args.publicConfirmed !== true) {
           return text(
             "public_deployment_confirmation_required",
@@ -1494,17 +1723,26 @@ Next action: ${analysis.suggestedNextAction}`,
             created.siteId,
             created.credential
           );
+          const createdAt = (/* @__PURE__ */ new Date()).toISOString();
           writeSiteFile(ctx.projectDir, {
             siteId: created.siteId,
             shortId: created.shortId,
             url: finalized2.url,
             credential: created.credential,
-            createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+            createdAt,
             apiBaseUrl: ctx.apiBaseUrl
           });
+          recordCreation({
+            siteId: created.siteId,
+            projectDir: ctx.projectDir,
+            url: finalized2.url,
+            createdAt
+          });
           return text(
             "site_published",
             `Site published: ${finalized2.url}
+Environment: ${environmentFor(ctx.apiBaseUrl).toUpperCase()} (${ctx.apiBaseUrl})
+Project directory: ${ctx.projectDir}
 Files uploaded: ${uploaded2} (${finalized2.totalBytes} bytes)
 ` + (finalized2.expiresAt ? `Expires at: ${finalized2.expiresAt}
 ` : "") + `
@@ -1522,7 +1760,9 @@ ${JSON.stringify(finalized2.warnings, null, 2)}` : ""),
               filesUploaded: uploaded2,
               totalBytes: finalized2.totalBytes,
               warnings: finalized2.warnings,
-              credentialStoredLocally: true
+              credentialStoredLocally: true,
+              projectDir: ctx.projectDir,
+              environment: environmentFor(ctx.apiBaseUrl)
             }
           );
         }
@@ -1568,6 +1808,8 @@ ${JSON.stringify(finalized2.warnings, null, 2)}` : ""),
         return text(
           "site_updated",
           `Site updated: ${finalized.url}
+Environment: ${environmentFor(ctx.apiBaseUrl).toUpperCase()} (${ctx.apiBaseUrl})
+Project directory: ${ctx.projectDir}
 Files uploaded: ${uploaded} (${finalized.totalBytes} bytes)
 ` + (finalized.expiresAt ? `Validity refreshed \u2014 expires at: ${finalized.expiresAt}
 ` : "") + (finalized.mode === "free" ? `
@@ -1579,6 +1821,8 @@ ${JSON.stringify(finalized.warnings, null, 2)}` : ""),
             siteId: existing.siteId,
             url: finalized.url,
             mode: finalized.mode,
+            projectDir: ctx.projectDir,
+            environment: environmentFor(ctx.apiBaseUrl),
             expiresAt: finalized.expiresAt,
             filesUploaded: uploaded,
             totalBytes: finalized.totalBytes,
@@ -1596,17 +1840,18 @@ ${JSON.stringify(finalized.warnings, null, 2)}` : ""),
       description: "Refresh the validity of the free temporary site WITHOUT uploading content. Uses the local credential in .sakupa/site.json. Subscribed sites are permanent and need no refresh.",
       outputSchema: STRUCTURED_TOOL_OUTPUT_SCHEMA,
       annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
-      inputSchema: {}
+      inputSchema: { projectDir: projectDirInput }
     },
-    async () => {
+    async (args) => {
       try {
+        const ctx = withProjectDir(baseCtx, args.projectDir);
         const site = requireSiteFile(ctx);
         const res = await ctx.client.refreshSite(site.siteId, site.credential);
         return text(
           "site_refreshed",
-          `Site validity refreshed. New expiry: ${res.expiresAt}
+          `Site validity refreshed (project: ${ctx.projectDir}). New expiry: ${res.expiresAt}
 NO content was uploaded or changed by this call \u2014 to publish new or edited files, run deploy_site. Free sites stay live for ${FREE_SITE_TTL_HOURS} hours after each deploy or refresh.`,
-          { siteId: site.siteId, expiresAt: res.expiresAt }
+          { siteId: site.siteId, expiresAt: res.expiresAt, projectDir: ctx.projectDir }
         );
       } catch (e) {
         return toolError(e);
@@ -1619,13 +1864,17 @@ NO content was uploaded or changed by this call \u2014 to publish new or edited
       description: "Show the current status of this project's Sakupa site: URL, mode (free/paid), expiry, subscription state, custom domains, size, last deployment and warnings.",
       outputSchema: STRUCTURED_TOOL_OUTPUT_SCHEMA,
       annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: true },
-      inputSchema: {}
+      inputSchema: { projectDir: projectDirInput }
     },
-    async () => {
+    async (args) => {
       try {
+        const ctx = withProjectDir(baseCtx, args.projectDir);
         const site = requireSiteFile(ctx);
         const res = await ctx.client.getSiteStatus(site.siteId, site.credential);
-        return textJson("site_status_returned", "Site status:", res);
+        return textJson("site_status_returned", "Site status:", {
+          ...res,
+          projectDir: ctx.projectDir
+        });
       } catch (e) {
         return toolError(e);
       }
@@ -1638,6 +1887,7 @@ NO content was uploaded or changed by this call \u2014 to publish new or edited
       outputSchema: STRUCTURED_TOOL_OUTPUT_SCHEMA,
       annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
       inputSchema: {
+        projectDir: projectDirInput,
         plan: planEnum.describe(
           "Monthly plan: water (very light personal pages), personal (personal brand / small shop), share (small-business site), business (steadier traffic, more headroom)."
         )
@@ -1645,6 +1895,7 @@ NO content was uploaded or changed by this call \u2014 to publish new or edited
     },
     async (args) => {
       try {
+        const ctx = withProjectDir(baseCtx, args.projectDir);
         const site = requireSiteFile(ctx);
         const res = await ctx.client.createPlanCheckout(
           {
@@ -1683,39 +1934,62 @@ Once payment confirms, the site becomes permanent on its current URL. Binding a
       outputSchema: STRUCTURED_TOOL_OUTPUT_SCHEMA,
       annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: true },
       inputSchema: {
-        action: z2.enum(["start", "status"]),
-        hostname: z2.string().optional().describe("Required for start."),
-        verificationId: z2.string().optional().describe("Required for status.")
+        projectDir: projectDirInput,
+        action: z3.enum(["start", "status"]),
+        hostname: z3.string().optional().describe("Required for start."),
+        verificationId: z3.string().optional().describe(
+          "Optional for status: when omitted, the server finds this site's latest binding verification \u2014 a NEW session can resume without it."
+        )
       }
     },
     async (args) => {
       try {
+        const ctx = withProjectDir(baseCtx, args.projectDir);
         const site = requireSiteFile(ctx);
         if (args.action === "status") {
-          if (!args.verificationId) {
-            throw new SakupaError("invalid_request", "verificationId is required for status");
-          }
-          const res2 = await ctx.client.checkVerification(args.verificationId, site.credential);
+          const res2 = args.verificationId ? await ctx.client.checkVerification(args.verificationId, site.credential) : await ctx.client.checkVerification("latest", site.credential, site.siteId);
           if (res2.status === "verified") {
             writeSiteFile(ctx.projectDir, { ...site, boundDomain: res2.apexDomain });
           }
+          const apex2 = res2.apexDomain;
+          const { checks, apexResolves, allOk, checklist, layers } = await diagnoseBinding({
+            apexDomain: apex2,
+            servingTarget: res2.servingTarget,
+            ...res2.verificationRecord ? { verificationRecord: res2.verificationRecord } : {},
+            pendingDnsRecords: res2.pendingDnsRecords,
+            verificationStatus: res2.status,
+            provisioning: res2.provisioningJobId !== void 0
+          });
           return text(
             res2.status === "verified" ? "domain_verification_succeeded" : "domain_verification_pending",
-            `DNS verification ${res2.verificationId}: ${res2.status}
+            `Domain binding status for ${apex2}: ${res2.status}
 ${res2.message}
-` + (res2.provisioningJobId ? `Provisioning started (job ${res2.provisioningJobId}). HTTPS certificates and serving setup are in progress; check again with bind_domain + verificationId later.
-` : "") + (res2.pendingDnsRecords.length > 0 ? `
-DNS records still required:
-${JSON.stringify(res2.pendingDnsRecords, null, 2)}` : ""),
+
+Live DNS checklist (host values are the SHORT panel form):
+${checklist}
+
+${layers}
+
+` + (allOk && res2.status === "verified" ? "All records are live; certificate issuance completes automatically \u2014 check again in a few minutes until the binding is active." : "Fix any [MISSING]/[FIX] lines above, then re-run bind_domain status. Re-check every 5 minutes, up to 10 times; if still failing after that, show the user this checklist."),
             {
               verificationId: res2.verificationId,
               status: res2.status,
-              apexDomain: res2.apexDomain,
+              apexDomain: apex2,
               provisioningJobId: res2.provisioningJobId,
-              pendingDnsRecords: res2.pendingDnsRecords,
+              servingTarget: res2.servingTarget,
+              dnsChecklist: checks.map((c) => ({
+                name: c.record.name,
+                type: c.record.type,
+                shortHost: c.shortHost,
+                state: c.state,
+                fix: c.fix || void 0
+              })),
+              apexResolves,
+              retryAfterSeconds: DNS_RETRY_AFTER_SECONDS,
+              maxAttempts: DNS_MAX_ATTEMPTS,
               message: res2.message
             },
-            res2.status === "verified" ? "completed" : "pending_provider"
+            res2.status === "verified" ? "pending_provider" : "waiting_user"
           );
         }
         if (!args.hostname) {
@@ -1726,25 +2000,42 @@ ${JSON.stringify(res2.pendingDnsRecords, null, 2)}` : ""),
           hostname: args.hostname
         };
         const res = await ctx.client.bindDomain(site.credential, req);
+        const apex = res.apexDomain;
+        const txtShort = shortHostFor(res.verificationRecord.name, apex);
         return text(
           "domain_verification_started",
-          `Domain binding started for ${res.apexDomain} (includes: ${res.includedHostnames.join(", ")} \u2014 both will serve this site).
+          `Domain binding started for ${apex} (includes: ${res.includedHostnames.join(", ")} \u2014 both will serve this site).
+
+Add ALL THREE DNS records NOW (adding them together lets verification, certificate issuance and serving complete without further record changes):
+
+  1) TXT    host: ${txtShort}   value: ${res.verificationRecord.value}
+  2) CNAME  host: www   value: ${res.servingTarget}
+  3) APEX   host: @   -> ${res.servingTarget} via your DNS panel's ALIAS / ANAME / CNAME-flattening feature (an apex cannot use a plain CNAME).
 
-1. Prove control of ${res.apexDomain} by creating this DNS record:
-   name:  ${res.verificationRecord.name}
-   type:  ${res.verificationRecord.type}
-   value: ${res.verificationRecord.value}
-   Ownership comes ONLY from DNS control; paying never grants it. This request does not reserve the domain \u2014 the first verified request wins, and this challenge expires after 72 hours.
+Host fields above are the SHORT form: most DNS panels append the domain automatically. After saving, the record list must NOT show ${apex} twice in one name \u2014 that means the full name was pasted into an auto-appending field.
 
-2. Serving DNS (after verification): ${res.servingInstructions}
+Ownership comes ONLY from DNS control; paying never grants it. The first verified request wins and this challenge expires after 72 hours.
 
-Then run bind_domain again with verificationId: "${res.verificationId}" to check verification and start provisioning.`,
+Then run bind_domain with action "status" \u2014 it live-checks every record and names the exact fix for anything wrong. Re-check every 5 minutes (up to 10 times). Any later session can resume with action "status" alone; the verificationId is optional.`,
           {
             verificationId: res.verificationId,
-            apexDomain: res.apexDomain,
+            apexDomain: apex,
             includedHostnames: res.includedHostnames,
             verificationRecord: res.verificationRecord,
-            servingInstructions: res.servingInstructions
+            servingTarget: res.servingTarget,
+            requiredRecords: [
+              {
+                type: "TXT",
+                shortHost: txtShort,
+                name: res.verificationRecord.name,
+                value: res.verificationRecord.value
+              },
+              { type: "CNAME", shortHost: "www", name: `www.${apex}`, value: res.servingTarget },
+              { type: "ALIAS", shortHost: "@", name: apex, value: res.servingTarget }
+            ],
+            servingInstructions: res.servingInstructions,
+            retryAfterSeconds: DNS_RETRY_AFTER_SECONDS,
+            maxAttempts: DNS_MAX_ATTEMPTS
           },
           "waiting_user"
         );
@@ -1759,10 +2050,11 @@ Then run bind_domain again with verificationId: "${res.verificationId}" to check
       description: "Show this site's hosting subscription: plan, payment state, current paid period, reconciled usage, estimated usage tier, bound custom domains and risks. Owner-only (uses the credential in .sakupa/site.json).",
       outputSchema: STRUCTURED_TOOL_OUTPUT_SCHEMA,
       annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: true },
-      inputSchema: {}
+      inputSchema: { projectDir: projectDirInput }
     },
-    async () => {
+    async (args) => {
       try {
+        const ctx = withProjectDir(baseCtx, args.projectDir);
         const site = requireSiteFile(ctx);
         const res = await ctx.client.getBillingStatus(site.siteId, site.credential);
         const lines = [
@@ -1792,11 +2084,13 @@ Full status:`, res);
       outputSchema: STRUCTURED_TOOL_OUTPUT_SCHEMA,
       annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
       inputSchema: {
-        scope: z2.enum(["site", "public_recovery"])
+        projectDir: projectDirInput,
+        scope: z3.enum(["site", "public_recovery"])
       }
     },
     async (args) => {
       try {
+        const ctx = withProjectDir(baseCtx, args.projectDir);
         if (args.scope === "site") {
           const site = requireSiteFile(ctx);
           const res2 = await ctx.client.createBillingPortal(site.siteId, site.credential);
@@ -1847,14 +2141,16 @@ Full status:`, res);
       outputSchema: STRUCTURED_TOOL_OUTPUT_SCHEMA,
       annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: true },
       inputSchema: {
-        action: z2.enum(["start", "status", "complete"]),
-        hostname: z2.string().optional().describe("Required for start."),
-        verificationId: z2.string().optional().describe("Required for status or complete."),
-        preserveExistingCredentials: z2.boolean().optional().describe("Explicitly keep old local credentials working (default: revoke them all).")
+        projectDir: projectDirInput,
+        action: z3.enum(["start", "status", "complete"]),
+        hostname: z3.string().optional().describe("Required for start."),
+        verificationId: z3.string().optional().describe("Required for status or complete."),
+        preserveExistingCredentials: z3.boolean().optional().describe("Explicitly keep old local credentials working (default: revoke them all).")
       }
     },
     async (args) => {
       try {
+        const ctx = withProjectDir(baseCtx, args.projectDir);
         if (args.action === "start") {
           if (!args.hostname) {
             throw new SakupaError("invalid_request", "hostname is required for start");
@@ -1952,14 +2248,16 @@ ${res.archiveUrl}`,
       outputSchema: STRUCTURED_TOOL_OUTPUT_SCHEMA,
       annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
       inputSchema: {
+        projectDir: projectDirInput,
         category: ticketCategoryEnum,
-        subject: z2.string().describe("Short subject line."),
-        description: z2.string().describe("Problem description (no secrets, no card data)."),
-        contactEmail: z2.string().optional().describe("Optional contact email for follow-up.")
+        subject: z3.string().describe("Short subject line."),
+        description: z3.string().describe("Problem description (no secrets, no card data)."),
+        contactEmail: z3.string().optional().describe("Optional contact email for follow-up.")
       }
     },
     async (args) => {
       try {
+        const ctx = withProjectDir(baseCtx, args.projectDir);
         const site = requireSiteFile(ctx);
         const res = await ctx.client.createTicket(site.credential, {
           siteId: site.siteId,
@@ -1985,18 +2283,20 @@ ${res.archiveUrl}`,
       outputSchema: STRUCTURED_TOOL_OUTPUT_SCHEMA,
       annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
       inputSchema: {
-        toolName: z2.string().describe('The Sakupa tool that failed, e.g. "deploy_site".'),
-        errorCode: z2.string().optional(),
-        errorMessage: z2.string().optional().describe("Sanitized error message (no secrets)."),
-        requestId: z2.string().optional(),
-        deploymentId: z2.string().optional(),
+        projectDir: projectDirInput,
+        toolName: z3.string().describe('The Sakupa tool that failed, e.g. "deploy_site".'),
+        errorCode: z3.string().optional(),
+        errorMessage: z3.string().optional().describe("Sanitized error message (no secrets)."),
+        requestId: z3.string().optional(),
+        deploymentId: z3.string().optional(),
         severity: severityEnum.optional(),
-        description: z2.string().optional().describe("What happened, in the user's words (no secrets)."),
-        confirmSubmit: z2.boolean().optional().describe("User reviewed the report payload and approved submission.")
+        description: z3.string().optional().describe("What happened, in the user's words (no secrets)."),
+        confirmSubmit: z3.boolean().optional().describe("User reviewed the report payload and approved submission.")
       }
     },
     async (args) => {
       try {
+        const ctx = withProjectDir(baseCtx, args.projectDir);
         const siteState = loadSiteFile(ctx.projectDir);
         const site = siteState.kind === "ok" ? siteState.file : null;
         const diagnostics = {
@@ -2040,19 +2340,20 @@ Summary: ${res.sanitizedSummary}`,
 }
 
 // src/tools/billing.ts
-import { z as z3 } from "zod";
-var plan = z3.enum(["water", "personal", "share", "business"]);
-function registerBillingTools(server, ctx) {
+import { z as z4 } from "zod";
+var plan = z4.enum(["water", "personal", "share", "business"]);
+function registerBillingTools(server, baseCtx) {
   server.registerTool(
     "list_billing_plans",
     {
       description: "Return the authoritative Sakupa monthly plan catalog, exact limits, prices, catalog version and plan-change billing rules. This is read-only and does not require a site.",
-      inputSchema: {},
+      inputSchema: { projectDir: projectDirInput },
       outputSchema: STRUCTURED_TOOL_OUTPUT_SCHEMA,
       annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: true }
     },
-    async () => {
+    async (args) => {
       try {
+        const ctx = withProjectDir(baseCtx, args.projectDir);
         const catalog = await ctx.client.getBillingPlanCatalog();
         return structuredToolResult({
           schemaVersion: 1,
@@ -2072,14 +2373,16 @@ function registerBillingTools(server, ctx) {
     {
       description: "Create a Stripe-hosted confirmation link for a manually selected subscription plan. Creating the link does not change billing; only the user can confirm on Stripe.",
       inputSchema: {
+        projectDir: projectDirInput,
         targetPlan: plan,
-        operationId: z3.string().min(1)
+        operationId: z4.string().min(1)
       },
       outputSchema: STRUCTURED_TOOL_OUTPUT_SCHEMA,
       annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true }
     },
     async (args) => {
       try {
+        const ctx = withProjectDir(baseCtx, args.projectDir);
         const site = requireSiteFile(ctx);
         const result = await ctx.client.changeSubscriptionPlan(site.credential, {
           siteId: site.siteId,
@@ -2109,39 +2412,40 @@ function registerBillingTools(server, ctx) {
 }
 
 // src/tools/lifecycle.ts
-import { z as z4 } from "zod";
-var deleteConfirmation = z4.object({
-  siteId: z4.string().min(1),
-  expectedSiteUpdatedAt: z4.string().datetime(),
-  expectedStatus: z4.enum(["active", "expired", "deleted"]),
-  expectedMode: z4.enum(["free", "paid"]),
-  expectedServingMode: z4.enum(["normal", "over_limit_notice", "risk_notice", "stopped"]),
-  expectedShortId: z4.string().optional(),
-  expectedSubscriptionStatus: z4.enum(["incomplete", "active", "past_due", "canceled"]).optional(),
-  expectedPlan: z4.enum(["water", "personal", "share", "business"]).optional(),
-  expectedCancelAtPeriodEnd: z4.boolean().optional(),
-  expectedCurrentPeriodEnd: z4.string().datetime().optional(),
-  expectedLastDeploymentId: z4.string().optional(),
-  expectedBoundHostnames: z4.array(z4.string()),
-  acknowledge: z4.literal("delete_site_and_cancel_renewal")
+import { z as z5 } from "zod";
+var deleteConfirmation = z5.object({
+  siteId: z5.string().min(1),
+  expectedSiteUpdatedAt: z5.string().datetime(),
+  expectedStatus: z5.enum(["active", "expired", "deleted"]),
+  expectedMode: z5.enum(["free", "paid"]),
+  expectedServingMode: z5.enum(["normal", "over_limit_notice", "risk_notice", "stopped"]),
+  expectedShortId: z5.string().optional(),
+  expectedSubscriptionStatus: z5.enum(["incomplete", "active", "past_due", "canceled"]).optional(),
+  expectedPlan: z5.enum(["water", "personal", "share", "business"]).optional(),
+  expectedCancelAtPeriodEnd: z5.boolean().optional(),
+  expectedCurrentPeriodEnd: z5.string().datetime().optional(),
+  expectedLastDeploymentId: z5.string().optional(),
+  expectedBoundHostnames: z5.array(z5.string()),
+  acknowledge: z5.literal("delete_site_and_cancel_renewal")
 });
-var unbindConfirmation = z4.object({
-  siteId: z4.string().min(1),
-  bindingId: z4.string().min(1),
-  expectedBindingUpdatedAt: z4.string().datetime(),
-  expectedBindingStatus: z4.enum(["provisioning", "active"]),
-  apexDomain: z4.string().min(1),
-  expectedBoundHostnames: z4.array(z4.string()),
-  acknowledge: z4.literal("unbind_domain_and_remove_custom_hostnames")
+var unbindConfirmation = z5.object({
+  siteId: z5.string().min(1),
+  bindingId: z5.string().min(1),
+  expectedBindingUpdatedAt: z5.string().datetime(),
+  expectedBindingStatus: z5.enum(["provisioning", "active"]),
+  apexDomain: z5.string().min(1),
+  expectedBoundHostnames: z5.array(z5.string()),
+  acknowledge: z5.literal("unbind_domain_and_remove_custom_hostnames")
 });
-function registerLifecycleTools(server, ctx) {
+function registerLifecycleTools(server, baseCtx) {
   server.registerTool(
     "delete_site",
     {
       description: "Preview or execute deletion of this Sakupa site. Execution requires an exact server-validated confirmation bound to the current site state.",
       inputSchema: {
-        action: z4.enum(["preview", "confirm"]),
-        operationId: z4.string().min(1).optional(),
+        projectDir: projectDirInput,
+        action: z5.enum(["preview", "confirm"]),
+        operationId: z5.string().min(1).optional(),
         confirmation: deleteConfirmation.optional()
       },
       outputSchema: STRUCTURED_TOOL_OUTPUT_SCHEMA,
@@ -2149,6 +2453,7 @@ function registerLifecycleTools(server, ctx) {
     },
     async (args) => {
       try {
+        const ctx = withProjectDir(baseCtx, args.projectDir);
         const site = requireSiteFile(ctx);
         if (!args.operationId) {
           throw new Error("operationId is required for delete_site");
@@ -2175,13 +2480,14 @@ function registerLifecycleTools(server, ctx) {
           confirmation: args.confirmation
         });
         deleteSiteFile(ctx.projectDir);
+        removeCreation(site.siteId);
         return structuredToolResult({
           schemaVersion: 1,
           outcome: result.servingDeletionPending ? "pending_provider" : "completed",
           resultCode: "site_deleted",
           operationId: args.operationId,
-          summary: "Site deleted; the local management credential file was removed.",
-          data: { result },
+          summary: `Site deleted; the local management credential file was removed from ${ctx.projectDir}.`,
+          data: { result, projectDir: ctx.projectDir },
           nextActions: []
         });
       } catch (error) {
@@ -2194,8 +2500,9 @@ function registerLifecycleTools(server, ctx) {
     {
       description: "Preview or execute removal of the custom apex/www serving surface while preserving the subscription and permanent Sakupa URL.",
       inputSchema: {
-        action: z4.enum(["preview", "confirm"]),
-        operationId: z4.string().min(1).optional(),
+        projectDir: projectDirInput,
+        action: z5.enum(["preview", "confirm"]),
+        operationId: z5.string().min(1).optional(),
         confirmation: unbindConfirmation.optional()
       },
       outputSchema: STRUCTURED_TOOL_OUTPUT_SCHEMA,
@@ -2203,6 +2510,7 @@ function registerLifecycleTools(server, ctx) {
     },
     async (args) => {
       try {
+        const ctx = withProjectDir(baseCtx, args.projectDir);
         const site = requireSiteFile(ctx);
         if (!args.operationId) throw new Error("operationId is required for unbind_domain");
         if (args.action === "preview") {
@@ -2233,7 +2541,7 @@ function registerLifecycleTools(server, ctx) {
           outcome: result.servingDeletionPending ? "pending_provider" : "completed",
           resultCode: "domain_unbound",
           operationId: args.operationId,
-          summary: "Custom domain unbound; the subscription, deployed content, and permanent Sakupa URL are unchanged.",
+          summary: `Custom domain unbound; the subscription, deployed content, and permanent Sakupa URL are unchanged. (project: ${ctx.projectDir})`,
           data: { result },
           nextActions: [{ tool: "site_status", allowed: true }]
         });
@@ -2346,6 +2654,15 @@ Workflow:
 5. create_support_ticket (subscribed sites) opens a support ticket; report_bug sends a
    sanitized diagnostic report after the user explicitly confirms it.
 
+Project directory contract: ONE directory = ONE site (its .sakupa/site.json holds the
+binding). Every project-scoped tool accepts projectDir \u2014 ALWAYS pass the absolute path of
+the directory the user is currently working in, on every call. Without it the server falls
+back to its startup directory, which may be a different project than the one the user is
+looking at. After every deploy, TELL the user which environment it went to (deploy results carry an
+Explicit Environment line: TEST vs PRODUCTION). analyze_site, deploy_site, site_status,
+refresh_site, delete_site and unbind_domain echo
+the directory they acted on \u2014 verify it matches the user's active project.
+
 Safety boundaries:
 - Static output only: no SSR, API routes, middleware, server actions, databases or online builds.
 - Never upload source projects, secrets, .env files, private keys, archives, videos or audio.
@@ -2398,7 +2715,7 @@ async function main() {
   const transport = new StdioServerTransport();
   await server.connect(transport);
   console.error(
-    `[sakupa-mcp] v${MCP_VERSION} connected (api: ${config.apiBaseUrl}, project: ${config.projectDir})`
+    `[sakupa-mcp] v${MCP_VERSION} connected (api: ${config.apiBaseUrl}, default project: ${config.projectDir}; tools accept per-call projectDir)`
   );
 }
 main().catch((err) => {