@sakupa/mcp 0.7.32 → 0.7.34

package/dist/bin.js

@@ -2,6 +2,247 @@
 
 // src/bin.ts
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { stdout } from "node:process";
+
+// src/project-root.ts
+import { randomUUID } from "node:crypto";
+import {
+  chmodSync,
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  readFileSync,
+  realpathSync,
+  renameSync,
+  statSync,
+  unlinkSync,
+  writeFileSync
+} from "node:fs";
+import { homedir } from "node:os";
+import { isAbsolute, join, parse, relative, resolve, sep } from "node:path";
+var SAKUPA_DIR = ".sakupa";
+var PROJECT_FILE = "project.json";
+var PROJECT_SCHEMA_VERSION = 1;
+var ProjectRootError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "ProjectRootError";
+    this.code = code;
+  }
+};
+function projectMarkerPath(projectDir) {
+  return join(projectDir, SAKUPA_DIR, PROJECT_FILE);
+}
+function loadProjectMarker(projectDir) {
+  const path = projectMarkerPath(projectDir);
+  if (!existsSync(path)) return { kind: "absent" };
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(path, "utf8"));
+  } catch (error) {
+    return {
+      kind: "corrupted",
+      problem: `the file cannot be read as JSON (${error instanceof Error ? error.message : String(error)})`
+    };
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    return { kind: "corrupted", problem: "the file does not contain a JSON object" };
+  }
+  const record = parsed;
+  if (record.schemaVersion !== PROJECT_SCHEMA_VERSION) {
+    return {
+      kind: "corrupted",
+      problem: `unsupported schemaVersion ${String(record.schemaVersion)}`
+    };
+  }
+  if (typeof record.projectId !== "string" || !isUuid(record.projectId)) {
+    return { kind: "corrupted", problem: "projectId is missing or is not a UUID" };
+  }
+  if (typeof record.createdAt !== "string" || !Number.isFinite(Date.parse(record.createdAt))) {
+    return { kind: "corrupted", problem: "createdAt is missing or invalid" };
+  }
+  if (record.outputDir !== void 0 && (typeof record.outputDir !== "string" || !isSafeRelativeOutput(record.outputDir))) {
+    return { kind: "corrupted", problem: "outputDir is not a safe project-relative path" };
+  }
+  return {
+    kind: "ok",
+    marker: {
+      schemaVersion: PROJECT_SCHEMA_VERSION,
+      projectId: record.projectId,
+      createdAt: record.createdAt,
+      ...record.outputDir !== void 0 ? { outputDir: normalizeRelative(record.outputDir) } : {}
+    }
+  };
+}
+function initializeProject(projectDir) {
+  const canonical = canonicalProjectDirectory(projectDir);
+  assertSafeProjectRoot(canonical);
+  const current = loadProjectMarker(canonical);
+  if (current.kind === "corrupted") {
+    throw new ProjectRootError(
+      "corrupted_marker",
+      `Refusing to overwrite damaged Sakupa project marker ${projectMarkerPath(canonical)}: ${current.problem}.`
+    );
+  }
+  if (current.kind === "ok") {
+    return {
+      projectDir: canonical,
+      requestedPath: canonical,
+      markerKind: "project",
+      marker: current.marker
+    };
+  }
+  const marker = {
+    schemaVersion: PROJECT_SCHEMA_VERSION,
+    projectId: randomUUID(),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writeMarkerAtomically(canonical, marker);
+  return {
+    projectDir: canonical,
+    requestedPath: canonical,
+    markerKind: "project",
+    marker
+  };
+}
+function resolveLockedProjectRoot(projectDir) {
+  const canonical = canonicalProjectDirectory(projectDir);
+  assertSafeProjectRoot(canonical);
+  const markerState = loadProjectMarker(canonical);
+  if (markerState.kind === "corrupted") {
+    throw new ProjectRootError(
+      "corrupted_marker",
+      `Sakupa project marker ${projectMarkerPath(canonical)} is damaged: ${markerState.problem}.`
+    );
+  }
+  if (markerState.kind === "absent") {
+    throw new ProjectRootError(
+      "not_initialized",
+      `The MCP working directory ${canonical} is not initialized. Run \`npx -y @sakupa/mcp@latest init\` in that directory; do not pass a path argument.`
+    );
+  }
+  return {
+    projectDir: canonical,
+    requestedPath: canonical,
+    markerKind: "project",
+    marker: markerState.marker
+  };
+}
+function updateProjectOutputDir(projectDir, outputDir) {
+  const canonical = canonicalProjectDirectory(projectDir);
+  const state = loadProjectMarker(canonical);
+  if (state.kind !== "ok") {
+    throw new ProjectRootError(
+      state.kind === "corrupted" ? "corrupted_marker" : "not_initialized",
+      state.kind === "corrupted" ? `Cannot update damaged Sakupa project marker: ${state.problem}.` : `No Sakupa project marker exists in ${canonical}.`
+    );
+  }
+  if (!isSafeRelativeOutput(outputDir)) {
+    throw new ProjectRootError(
+      "unsafe_path",
+      `Output directory "${outputDir}" must stay inside the initialized Sakupa project.`
+    );
+  }
+  const marker = {
+    ...state.marker,
+    outputDir: normalizeRelative(outputDir)
+  };
+  writeMarkerAtomically(canonical, marker);
+  return marker;
+}
+function canonicalProjectDirectory(path) {
+  const canonical = canonicalExistingPath(resolve(path));
+  if (!statSync(canonical).isDirectory()) {
+    throw new ProjectRootError("invalid_path", `Project path ${canonical} is not a directory.`);
+  }
+  return canonical;
+}
+function canonicalExistingPath(path) {
+  try {
+    const stat2 = lstatSync(path, { throwIfNoEntry: false });
+    if (!stat2) {
+      throw new ProjectRootError("invalid_path", `Project path ${path} does not exist.`);
+    }
+    return realpathSync(path);
+  } catch (error) {
+    if (error instanceof ProjectRootError) throw error;
+    throw new ProjectRootError(
+      "invalid_path",
+      `Project path ${path} cannot be resolved (${error instanceof Error ? error.message : String(error)}).`
+    );
+  }
+}
+function assertSafeProjectRoot(projectDir) {
+  if (parse(projectDir).root === projectDir || projectDir === realpathSync(homedir())) {
+    throw new ProjectRootError(
+      "unsafe_path",
+      `Refusing to use ${projectDir} as a Sakupa project root; choose a specific project directory.`
+    );
+  }
+}
+function isUuid(value) {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value);
+}
+function normalizeRelative(path) {
+  const normalized = path.split(sep).join("/").replace(/^\.\//, "").replace(/\/$/, "");
+  return normalized.length === 0 ? "." : normalized;
+}
+function isSafeRelativeOutput(path) {
+  if (path.length === 0 || isAbsolute(path)) return false;
+  const normalized = normalizeRelative(path);
+  if (normalized === ".") return true;
+  const rel = relative("/sakupa-root", resolve("/sakupa-root", normalized));
+  return rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
+}
+function writeMarkerAtomically(projectDir, marker) {
+  const dir = join(projectDir, SAKUPA_DIR);
+  mkdirSync(dir, { recursive: true, mode: 448 });
+  const path = projectMarkerPath(projectDir);
+  const temporary = `${path}.${process.pid}.${randomUUID()}.tmp`;
+  try {
+    writeFileSync(temporary, `${JSON.stringify(marker, null, 2)}
+`, {
+      encoding: "utf8",
+      mode: 384
+    });
+    renameSync(temporary, path);
+    try {
+      chmodSync(path, 384);
+    } catch {
+    }
+  } finally {
+    if (existsSync(temporary)) unlinkSync(temporary);
+  }
+}
+
+// src/cli-init.ts
+async function runInitCommand(args, io, cwd = process.cwd()) {
+  if (args.length > 0) {
+    io.write("Usage: sakupa-mcp init");
+    return { exitCode: 2, initialized: false };
+  }
+  try {
+    const projectDir = canonicalProjectDirectory(cwd);
+    const current = loadProjectMarker(projectDir);
+    if (current.kind === "corrupted") {
+      io.write(`Refusing to replace damaged Sakupa marker in ${projectDir}: ${current.problem}.`);
+      return { exitCode: 1, projectDir, initialized: false };
+    }
+    if (current.kind === "ok") {
+      io.write(`Sakupa project is already initialized: ${projectDir}`);
+      return { exitCode: 0, projectDir, initialized: false };
+    }
+    initializeProject(projectDir);
+    io.write(
+      `Initialized the current directory ${projectDir}. Created .sakupa/project.json here; site credentials and recovery state will stay in this .sakupa directory.`
+    );
+    return { exitCode: 0, projectDir, initialized: true };
+  } catch (error) {
+    io.write(error instanceof Error ? error.message : String(error));
+    return { exitCode: 1, initialized: false };
+  }
+}
 
 // ../core/dist/domain/constants.js
 var SERVICE_DOMAIN = "sakupa.com";
@@ -129,7 +370,7 @@ var FORBIDDEN_PATH_SEGMENTS = [
 var ALLOWED_HIDDEN_PATHS = [".well-known/"];
 
 // ../core/dist/domain/version.js
-var SAKUPA_MCP_VERSION = "0.7.32";
+var SAKUPA_MCP_VERSION = "0.7.34";
 
 // ../core/dist/domain/errors.js
 var HTTP_STATUS = {
@@ -688,14 +929,14 @@ var HttpApiClient = class {
 };
 
 // src/tools/definitions.ts
-import { randomUUID } from "node:crypto";
-import { existsSync as existsSync3, promises as fs2 } from "node:fs";
-import { join as join5, relative as relative2, resolve as resolve4, sep as sep3 } from "node:path";
-import { z as z3 } from "zod";
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { promises as fs2 } from "node:fs";
+import { join as join6, resolve as resolve4 } from "node:path";
+import { z as z2 } from "zod";
 
 // src/analyze/analyzer.ts
 import { promises as fs } from "node:fs";
-import { join, posix, resolve, sep } from "node:path";
+import { join as join2, posix, resolve as resolve2, sep as sep2 } from "node:path";
 var SERVER_RUNTIME_DEPS = ["express", "koa", "fastify", "hapi", "@hapi/hapi"];
 var DB_RUNTIME_DEPS = [
   "prisma",
@@ -740,7 +981,7 @@ async function readTextIfExists(path, maxBytes = CONTENT_READ_MAX_BYTES) {
 }
 async function firstExistingFile(dir, names) {
   for (const name of names) {
-    const p = join(dir, name);
+    const p = join2(dir, name);
     if (await isFile(p)) return p;
   }
   return null;
@@ -769,10 +1010,10 @@ async function walkFiles(dir, opts) {
       if (entry.isDirectory()) {
         if (FORBIDDEN_SEGMENTS_LOWER.has(entry.name.toLowerCase())) continue;
         if (opts.skipRelDirs?.has(rel)) continue;
-        await recurse(join(current, entry.name), rel);
+        await recurse(join2(current, entry.name), rel);
       } else if (entry.isFile()) {
         try {
-          const stat2 = await fs.stat(join(current, entry.name));
+          const stat2 = await fs.stat(join2(current, entry.name));
           out.push({ path: rel, size: stat2.size });
         } catch {
         }
@@ -783,7 +1024,7 @@ async function walkFiles(dir, opts) {
   return out;
 }
 async function readPackageJson(projectDir) {
-  const raw = await readTextIfExists(join(projectDir, "package.json"));
+  const raw = await readTextIfExists(join2(projectDir, "package.json"));
   if (raw === null) return null;
   try {
     const parsed = JSON.parse(raw);
@@ -818,7 +1059,7 @@ async function detectFramework(projectDir, pkg) {
       );
     }
     for (const apiDir of ["pages/api", "src/pages/api"]) {
-      if (await isDirectory(join(projectDir, apiDir))) {
+      if (await isDirectory(join2(projectDir, apiDir))) {
         ssrRisks.push(
           `API routes (${apiDir}/) require a server runtime and will not run on Sakupa. Remove them or move their logic to build time before static export.`
         );
@@ -827,7 +1068,7 @@ async function detectFramework(projectDir, pkg) {
     }
     for (const appDir of ["app", "src/app"]) {
       if (await anyFileMatches(
-        join(projectDir, appDir),
+        join2(projectDir, appDir),
         (base) => /^route\.(ts|js|tsx|jsx|mjs)$/.test(base)
       )) {
         ssrRisks.push(
@@ -858,7 +1099,7 @@ async function detectFramework(projectDir, pkg) {
   ]);
   if ("nuxt" in deps || "nuxt3" in deps || nuxtConfigPath !== null) {
     for (const serverDir of ["server/api", "server/routes"]) {
-      if (await isDirectory(join(projectDir, serverDir))) {
+      if (await isDirectory(join2(projectDir, serverDir))) {
         ssrRisks.push(
           `Nuxt server handlers (${serverDir}/) require a server runtime and will not run on Sakupa. Use static generation (npx nuxi generate) and deploy .output/public.`
         );
@@ -900,7 +1141,7 @@ async function detectFramework(projectDir, pkg) {
         "SvelteKit requires @sveltejs/adapter-static to produce a fully static build. Install and configure it, then build locally."
       );
     }
-    if (await anyFileMatches(join(projectDir, "src/routes"), (base) => base.startsWith("+server."))) {
+    if (await anyFileMatches(join2(projectDir, "src/routes"), (base) => base.startsWith("+server."))) {
       ssrRisks.push(
         "SvelteKit +server.* endpoint files require a server runtime and will not run on Sakupa."
       );
@@ -965,17 +1206,17 @@ async function scanForUseServer(projectDir, skipRelDirs) {
     if (scanned >= USE_SERVER_SCAN_MAX_FILES) break;
     if (!SOURCE_SCAN_EXTENSIONS.has(extensionOf(file.path))) continue;
     scanned += 1;
-    const text2 = await readTextIfExists(join(projectDir, file.path), USE_SERVER_SCAN_MAX_BYTES);
+    const text2 = await readTextIfExists(join2(projectDir, file.path), USE_SERVER_SCAN_MAX_BYTES);
     if (text2 !== null && /['"]use server['"]/.test(text2)) return true;
   }
   return false;
 }
 function normalizeOutputDir(outputDir) {
-  const normalized = posix.normalize(outputDir.replaceAll(sep, "/")).replace(/\/+$/, "");
+  const normalized = posix.normalize(outputDir.replaceAll(sep2, "/")).replace(/\/+$/, "");
   return normalized === "" ? "." : normalized;
 }
 async function analyzeProject(projectDir, opts = {}) {
-  const root = resolve(projectDir);
+  const root = await fs.realpath(resolve2(projectDir));
   const pkg = await readPackageJson(root);
   const detection = await detectFramework(root, pkg);
   const ssrRisks = [...detection?.ssrRisks ?? []];
@@ -985,16 +1226,26 @@ async function analyzeProject(projectDir, opts = {}) {
   let outputDirExists = false;
   if (opts.outputDir !== void 0) {
     outputDirRel = normalizeOutputDir(opts.outputDir);
-    const abs = resolve(root, outputDirRel);
-    if (abs !== root && !abs.startsWith(root + sep)) {
+    const abs = resolve2(root, outputDirRel);
+    if (abs !== root && !abs.startsWith(root + sep2)) {
       outputDirRel = ".";
       outputDirExists = false;
     } else {
       outputDirExists = await isDirectory(abs) || outputDirRel === "." && await isDirectory(root);
+      if (outputDirExists) {
+        try {
+          const physical = await fs.realpath(abs);
+          if (physical !== root && !physical.startsWith(root + sep2)) {
+            outputDirExists = false;
+          }
+        } catch {
+          outputDirExists = false;
+        }
+      }
     }
   } else if (detection) {
     for (const candidate of detection.outputCandidates) {
-      if (await isDirectory(join(root, candidate))) {
+      if (await isDirectory(join2(root, candidate))) {
         outputDirRel = candidate;
         outputDirExists = true;
         break;
@@ -1009,7 +1260,7 @@ async function analyzeProject(projectDir, opts = {}) {
     outputDirExists = true;
   } else if (hasBuildScript) {
     for (const candidate of ["dist", "build", "out", "public"]) {
-      if (await isFile(join(root, candidate, "index.html"))) {
+      if (await isFile(join2(root, candidate, "index.html"))) {
         outputDirRel = candidate;
         outputDirExists = true;
         break;
@@ -1029,7 +1280,7 @@ async function analyzeProject(projectDir, opts = {}) {
   }
   if (outputDirRel === void 0 || !outputDirExists) {
     ssrRisks.push(...serverAndDbDepRisks(pkg, false));
-    const sourceWithoutBuild = pkg !== null && buildRequired && (await isDirectory(join(root, "src")) || await isDirectory(join(root, "pages")));
+    const sourceWithoutBuild = pkg !== null && buildRequired && (await isDirectory(join2(root, "src")) || await isDirectory(join2(root, "pages")));
     let suggestedNextAction2;
     if (opts.outputDir !== void 0) {
       suggestedNextAction2 = `The requested output directory "${opts.outputDir}" does not exist. Build the project locally first (${buildCommandHint ?? "npm run build"}) or pass the correct directory, then re-run analyze.`;
@@ -1057,7 +1308,7 @@ async function analyzeProject(projectDir, opts = {}) {
       suggestedNextAction: suggestedNextAction2
     };
   }
-  const outputAbs = outputDirRel === "." ? root : resolve(root, outputDirRel);
+  const outputAbs = outputDirRel === "." ? root : resolve2(root, outputDirRel);
   const walked = await walkFiles(outputAbs, { maxFiles: MAX_FILE_COUNT + 1 });
   const candidates = [];
   for (const file of walked) {
@@ -1065,7 +1316,7 @@ async function analyzeProject(projectDir, opts = {}) {
     let content;
     if (TEXT_CONTENT_EXTENSIONS.has(ext) && file.size <= CONTENT_READ_MAX_BYTES) {
       try {
-        content = new Uint8Array(await fs.readFile(join(outputAbs, file.path)));
+        content = new Uint8Array(await fs.readFile(join2(outputAbs, file.path)));
       } catch {
         content = void 0;
       }
@@ -1114,30 +1365,30 @@ async function analyzeProject(projectDir, opts = {}) {
 
 // src/project-file.ts
 import {
-  chmodSync,
-  existsSync,
-  mkdirSync,
-  readFileSync,
+  chmodSync as chmodSync2,
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync2,
   rmdirSync,
   rmSync,
-  writeFileSync
+  writeFileSync as writeFileSync2
 } from "node:fs";
-import { dirname, join as join2 } from "node:path";
+import { dirname, join as join3 } from "node:path";
 var SITE_DIR = ".sakupa";
 var SITE_FILE = "site.json";
 var RECOVERY_FILE = "recovery.json";
 function siteFilePath(projectDir) {
-  return join2(projectDir, SITE_DIR, SITE_FILE);
+  return join3(projectDir, SITE_DIR, SITE_FILE);
 }
 function recoveryFilePath(projectDir) {
-  return join2(projectDir, SITE_DIR, RECOVERY_FILE);
+  return join3(projectDir, SITE_DIR, RECOVERY_FILE);
 }
 function loadSiteFile(projectDir) {
   const path = siteFilePath(projectDir);
-  if (!existsSync(path)) return { kind: "absent" };
+  if (!existsSync2(path)) return { kind: "absent" };
   let raw;
   try {
-    raw = readFileSync(path, "utf8");
+    raw = readFileSync2(path, "utf8");
   } catch (err2) {
     return {
       kind: "corrupted",
@@ -1180,9 +1431,9 @@ function loadSiteFile(projectDir) {
 }
 function loadRecoveryFile(projectDir) {
   const path = recoveryFilePath(projectDir);
-  if (!existsSync(path)) return null;
+  if (!existsSync2(path)) return null;
   try {
-    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    const parsed = JSON.parse(readFileSync2(path, "utf8"));
     if (typeof parsed.verificationId !== "string" || parsed.verificationId.length === 0 || typeof parsed.credential !== "string" || !CREDENTIAL_PATTERN.test(parsed.credential)) {
       throw new Error("required recovery fields are missing or invalid");
     }
@@ -1198,19 +1449,19 @@ function loadRecoveryFile(projectDir) {
   }
 }
 function writeRecoveryFile(projectDir, file) {
-  const dir = join2(projectDir, SITE_DIR);
-  mkdirSync(dir, { recursive: true });
-  const path = join2(dir, RECOVERY_FILE);
-  writeFileSync(path, `${JSON.stringify(file, null, 2)}
+  const dir = join3(projectDir, SITE_DIR);
+  mkdirSync2(dir, { recursive: true });
+  const path = join3(dir, RECOVERY_FILE);
+  writeFileSync2(path, `${JSON.stringify(file, null, 2)}
 `, "utf8");
   try {
-    chmodSync(path, 384);
+    chmodSync2(path, 384);
   } catch {
   }
 }
 function deleteRecoveryFile(projectDir) {
   const path = recoveryFilePath(projectDir);
-  if (existsSync(path)) rmSync(path, { force: true });
+  if (existsSync2(path)) rmSync(path, { force: true });
 }
 function siteFileRecoveryGuidance(projectDir) {
   return `The site itself is intact on the server; only the local binding file (${siteFilePath(projectDir)}) is the problem. Restore the file (from a backup or by undoing the local edit). Do NOT delete it to work around the error: the credential is unrecoverable by design, so abandoning it permanently orphans the existing site. Publishing this project as a brand-NEW site requires the user to manually delete the .sakupa directory first \u2014 the tool will never overwrite it.`;
@@ -1229,23 +1480,23 @@ function writeSiteFile(projectDir, file, opts = {}) {
       );
     }
   }
-  const dir = join2(projectDir, SITE_DIR);
-  mkdirSync(dir, { recursive: true });
-  const path = join2(dir, SITE_FILE);
-  writeFileSync(path, `${JSON.stringify(file, null, 2)}
+  const dir = join3(projectDir, SITE_DIR);
+  mkdirSync2(dir, { recursive: true });
+  const path = join3(dir, SITE_FILE);
+  writeFileSync2(path, `${JSON.stringify(file, null, 2)}
 `, "utf8");
   try {
-    chmodSync(path, 384);
+    chmodSync2(path, 384);
   } catch {
   }
 }
 function deleteSiteFile(projectDir) {
   const path = siteFilePath(projectDir);
-  if (existsSync(path)) {
+  if (existsSync2(path)) {
     rmSync(path, { force: true });
   }
   try {
-    rmdirSync(join2(projectDir, SITE_DIR));
+    rmdirSync(join3(projectDir, SITE_DIR));
   } catch {
   }
 }
@@ -1260,7 +1511,7 @@ function findAncestor(startDir, predicate, maxLevels = Number.POSITIVE_INFINITY)
   return null;
 }
 function isInsideGitRepo(projectDir) {
-  return existsSync(join2(projectDir, ".git")) || findAncestor(projectDir, (dir) => existsSync(join2(dir, ".git"))) !== null;
+  return existsSync2(join3(projectDir, ".git")) || findAncestor(projectDir, (dir) => existsSync2(join3(dir, ".git"))) !== null;
 }
 function credentialGitReminder(projectDir) {
   if (!isInsideGitRepo(projectDir)) return "";
@@ -1268,8 +1519,9 @@ function credentialGitReminder(projectDir) {
 }
 
 // src/recovery-archive.ts
+import { existsSync as existsSync3, realpathSync as realpathSync2 } from "node:fs";
 import { mkdtemp, mkdir, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
-import { dirname as dirname2, isAbsolute, join as join3, relative, resolve as resolve2, sep as sep2 } from "node:path";
+import { dirname as dirname2, isAbsolute as isAbsolute2, join as join4, relative as relative2, resolve as resolve3, sep as sep3 } from "node:path";
 
 // ../../node_modules/fflate/esm/index.mjs
 import { createRequire } from "module";
@@ -1688,15 +1940,15 @@ function strFromU8(dat, latin1) {
 var slzh = function(d, b) {
   return b + 30 + b2(d, b + 26) + b2(d, b + 28);
 };
-var zh = function(d, b, z6) {
+var zh = function(d, b, z5) {
   var fnl = b2(d, b + 28), efl = b2(d, b + 30), fn = strFromU8(d.subarray(b + 46, b + 46 + fnl), !(b2(d, b + 8) & 2048)), es = b + 46 + fnl;
-  var _a2 = z64hs(d, es, efl, z6, b4(d, b + 20), b4(d, b + 24), b4(d, b + 42)), sc = _a2[0], su = _a2[1], off = _a2[2];
+  var _a2 = z64hs(d, es, efl, z5, b4(d, b + 20), b4(d, b + 24), b4(d, b + 42)), sc = _a2[0], su = _a2[1], off = _a2[2];
   return [b2(d, b + 10), sc, su, fn, es + efl + b2(d, b + 32), off];
 };
-var z64hs = function(d, b, l, z6, sc, su, off) {
+var z64hs = function(d, b, l, z5, sc, su, off) {
   var nsc = sc == 4294967295, nsu = su == 4294967295, noff = off == 4294967295, e = b + l;
   var nf = nsc + nsu + noff;
-  if (z6 && nf) {
+  if (z5 && nf) {
     for (; b + 4 < e; b += 4 + b2(d, b + 2)) {
       if (b2(d, b) == 1) {
         return [
@@ -1707,7 +1959,7 @@ var z64hs = function(d, b, l, z6, sc, su, off) {
         ];
       }
     }
-    if (z6 < 2)
+    if (z5 < 2)
       err(13);
   }
   return [sc, su, off, 0];
@@ -1724,18 +1976,18 @@ function unzipSync(data, opts) {
   if (!c)
     return {};
   var o = b4(data, e + 16);
-  var z6 = b4(data, e - 20) == 117853008;
-  if (z6) {
+  var z5 = b4(data, e - 20) == 117853008;
+  if (z5) {
     var ze = b4(data, e - 12);
-    z6 = b4(data, ze) == 101075792;
-    if (z6) {
+    z5 = b4(data, ze) == 101075792;
+    if (z5) {
       c = b4(data, ze + 32);
       o = b4(data, ze + 48);
     }
   }
   var fltr = opts && opts.filter;
   for (var i = 0; i < c; ++i) {
-    var _a2 = zh(data, o, z6), c_2 = _a2[0], sc = _a2[1], su = _a2[2], fn = _a2[3], no = _a2[4], off = _a2[5], b = slzh(data, off);
+    var _a2 = zh(data, o, z5), c_2 = _a2[0], sc = _a2[1], su = _a2[2], fn = _a2[3], no = _a2[4], off = _a2[5], b = slzh(data, off);
     o = no;
     if (!fltr || fltr({
       name: fn,
@@ -1756,18 +2008,33 @@ function unzipSync(data, opts) {
 
 // src/recovery-archive.ts
 function safeOutputPath(projectDir, outputDir) {
-  if (outputDir.length === 0 || isAbsolute(outputDir)) {
+  if (outputDir.length === 0 || isAbsolute2(outputDir)) {
     throw new SakupaError("invalid_request", "Recovery outputDir must be a relative directory");
   }
-  const root = resolve2(projectDir);
-  const target = resolve2(root, outputDir);
-  const rel = relative(root, target);
-  if (rel === "" || rel === ".." || rel.startsWith(`..${sep2}`) || isAbsolute(rel)) {
+  const root = realpathSync2(resolve3(projectDir));
+  const target = resolve3(root, outputDir);
+  const rel = relative2(root, target);
+  if (rel === "" || rel === ".." || rel.startsWith(`..${sep3}`) || isAbsolute2(rel)) {
     throw new SakupaError("invalid_request", "Recovery outputDir must stay inside projectDir");
   }
-  if (rel === ".sakupa" || rel.startsWith(`.sakupa${sep2}`)) {
+  if (rel === ".sakupa" || rel.startsWith(`.sakupa${sep3}`)) {
     throw new SakupaError("invalid_request", "Recovery content cannot be written inside .sakupa");
   }
+  let existingAncestor = target;
+  while (!existsSync3(existingAncestor)) {
+    const parent = dirname2(existingAncestor);
+    if (parent === existingAncestor) break;
+    existingAncestor = parent;
+  }
+  const physicalAncestor = realpathSync2(existingAncestor);
+  const physicalTarget = resolve3(physicalAncestor, relative2(existingAncestor, target));
+  const physicalRel = relative2(root, physicalTarget);
+  if (physicalRel === ".." || physicalRel.startsWith(`..${sep3}`) || isAbsolute2(physicalRel)) {
+    throw new SakupaError(
+      "invalid_request",
+      "Recovery outputDir resolves through a symlink outside projectDir"
+    );
+  }
   return target;
 }
 function safeEntryName(name) {
@@ -1796,9 +2063,9 @@ async function listExistingFiles(root, current = root) {
     if (entry.isSymbolicLink()) {
       throw new SakupaError("state_conflict", `Recovery output contains a symlink: ${entry.name}`);
     }
-    const absolute = join3(current, entry.name);
+    const absolute = join4(current, entry.name);
     if (entry.isDirectory()) files.push(...await listExistingFiles(root, absolute));
-    else if (entry.isFile()) files.push(relative(root, absolute).split(sep2).join("/"));
+    else if (entry.isFile()) files.push(relative2(root, absolute).split(sep3).join("/"));
     else
       throw new SakupaError(
         "state_conflict",
@@ -1814,7 +2081,7 @@ async function existingOutputMatches(outputDir, files) {
     return false;
   }
   for (const name of expected) {
-    const actual = await readFile(join3(outputDir, ...name.split("/")));
+    const actual = await readFile(join4(outputDir, ...name.split("/")));
     const wanted = files[name];
     if (!wanted || actual.byteLength !== wanted.byteLength || !actual.equals(wanted)) return false;
   }
@@ -1824,7 +2091,7 @@ async function extractRecoveryArchive(input) {
   if (!Number.isSafeInteger(input.expectedBytes) || input.expectedBytes < 0 || input.expectedBytes > PAID_SITE_MAX_TOTAL_BYTES || !Number.isSafeInteger(input.expectedFiles) || input.expectedFiles < 0 || input.expectedFiles > MAX_FILE_COUNT) {
     throw new SakupaError("validation_failed", "Recovery archive metadata exceeds product limits");
   }
-  const outputDir = safeOutputPath(input.projectDir, input.outputDir ?? "html");
+  const outputDir = safeOutputPath(input.projectDir, input.outputDir);
   const maxArchiveBytes = input.expectedBytes + input.expectedFiles * 4096 + 65536;
   if (input.archive.byteLength > maxArchiveBytes) {
     throw new SakupaError("validation_failed", "Recovery archive is larger than its site metadata");
@@ -1865,13 +2132,13 @@ async function extractRecoveryArchive(input) {
       `Recovery output already exists with different content: ${outputDir}. Move it aside or choose another outputDir.`
     );
   }
-  const tempDir = await mkdtemp(join3(resolve2(input.projectDir), ".sakupa-restore-"));
+  const tempDir = await mkdtemp(join4(resolve3(input.projectDir), ".sakupa-restore-"));
   try {
     let writtenBytes = 0;
     const entries = Object.entries(files).sort(([a], [b]) => a.localeCompare(b));
     for (const [rawName, data] of entries) {
       const name = safeEntryName(rawName);
-      const destination = join3(tempDir, ...name.split("/"));
+      const destination = join4(tempDir, ...name.split("/"));
       await mkdir(dirname2(destination), { recursive: true });
       await writeFile(destination, data, { flag: "wx" });
       writtenBytes += data.byteLength;
@@ -1897,19 +2164,19 @@ async function extractRecoveryArchive(input) {
 }
 
 // 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 dirname3, join as join4 } from "node:path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { dirname as dirname3, join as join5 } 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 join4(base, ".sakupa", "created-sites.json");
+  const base = process.env["SAKUPA_STATE_DIR"] ?? homedir2();
+  return join5(base, ".sakupa", "created-sites.json");
 }
 function readAll() {
   const path = creationRegistryPath();
-  if (!existsSync2(path)) return [];
+  if (!existsSync4(path)) return [];
   try {
-    const parsed = JSON.parse(readFileSync2(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync3(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"
@@ -1920,8 +2187,8 @@ function readAll() {
 }
 function writeAll(records) {
   const path = creationRegistryPath();
-  mkdirSync2(dirname3(path), { recursive: true });
-  writeFileSync2(path, `${JSON.stringify(records, null, 2)}
+  mkdirSync3(dirname3(path), { recursive: true });
+  writeFileSync3(path, `${JSON.stringify(records, null, 2)}
 `, "utf-8");
 }
 function listRecentCreations(nowMs, apiBaseUrl) {
@@ -2077,12 +2344,6 @@ ${diag.layers}
 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 as isAbsolute2, parse, resolve as resolve3 } from "node:path";
-
 // src/tools/result.ts
 import { z } from "zod";
 var STRUCTURED_TOOL_OUTPUT_SCHEMA = {
@@ -2130,37 +2391,25 @@ var LocalGuidanceError = class extends SakupaError {
     super(code, message);
   }
 };
-var projectDirInput = z2.string().describe(
-  "REQUIRED on every call: absolute path of the user's PROJECT ROOT \u2014 the folder the user opened/works in (for framework projects: where package.json lives, NEVER the build-output subfolder like dist/out; the analyzer locates the output automatically). .sakupa/site.json lives here, so PASS THE SAME DIRECTORY EVERY TIME for the same project. Only YOU know which directory the user is in \u2014 the server never guesses and refuses calls without it."
-);
-function withProjectDir(ctx, projectDirArg) {
-  if (projectDirArg === void 0) {
-    throw new LocalGuidanceError(
-      "invalid_request",
-      "projectDir is REQUIRED on every call: pass the absolute path of the directory the user is CURRENTLY working in. The server never guesses a directory \u2014 a wrong guess once published one project's files over a different project's PAID site."
-    );
-  }
-  if (!isAbsolute2(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 = resolve3(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 stat2 = statSync(dir, { throwIfNoEntry: false });
-  if (!stat2?.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.`
-    );
+function withProjectDir(ctx) {
+  try {
+    const resolved = resolveLockedProjectRoot(ctx.projectDir);
+    return {
+      ...ctx,
+      projectDir: resolved.projectDir,
+      requestedPath: resolved.requestedPath,
+      markerKind: resolved.markerKind,
+      projectMarker: resolved.marker
+    };
+  } catch (error) {
+    if (error instanceof ProjectRootError) {
+      throw new LocalGuidanceError(
+        error.code === "not_initialized" ? "not_found" : "invalid_request",
+        error.message
+      );
+    }
+    throw error;
   }
-  return { ...ctx, projectDir: dir };
 }
 function requireSiteFile(ctx) {
   const state = loadSiteFile(ctx.projectDir);
@@ -2173,7 +2422,7 @@ function requireSiteFile(ctx) {
   if (state.kind === "absent") {
     throw new LocalGuidanceError(
       "not_found",
-      `No .sakupa/site.json found in ${ctx.projectDir} \u2014 this directory has no Sakupa site binding. If you meant to manage (delete/status/bind) an EXISTING site, re-run this tool with projectDir set to THAT site's own directory (each site's binding lives in its own folder). To publish THIS directory as a new site, run deploy. If this was a paid custom-domain site whose project file was lost, use recover.`
+      `No .sakupa/site.json found in ${ctx.projectDir} \u2014 this directory has no Sakupa site binding. If you meant to manage a different existing site, open that project as the AI tool workspace and start its Sakupa MCP process there. To publish THIS directory as a new site, run deploy. If this was a paid custom-domain site whose project file was lost, use recover.`
     );
   }
   return state.file;
@@ -2239,12 +2488,12 @@ ${JSON.stringify(obj, null, 2)}`;
     nextActions: []
   });
 }
-var planEnum = z3.enum(["water", "personal", "share", "business"]);
-var severityEnum = z3.enum(["low", "medium", "high", "critical"]);
+var planEnum = z2.enum(["water", "personal", "share", "business"]);
+var severityEnum = z2.enum(["low", "medium", "high", "critical"]);
 function planCatalog() {
   return TIER_ORDER.map((p) => `${p} JPY ${tierPriceJpy(p)}/month`).join(", ");
 }
-var ticketCategoryEnum = z3.enum([
+var ticketCategoryEnum = z2.enum([
   "billing",
   "payment",
   "refund_review",
@@ -2292,7 +2541,7 @@ function ensureUploadSizeWithinLimits(manifest, isFirstFreeDeploy) {
 async function buildHashedManifest(files, outputAbs) {
   const manifest = [];
   for (const file of files) {
-    const bytes = new Uint8Array(await fs2.readFile(join5(outputAbs, file.path)));
+    const bytes = new Uint8Array(await fs2.readFile(join6(outputAbs, file.path)));
     manifest.push({ path: file.path, size: file.size, contentHash: await sha256Hex(bytes) });
   }
   return manifest;
@@ -2311,7 +2560,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(join5(outputAbs, match.path)));
+    const bytes = new Uint8Array(await fs2.readFile(join6(outputAbs, match.path)));
     if (bytes.byteLength !== match.size) {
       throw new SakupaError(
         "validation_failed",
@@ -2354,21 +2603,6 @@ ${block}`, checklist: toDnsChecklist(diag.checks) };
     };
   }
 }
-function projectRootAbove(projectDir) {
-  if (existsSync3(join5(projectDir, "package.json"))) return null;
-  const packageRoot = findAncestor(projectDir, (dir) => existsSync3(join5(dir, "package.json")), 4);
-  if (packageRoot) {
-    return {
-      projectRoot: packageRoot,
-      outputDir: relative2(packageRoot, projectDir).split(sep3).join("/")
-    };
-  }
-  return null;
-}
-function findNeighborBinding(projectDir) {
-  const bound = (dir) => loadSiteFile(dir).kind !== "absent";
-  return findAncestor(projectDir, bound, 3);
-}
 function freeSiteCreationBarrier(apiBaseUrl) {
   const recent = listRecentCreations(Date.now(), apiBaseUrl);
   if (recent.length < FREE_ACTIVE_SITES_PER_IP) return null;
@@ -2379,7 +2613,7 @@ function freeSiteCreationBarrier(apiBaseUrl) {
 
 ` + recent.map((r) => `- ${r.url} (project: ${r.projectDir}, created: ${r.createdAt})`).join("\n") + `
 
-How a slot frees up: (1) delete one of the sites above \u2014 run delete with that site's projectDir; its slot frees immediately; (2) every record expires on its own 24 hours after creation; (3) a site that upgrades to a paid plan stops counting the next time any tool sees it. Deleting a project's .sakupa folder does NOT free a slot: this registry lives in the home directory and the server still counts the live site.
+How a slot frees up: (1) delete one of the sites above \u2014 run delete with that site opened as the AI tool's current project; its slot frees immediately; (2) every record expires on its own 24 hours after creation; (3) a site that upgrades to a paid plan stops counting the next time any tool sees it. Deleting a project's .sakupa folder does NOT free a slot: this registry lives in the home directory and the server still counts the live site.
 
 If this list is stale (sites deleted or subscribed from another machine), remove the local registry file at ${registryPath} and retry \u2014 that only skips this local precheck; the server still enforces the same per-IP limit and is the final authority.`,
     { recentCreations: recent, limit: FREE_ACTIVE_SITES_PER_IP, registryPath },
@@ -2395,13 +2629,12 @@ function registerTools(server, baseCtx) {
       outputSchema: STRUCTURED_TOOL_OUTPUT_SCHEMA,
       annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
       inputSchema: {
-        projectDir: projectDirInput,
-        outputDir: z3.string().optional().describe("Output directory relative to the project root (overrides detection).")
+        outputDir: z2.string().optional().describe("Output directory relative to the project root (overrides detection).")
       }
     },
     async (args) => {
       try {
-        const ctx = withProjectDir(baseCtx, args.projectDir);
+        const ctx = withProjectDir(baseCtx);
         const analysis = await analyzeProject(ctx.projectDir, {
           ...args.outputDir !== void 0 ? { outputDir: args.outputDir } : {}
         });
@@ -2419,35 +2652,54 @@ Next action: ${analysis.suggestedNextAction}`,
   server.registerTool(
     "deploy",
     {
-      description: `Deploy the local static output to Sakupa. First deploy creates a free temporary site (valid ${FREE_SITE_TTL_HOURS}h, public URL like https://${previewHostPattern}) and stores the management credential in .sakupa/site.json. Later runs update the existing site (free sites also refresh their validity; subscribed sites are permanent). Runs analyze first and refuses to upload source projects, secrets, .env files, archives, media or server code. projectDir is ALWAYS the project root where .sakupa belongs; outputDir is a separate REQUIRED relative path supplied from the current project inspection ("." when the root itself is published). NEVER pass the build/output folder as projectDir. Never uploads anything when analysis says the project is not deployable.`,
+      description: `Deploy the local static output to Sakupa. First deploy creates a free temporary site (valid ${FREE_SITE_TTL_HOURS}h, public URL like https://${previewHostPattern}) and stores the management credential in .sakupa/site.json. Later runs update the existing site (free sites also refresh their validity; subscribed sites are permanent). Runs analyze first and refuses to upload source projects, secrets, .env files, archives, media or server code. The MCP process is locked to the current directory initialized by \`npx -y @sakupa/mcp@latest init\`; no tool argument can change that root. outputDir is a separate REQUIRED relative path supplied from the current project inspection. Never uploads anything when analysis says the project is not deployable.`,
       outputSchema: STRUCTURED_TOOL_OUTPUT_SCHEMA,
       annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: true },
       inputSchema: {
-        projectDir: projectDirInput,
-        outputDir: z3.string().min(1).describe(
-          'REQUIRED: exact publish directory relative to projectDir, supplied by the AI after inspecting this project (for example ".", "dist", "html", or any custom build directory). NEVER put this path in projectDir; .sakupa belongs at projectDir.'
+        outputDir: z2.string().min(1).describe(
+          'REQUIRED: exact publish directory relative to the initialized project root, supplied by the AI after inspecting this project (for example ".", "dist", "html", or any custom build directory). Sakupa applies it only inside the cwd-locked project.'
+        ),
+        outputDirChangeConfirmed: z2.boolean().optional().describe(
+          "Required only when changing the previously successful publish directory. Confirm only after showing the old and new directories to the user."
         ),
-        spaFallback: z3.boolean().optional().describe(
+        spaFallback: z2.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: z3.boolean().optional().describe(
+        publicConfirmed: z2.boolean().optional().describe(
           "Required only for the first deployment: user explicitly confirmed creation of a public 24-hour URL."
         ),
-        subprojectConfirmed: z3.boolean().optional().describe(
-          "Only when creating a NEW site in a subfolder of a package.json project: the user explicitly confirmed this subfolder is an INDEPENDENT site, not the project's build output."
+        subprojectConfirmed: z2.boolean().optional().describe(
+          "Deprecated compatibility field. Project independence is established only by `sakupa-mcp init`, never inferred from package.json or folder names."
         ),
-        lang: z3.string().optional().describe("Site language override (en | ja | zh-CN); defaults to the html lang.")
+        lang: z2.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 ctx = withProjectDir(baseCtx);
         const analysis = await analyzeProject(ctx.projectDir, { outputDir: args.outputDir });
         if (!analysis.deployable || !analysis.files) {
           return notDeployableResult(analysis);
         }
+        const effectiveOutputDir = analysis.recommendedOutputDir ?? ".";
+        const recordedOutputDir = ctx.projectMarker?.outputDir;
+        if (recordedOutputDir !== void 0 && resolve4(ctx.projectDir, recordedOutputDir) !== resolve4(ctx.projectDir, effectiveOutputDir) && args.outputDirChangeConfirmed !== true) {
+          return structuredToolResult({
+            schemaVersion: 1,
+            outcome: "waiting_user",
+            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"
+            },
+            nextActions: [{ tool: "deploy", allowed: true, reasonCode: "explicit_confirmation" }]
+          });
+        }
         const files = analysis.files;
-        const outputAbs = resolve4(ctx.projectDir, analysis.recommendedOutputDir ?? ".");
+        const outputAbs = resolve4(ctx.projectDir, effectiveOutputDir);
         const manifest = await buildHashedManifest(files, outputAbs);
         const siteFileState = loadSiteFile(ctx.projectDir);
         if (siteFileState.kind === "corrupted") {
@@ -2462,46 +2714,31 @@ Next action: ${analysis.suggestedNextAction}`,
         }
         let existing = siteFileState.kind === "ok" ? siteFileState.file : null;
         let credentialRelocatedFrom = null;
-        if (!existing && analysis.recommendedOutputDir !== ".") {
+        if (!existing && effectiveOutputDir !== ".") {
+          const outputProjectMarker = loadProjectMarker(outputAbs);
+          if (outputProjectMarker.kind !== "absent") {
+            return text(
+              "publish_directory_is_independent_project",
+              outputProjectMarker.kind === "corrupted" ? `The selected publish directory ${outputAbs} contains a damaged Sakupa project marker: ${outputProjectMarker.problem}. Nothing was deployed.` : `The selected publish directory ${outputAbs} is itself an explicitly initialized Sakupa project. Refusing to move or reuse its credential from ${ctx.projectDir}. Run deploy from that independent project instead, or choose a publish directory that is not another Sakupa project.`,
+              { projectRoot: ctx.projectDir, outputDir: effectiveOutputDir },
+              "blocked"
+            );
+          }
           const outputSiteState = loadSiteFile(outputAbs);
           if (outputSiteState.kind === "corrupted") {
             return text(
               "output_site_file_corrupted",
-              `A misplaced .sakupa/site.json exists in output directory ${outputAbs}, but it is damaged: ${outputSiteState.problem}. Repair that file before retrying with projectDir: ${ctx.projectDir}. Nothing was deployed and no site was created.`,
+              `A misplaced .sakupa/site.json exists in output directory ${outputAbs}, but it is damaged: ${outputSiteState.problem}. Repair that file before retrying with the MCP still opened at ${ctx.projectDir}. Nothing was deployed and no site was created.`,
               { projectRoot: ctx.projectDir, outputDir: analysis.recommendedOutputDir },
               "blocked"
             );
           }
           if (outputSiteState.kind === "ok") {
-            writeSiteFile(ctx.projectDir, outputSiteState.file);
-            deleteSiteFile(outputAbs);
             existing = outputSiteState.file;
             credentialRelocatedFrom = outputAbs;
           }
         }
         if (!existing) {
-          const rootHint = args.subprojectConfirmed === true ? null : projectRootAbove(ctx.projectDir);
-          if (rootHint) {
-            return text(
-              "not_project_root",
-              `${ctx.projectDir} is a SUBFOLDER of a package.json project, and .sakupa must live at the project ROOT. Re-run deploy with projectDir: ${rootHint.projectRoot} and outputDir: ${rootHint.outputDir}. Only if the user explicitly says this subfolder is an INDEPENDENT site (e.g. a docs/ site inside a repo), re-run with subprojectConfirmed: true. Nothing was deployed and no site was created.`,
-              {
-                projectRoot: rootHint.projectRoot,
-                outputDir: rootHint.outputDir,
-                confirmationField: "subprojectConfirmed"
-              },
-              "blocked"
-            );
-          }
-          const neighbor = findNeighborBinding(ctx.projectDir);
-          if (neighbor) {
-            return text(
-              "neighbor_binding_found",
-              `No .sakupa binding in ${ctx.projectDir}, but one EXISTS at ${neighbor} \u2014 this looks like the same project addressed at a different directory level. To update that existing site, re-run deploy with projectDir: ${neighbor}. Only if the user explicitly wants a SEPARATE new site, move this deploy to a directory outside that project. Nothing was deployed and no site was created.`,
-              { neighborProjectDir: neighbor },
-              "blocked"
-            );
-          }
           const barrier = freeSiteCreationBarrier(ctx.apiBaseUrl);
           if (barrier) return barrier;
           if (args.publicConfirmed !== true) {
@@ -2535,6 +2772,7 @@ Next action: ${analysis.suggestedNextAction}`,
             createdAt,
             apiBaseUrl: ctx.apiBaseUrl
           });
+          updateProjectOutputDir(ctx.projectDir, effectiveOutputDir);
           recordCreation({
             siteId: created.siteId,
             projectDir: ctx.projectDir,
@@ -2609,6 +2847,8 @@ ${JSON.stringify(finalized2.warnings, null, 2)}` : ""),
         }
         const { uploaded, finalized } = update;
         writeSiteFile(ctx.projectDir, { ...existing, url: finalized.url });
+        if (credentialRelocatedFrom !== null) deleteSiteFile(credentialRelocatedFrom);
+        updateProjectOutputDir(ctx.projectDir, effectiveOutputDir);
         noteSiteMode(existing.siteId, finalized.mode);
         return text(
           "site_updated",
@@ -2647,11 +2887,11 @@ ${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: { projectDir: projectDirInput }
+      inputSchema: {}
     },
-    async (args) => {
+    async () => {
       try {
-        const ctx = withProjectDir(baseCtx, args.projectDir);
+        const ctx = withProjectDir(baseCtx);
         const site = requireSiteFile(ctx);
         const res = await ctx.client.refreshSite(site.siteId, site.credential);
         return text(
@@ -2671,11 +2911,11 @@ 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, custom domains, size, last deployment and warnings. For a paid site this tool also automatically returns the complete authoritative billing snapshot; users never need to know or name a separate billing tool to get accurate subscription information.",
       outputSchema: STRUCTURED_TOOL_OUTPUT_SCHEMA,
       annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: true },
-      inputSchema: { projectDir: projectDirInput }
+      inputSchema: {}
     },
-    async (args) => {
+    async () => {
       try {
-        const ctx = withProjectDir(baseCtx, args.projectDir);
+        const ctx = withProjectDir(baseCtx);
         const site = requireSiteFile(ctx);
         const res = await ctx.client.getSiteStatus(site.siteId, site.credential);
         noteSiteMode(res.siteId, res.mode);
@@ -2703,7 +2943,6 @@ 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)."
         )
@@ -2711,13 +2950,13 @@ 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 ctx = withProjectDir(baseCtx);
         const site = requireSiteFile(ctx);
         const res = await ctx.client.createPlanCheckout(
           {
             siteId: site.siteId,
             plan: args.plan,
-            idempotencyKey: randomUUID()
+            idempotencyKey: randomUUID2()
           },
           site.credential
         );
@@ -2750,17 +2989,16 @@ 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: {
-        projectDir: projectDirInput,
-        action: z3.enum(["start", "status"]),
-        hostname: z3.string().optional().describe("Required for start."),
-        verificationId: z3.string().optional().describe(
+        action: z2.enum(["start", "status"]),
+        hostname: z2.string().optional().describe("Required for start."),
+        verificationId: z2.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 ctx = withProjectDir(baseCtx);
         const site = requireSiteFile(ctx);
         if (args.action === "status") {
           const res2 = args.verificationId ? await ctx.client.checkVerification(args.verificationId, site.credential) : await ctx.client.checkVerification("latest", site.credential, site.siteId);
@@ -2865,11 +3103,11 @@ When the user says the TXT is set, run bind "status". It verifies ownership and
       description: "Return the sole authoritative source for this site's hosting subscription: current plan, next renewal plan or cancellation, effective time, payment state, current paid entitlement, 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: { projectDir: projectDirInput }
+      inputSchema: {}
     },
-    async (args) => {
+    async () => {
       try {
-        const ctx = withProjectDir(baseCtx, args.projectDir);
+        const ctx = withProjectDir(baseCtx);
         const site = requireSiteFile(ctx);
         const res = await ctx.client.getBillingStatus(site.siteId, site.credential);
         noteSiteMode(res.siteId, res.mode);
@@ -2907,14 +3145,13 @@ Full status:`, res);
       outputSchema: STRUCTURED_TOOL_OUTPUT_SCHEMA,
       annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
       inputSchema: {
-        projectDir: projectDirInput,
-        scope: z3.enum(["site", "public_recovery"])
+        scope: z2.enum(["site", "public_recovery"])
       }
     },
     async (args) => {
       try {
-        const ctx = withProjectDir(baseCtx, args.projectDir);
         if (args.scope === "site") {
+          const ctx = withProjectDir(baseCtx);
           const site = requireSiteFile(ctx);
           const res2 = await ctx.client.createBillingPortal(site.siteId, site.credential);
           return structuredToolResult({
@@ -2932,7 +3169,7 @@ Full status:`, res);
             nextActions: [{ tool: "billing", allowed: true }]
           });
         }
-        const res = await ctx.client.getPublicBillingPortal();
+        const res = await baseCtx.client.getPublicBillingPortal();
         return structuredToolResult({
           schemaVersion: 1,
           outcome: "waiting_user",
@@ -2960,21 +3197,28 @@ Full status:`, res);
   server.registerTool(
     "recover",
     {
-      description: "Recover management control of a subscribed site WITH A BOUND CUSTOM DOMAIN after losing the local project, by proving DNS control of the apex domain. Sites without a bound domain are identified solely by their local credential and cannot be recovered. By default, completing recovery REVOKES all previous local credentials. Recovery is resumable: start stores local pending state; complete installs and writes the new .sakupa/site.json credential BEFORE requesting content; download uses that credential to reissue an archive and safely extract it into html without repeating DNS.",
+      description: "Recover management control of a subscribed site WITH A BOUND CUSTOM DOMAIN after losing the local project, by proving DNS control of the apex domain. Sites without a bound domain are identified solely by their local credential and cannot be recovered. By default, completing recovery REVOKES all previous local credentials. Recovery is resumable: start stores local pending state; complete installs and writes the new .sakupa/site.json credential BEFORE requesting content; download uses that credential to reissue an archive and safely extract it into the explicitly selected outputDir without repeating DNS.",
       outputSchema: STRUCTURED_TOOL_OUTPUT_SCHEMA,
       annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: true },
       inputSchema: {
-        projectDir: projectDirInput,
-        action: z3.enum(["start", "status", "complete", "download"]),
-        hostname: z3.string().optional().describe("Required for start."),
-        verificationId: z3.string().optional().describe("For status or complete; inferred from local recovery state when omitted."),
-        outputDir: z3.string().optional().describe("Relative extraction directory for complete/download (default: html)."),
-        preserveExistingCredentials: z3.boolean().optional().describe("Explicitly keep old local credentials working (default: revoke them all).")
+        action: z2.enum(["start", "status", "complete", "download"]),
+        hostname: z2.string().optional().describe("Required for start."),
+        verificationId: z2.string().optional().describe("For status or complete; inferred from local recovery state when omitted."),
+        outputDir: z2.string().optional().describe(
+          "REQUIRED for complete/download: exact extraction directory relative to the initialized project root. Inspect the current project; Sakupa never guesses a name."
+        ),
+        preserveExistingCredentials: z2.boolean().optional().describe("Explicitly keep old local credentials working (default: revoke them all).")
       }
     },
     async (args) => {
       try {
-        const ctx = withProjectDir(baseCtx, args.projectDir);
+        const ctx = withProjectDir(baseCtx);
+        if ((args.action === "complete" || args.action === "download") && args.outputDir === void 0) {
+          throw new LocalGuidanceError(
+            "invalid_request",
+            "recover requires outputDir for complete/download. Inspect the current project and pass the exact extraction directory relative to the initialized Sakupa root; the server never defaults to html, dist, build, or any other name."
+          );
+        }
         const localSite = loadSiteFile(ctx.projectDir);
         const localCredentialIsActive = async () => {
           if (localSite.kind !== "ok") return false;
@@ -2987,12 +3231,18 @@ Full status:`, res);
           }
         };
         const download = async () => {
+          if (args.outputDir === void 0) {
+            throw new LocalGuidanceError(
+              "invalid_request",
+              "recover download requires an explicit outputDir."
+            );
+          }
           const site = requireSiteFile(ctx);
           const archive = await ctx.client.getSiteArchive(site.siteId, site.credential);
           const bytes = await ctx.client.downloadArchive(archive.archiveUrl);
           const extracted = await extractRecoveryArchive({
             projectDir: ctx.projectDir,
-            ...args.outputDir !== void 0 ? { outputDir: args.outputDir } : {},
+            outputDir: args.outputDir,
             archive: bytes,
             expectedBytes: archive.totalBytes,
             expectedFiles: archive.fileCount
@@ -3035,9 +3285,8 @@ No DNS verification was started or repeated.`,
                 {
                   tool: "recover",
                   arguments: {
-                    projectDir: ctx.projectDir,
                     action: "download",
-                    outputDir: args.outputDir ?? "html"
+                    ...args.outputDir !== void 0 ? { outputDir: args.outputDir } : {}
                   },
                   allowed: true
                 }
@@ -3062,7 +3311,6 @@ No DNS verification was started or repeated.`,
                 {
                   tool: "recover",
                   arguments: {
-                    projectDir: ctx.projectDir,
                     action: "status",
                     verificationId: pending2.verificationId
                   },
@@ -3135,9 +3383,8 @@ After the DNS record resolves, re-run recover with verificationId: "${res2.verif
               {
                 tool: "recover",
                 arguments: {
-                  projectDir: ctx.projectDir,
                   action: "download",
-                  outputDir: args.outputDir ?? "html"
+                  ...args.outputDir !== void 0 ? { outputDir: args.outputDir } : {}
                 },
                 allowed: true
               }
@@ -3170,10 +3417,9 @@ After the DNS record resolves, re-run recover with verificationId: "${res2.verif
               {
                 tool: "recover",
                 arguments: {
-                  projectDir: ctx.projectDir,
                   action: "complete",
                   verificationId,
-                  outputDir: args.outputDir ?? "html"
+                  ...args.outputDir !== void 0 ? { outputDir: args.outputDir } : {}
                 },
                 allowed: res2.readyToComplete,
                 ...res2.readyToComplete ? {} : { reasonCode: res2.status }
@@ -3247,9 +3493,8 @@ Files: ${extracted.fileCount}; bytes: ${extracted.totalBytes}
               {
                 tool: "recover",
                 arguments: {
-                  projectDir: ctx.projectDir,
                   action: "download",
-                  outputDir: args.outputDir ?? "html"
+                  ...args.outputDir !== void 0 ? { outputDir: args.outputDir } : {}
                 },
                 allowed: true
               }
@@ -3268,16 +3513,15 @@ Files: ${extracted.fileCount}; bytes: ${extracted.totalBytes}
       outputSchema: STRUCTURED_TOOL_OUTPUT_SCHEMA,
       annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
       inputSchema: {
-        projectDir: projectDirInput,
         category: ticketCategoryEnum,
-        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.")
+        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.")
       }
     },
     async (args) => {
       try {
-        const ctx = withProjectDir(baseCtx, args.projectDir);
+        const ctx = withProjectDir(baseCtx);
         const site = requireSiteFile(ctx);
         const res = await ctx.client.createTicket(site.credential, {
           siteId: site.siteId,
@@ -3303,26 +3547,25 @@ Files: ${extracted.fileCount}; bytes: ${extracted.totalBytes}
       outputSchema: STRUCTURED_TOOL_OUTPUT_SCHEMA,
       annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
       inputSchema: {
-        projectDir: projectDirInput,
-        toolName: z3.string().describe('The Sakupa tool that failed, e.g. "deploy".'),
-        errorCode: z3.string().optional(),
-        errorMessage: z3.string().optional().describe("Sanitized error message (no secrets)."),
-        requestId: z3.string().optional(),
-        deploymentId: z3.string().optional(),
+        toolName: z2.string().describe('The Sakupa tool that failed, e.g. "deploy".'),
+        errorCode: z2.string().optional(),
+        errorMessage: z2.string().optional().describe("Sanitized error message (no secrets)."),
+        requestId: z2.string().optional(),
+        deploymentId: z2.string().optional(),
         severity: severityEnum.optional(),
-        description: z3.string().optional().describe("What happened, in the user's words (no secrets)."),
-        agentContext: z3.string().optional().describe(
+        description: z2.string().optional().describe("What happened, in the user's words (no secrets)."),
+        agentContext: z2.string().optional().describe(
           "YOUR OWN factual account of the session as the AI: which tools you called, what they returned, expected vs actual. Write it yourself from your observations \u2014 never ask the user to compose it, and do not read it back to them; it travels alongside the user's description as a second witness. No secrets, no file contents."
         ),
-        contactEmail: z3.string().optional().describe(
+        contactEmail: z2.string().optional().describe(
           "OPTIONAL. Before submitting, ask the user ONCE whether they want to leave a contact for follow-up. Omit entirely if they decline \u2014 never require it."
         ),
-        confirmSubmit: z3.boolean().optional().describe("User reviewed the report payload and approved submission.")
+        confirmSubmit: z2.boolean().optional().describe("User reviewed the report payload and approved submission.")
       }
     },
     async (args) => {
       try {
-        const ctx = withProjectDir(baseCtx, args.projectDir);
+        const ctx = withProjectDir(baseCtx);
         const siteState = loadSiteFile(ctx.projectDir);
         const site = siteState.kind === "ok" ? siteState.file : null;
         const diagnostics = {
@@ -3369,20 +3612,19 @@ Summary: ${res.sanitizedSummary}`,
 }
 
 // src/tools/billing.ts
-import { z as z4 } from "zod";
+import { z as z3 } from "zod";
 function registerBillingTools(server, baseCtx) {
   server.registerTool(
     "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: { projectDir: projectDirInput },
+      inputSchema: {},
       outputSchema: STRUCTURED_TOOL_OUTPUT_SCHEMA,
       annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: true }
     },
-    async (args) => {
+    async () => {
       try {
-        const ctx = withProjectDir(baseCtx, args.projectDir);
-        const catalog = await ctx.client.getBillingPlanCatalog();
+        const catalog = await baseCtx.client.getBillingPlanCatalog();
         return structuredToolResult({
           schemaVersion: 1,
           outcome: "completed",
@@ -3401,15 +3643,14 @@ function registerBillingTools(server, baseCtx) {
     {
       description: "Create one Stripe-hosted subscription-management link. The user chooses the plan or period-end cancellation on Stripe; Sakupa never infers intent from the conversation. Creating the link does not change billing.",
       inputSchema: {
-        projectDir: projectDirInput,
-        operationId: z4.string().min(1)
+        operationId: z3.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 ctx = withProjectDir(baseCtx);
         const site = requireSiteFile(ctx);
         const result = await ctx.client.changeSubscriptionPlan(site.credential, {
           siteId: site.siteId,
@@ -3438,22 +3679,22 @@ function registerBillingTools(server, baseCtx) {
 }
 
 // src/tools/lifecycle.ts
-import { randomUUID as randomUUID2 } from "node:crypto";
-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_and_cancel_renewal")
+import { randomUUID as randomUUID3 } from "node:crypto";
+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_and_cancel_renewal")
 });
 function registerLifecycleTools(server, baseCtx) {
   server.registerTool(
@@ -3461,9 +3702,8 @@ function registerLifecycleTools(server, baseCtx) {
     {
       description: "Preview or execute deletion of this Sakupa site. Execution requires an exact server-validated confirmation bound to the current site state. Paid sites must first cancel renewal through portal and return to free mode. For a temporary pause, publish a pause notice as index.html with deploy instead of deleting the site.",
       inputSchema: {
-        projectDir: projectDirInput,
-        action: z5.enum(["preview", "confirm"]),
-        operationId: z5.string().min(1).optional(),
+        action: z4.enum(["preview", "confirm"]),
+        operationId: z4.string().min(1).optional(),
         confirmation: deleteConfirmation.optional()
       },
       outputSchema: STRUCTURED_TOOL_OUTPUT_SCHEMA,
@@ -3471,9 +3711,9 @@ function registerLifecycleTools(server, baseCtx) {
     },
     async (args) => {
       try {
-        const ctx = withProjectDir(baseCtx, args.projectDir);
+        const ctx = withProjectDir(baseCtx);
         const site = requireSiteFile(ctx);
-        const operationId = args.operationId ?? randomUUID2();
+        const operationId = args.operationId ?? randomUUID3();
         if (args.action === "preview") {
           const preview = await ctx.client.previewDeleteSite(site.siteId, site.credential, {
             operationId
@@ -3668,18 +3908,22 @@ Workflow:
 5. support (subscribed sites) opens a support ticket; report 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). projectDir is REQUIRED on EVERY tool call \u2014 always pass the absolute path of
-the user's PROJECT ROOT, the SAME directory every time for the same project: the folder
-the user opened (for framework projects, where package.json lives \u2014 never the dist/out
-build folder). For deploy, ALWAYS pass outputDir separately as the exact path RELATIVE to
-projectDir (use "." when publishing the root); outputDir is required and may have ANY name,
-so inspect the current project and never infer it from a conventional folder name. The server
-NEVER guesses either directory: only you can see the user's actual workspace and build output.
+Project directory contract: before the first deploy or a new recovery, initialize the intended
+project once by running "npx -y @sakupa/mcp@latest init" with NO path argument from the AI
+tool's current project directory. This immediately creates the non-secret .sakupa/project.json
+there. ONE MCP process = ONE cwd-locked project = ONE site. Site tools do not accept projectDir
+and cannot select another root; plans and public_recovery portal remain project-independent.
+Sakupa stores .sakupa/site.json and recovery state only in the locked directory; it never uses
+package.json, .git, framework names or output-directory names to guess. For deploy, ALWAYS pass
+outputDir separately as the exact path RELATIVE to the locked directory (use "." when publishing
+the root); outputDir is
+required and may have ANY name, so inspect the current project. If it differs from the last
+successful publish directory, show the old and new paths and obtain explicit confirmation
+before retrying with outputDirChangeConfirmed: true.
 After every deploy, TELL the user which environment it went to (deploy results carry an
 Explicit Environment line: TEST vs PRODUCTION). analyze, deploy, status,
 refresh and delete echo
-the directory they acted on \u2014 verify it matches the user's active project.
+the cwd-locked directory they acted on.
 
 When the same operation fails twice in a row, or the user is clearly stuck or
 frustrated, proactively offer report: it files the problem into Sakupa's ticket and
@@ -3717,7 +3961,11 @@ function createSakupaMcpServer(opts) {
     { name: "sakupa", version: MCP_VERSION },
     { instructions: instructionsFor(previewHostPatternFor(opts.apiBaseUrl)) }
   );
-  const ctx = { client, apiBaseUrl: opts.apiBaseUrl };
+  const ctx = {
+    client,
+    apiBaseUrl: opts.apiBaseUrl,
+    projectDir: canonicalProjectDirectory(opts.projectDir ?? process.cwd())
+  };
   registerTools(server, ctx);
   registerBillingTools(server, ctx);
   registerLifecycleTools(server, ctx);
@@ -3726,12 +3974,24 @@ function createSakupaMcpServer(opts) {
 
 // src/bin.ts
 async function main() {
+  const argv = process.argv.slice(2);
+  if (argv[0] === "init") {
+    const result = await runInitCommand(argv.slice(1), {
+      write: (message) => stdout.write(`${message}
+`)
+    });
+    process.exitCode = result.exitCode;
+    return;
+  }
+  if (argv.length > 0) {
+    throw new Error("Usage: sakupa-mcp [init]");
+  }
   const config = loadMcpRuntimeConfig();
   const server = createSakupaMcpServer(config);
   const transport = new StdioServerTransport();
   await server.connect(transport);
   console.error(
-    `[sakupa-mcp] v${MCP_VERSION} connected (api: ${config.apiBaseUrl}; every tool call requires projectDir)`
+    `[sakupa-mcp] v${MCP_VERSION} connected (api: ${config.apiBaseUrl}; project: ${process.cwd()})`
   );
 }
 main().catch((err2) => {