@bonginkan/maria 4.3.45 → 4.3.46

package/dist/bin/maria.cjs

@@ -26066,8 +26066,8 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "@bonginkan/maria",
-      version: "4.3.45",
-      description: "\u{1F680} MARIA v4.3.45 - Enterprise AI Development Platform with identity system and character voice implementation. Features 74 production-ready commands with comprehensive fallback implementation, local LLM support, and zero external dependencies. Includes natural language coding, AI safety evaluation, intelligent evolution system, episodic memory with PII masking, and real-time monitoring dashboard. Built with TypeScript AST-powered code generation, OAuth2.0 + PKCE authentication, quantum-resistant cryptography, and enterprise-grade performance.",
+      version: "4.3.46",
+      description: "\u{1F680} MARIA v4.3.46 - Enterprise AI Development Platform with identity system and character voice implementation. Features 74 production-ready commands with comprehensive fallback implementation, local LLM support, and zero external dependencies. Includes natural language coding, AI safety evaluation, intelligent evolution system, episodic memory with PII masking, and real-time monitoring dashboard. Built with TypeScript AST-powered code generation, OAuth2.0 + PKCE authentication, quantum-resistant cryptography, and enterprise-grade performance.",
       keywords: [
         "ai",
         "cli",
@@ -26619,7 +26619,8 @@ var init_env_loader = __esm({
 var ThinkingAnimation, ProcessAnimation;
 var init_animations = __esm({
   "src/utils/animations.ts"() {
-    ThinkingAnimation = class {
+    ThinkingAnimation = class _ThinkingAnimation {
+      static current = null;
       frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
       currentFrame = 0;
       interval = null;
@@ -26628,6 +26629,13 @@ var init_animations = __esm({
         this.message = message;
       }
       start() {
+        if (_ThinkingAnimation.current && _ThinkingAnimation.current !== this) {
+          try {
+            _ThinkingAnimation.current.stop();
+          } catch {
+          }
+        }
+        _ThinkingAnimation.current = this;
         this.interval = setInterval(() => {
           process.stdout.write(
             `\r${chalk14__default.default.cyan(this.frames[this.currentFrame])} ${chalk14__default.default.gray(this.message)}...`
@@ -26641,12 +26649,16 @@ var init_animations = __esm({
           this.interval = null;
           process.stdout.write("\r\x1B[K");
         }
+        if (_ThinkingAnimation.current === this) {
+          _ThinkingAnimation.current = null;
+        }
       }
       updateMessage(message) {
         this.message = message;
       }
     };
-    ProcessAnimation = class {
+    ProcessAnimation = class _ProcessAnimation {
+      static current = null;
       stages = [
         { icon: "\u{1F9E0}", message: "Understanding your request" },
         { icon: "\u{1F50D}", message: "Analyzing context" },
@@ -26660,7 +26672,18 @@ var init_animations = __esm({
       interval = null;
       stageInterval = null;
       startTime = 0;
+      // Expose whether any ProcessAnimation is currently active
+      static hasActive() {
+        return !!_ProcessAnimation.current;
+      }
       start() {
+        if (_ProcessAnimation.current && _ProcessAnimation.current !== this) {
+          try {
+            _ProcessAnimation.current.stop();
+          } catch {
+          }
+        }
+        _ProcessAnimation.current = this;
         this.startTime = Date.now();
         this.currentStage = 0;
         this.currentFrame = 0;
@@ -26688,6 +26711,9 @@ var init_animations = __esm({
           this.stageInterval = null;
         }
         process.stdout.write("\r\x1B[K");
+        if (_ProcessAnimation.current === this) {
+          _ProcessAnimation.current = null;
+        }
       }
       setStage(stageIndex) {
         if (stageIndex >= 0 && stageIndex < this.stages.length) {
@@ -28104,7 +28130,7 @@ var init_AuthenticationManager = __esm({
           const response = await fetch(`${this.apiBase}/api/user/profile`, {
             headers: {
               "Authorization": `Bearer ${tokens2.accessToken}`,
-              "User-Agent": `maria-cli/${process.env.CLI_VERSION || "4.3.45"}`
+              "User-Agent": `maria-cli/${process.env.CLI_VERSION || "4.3.46"}`
             }
           });
           if (response.status === 401) {
@@ -28758,7 +28784,7 @@ async function callApi(path65, init3 = {}) {
     "Authorization": `Bearer ${token}`,
     "X-Device-Id": getDeviceId(),
     "X-Session-Id": getSessionId() || "",
-    "User-Agent": `maria-cli/${process.env.CLI_VERSION || "4.3.45"}`,
+    "User-Agent": `maria-cli/${process.env.CLI_VERSION || "4.3.46"}`,
     "Content-Type": init3.headers?.["Content-Type"] || "application/json"
   });
   const doFetch = async (token) => {
@@ -29102,15 +29128,27 @@ async function callAPI(endpoint, options = {}) {
     throw err;
   }
 }
-async function executeChat(messages) {
+async function executeChat(messages, options) {
   const maxAttempts = 4;
   let lastErr;
   for (let attempt = 1; attempt <= maxAttempts; attempt++) {
     try {
+      if (process.env.MARIA_DEBUG === "1") {
+        try {
+          console.log("[DEBUG/ai] chat.request", { attempt, provider: options?.provider, model: options?.model, messages: messages.slice(0, 3) });
+        } catch {
+        }
+      }
       const response = await callAPI("/v1/ai-proxy", {
         method: "POST",
-        body: { messages, taskType: "chat" }
+        body: { messages, taskType: "chat", ...options?.provider ? { provider: options.provider } : {}, ...options?.model ? { model: options.model } : {} }
       });
+      if (process.env.MARIA_DEBUG === "1") {
+        try {
+          console.log("[DEBUG/ai] chat.response.head", String(response?.data?.content || response?.output || "").slice(0, 1200));
+        } catch {
+        }
+      }
       return response;
     } catch (e2) {
       lastErr = e2;
@@ -29142,6 +29180,13 @@ async function executeCode(input3) {
   let lastErr;
   for (let attempt = 1; attempt <= maxAttempts; attempt++) {
     try {
+      if (process.env.MARIA_DEBUG === "1") {
+        try {
+          const dbg = typeof input3 === "string" ? { prompt: String(input3).slice(0, 800) } : { prompt: input3.prompt.slice(0, 800), provider: input3.provider, model: input3.model, attachments: Array.isArray(input3.attachments) ? input3.attachments.length : 0 };
+          console.log("[DEBUG/ai] code.request", { attempt, ...dbg });
+        } catch {
+        }
+      }
       const response = await callAPI("/v1/ai-proxy", {
         method: "POST",
         body
@@ -29152,6 +29197,12 @@ async function executeCode(input3) {
       if (response.data?.content) {
         response.output = response.data.content;
       }
+      if (process.env.MARIA_DEBUG === "1") {
+        try {
+          console.log("[DEBUG/ai] code.response.head", String(response?.output || "").slice(0, 1200));
+        } catch {
+        }
+      }
       return response;
     } catch (e2) {
       lastErr = e2;
@@ -51298,7 +51349,7 @@ var init_about_command = __esm({
       async execute(args2, context2) {
         const output3 = [];
         output3.push("");
-        output3.push(chalk14__default.default.cyan.bold("\u{1F916} About MARIA v4.3.45"));
+        output3.push(chalk14__default.default.cyan.bold("\u{1F916} About MARIA v4.3.46"));
         output3.push(chalk14__default.default.gray("\u2550".repeat(40)));
         output3.push("");
         output3.push(chalk14__default.default.white.bold("MARIA - Minimal API, Maximum Power"));
@@ -55025,9 +55076,10 @@ function extractFirstJson5(text) {
 async function inferCodeArgs(rawText) {
   const system = [
     "You extract structured options for a code command.",
-    'Return JSON only with keys: { "planOnly"?: boolean, "dryRun"?: boolean, "output"?: "names"|"summary"|"detail", "previewLines"?: number }.',
+    'Return JSON only with keys: { "planOnly"?: boolean, "dryRun"?: boolean, "output"?: "names"|"summary"|"detail", "previewLines"?: number, "onlyAttached"?: boolean }.',
     "Decide from the user text whether planOnly or dryRun should be true. Do not explain.",
-    "Only include output if the user requests preview detail or summary mode. Only include previewLines if a specific number of lines is requested."
+    "Only include output if the user requests preview detail or summary mode. Only include previewLines if a specific number of lines is requested.",
+    "Set onlyAttached=true when the user indicates editing only attached/uploaded/provided files, or restrict changes to referenced files."
   ].join("\n");
   const resp = await callAPI("/v1/ai-proxy", {
     method: "POST",
@@ -55048,11 +55100,19 @@ ${rawText}`,
   } catch {
     return {};
   }
+  if (process.env.MARIA_DEBUG === "1") {
+    try {
+      console.log("[DEBUG/code] inferCodeArgs.response.raw", raw.slice(0, 1200));
+      console.log("[DEBUG/code] inferCodeArgs.parsed", parsed);
+    } catch {
+    }
+  }
   const out = {};
   if (typeof parsed.planOnly === "boolean") out.planOnly = parsed.planOnly;
   if (typeof parsed.dryRun === "boolean") out.dryRun = parsed.dryRun;
   if (typeof parsed.output === "string" && (parsed.output === "names" || parsed.output === "summary" || parsed.output === "detail")) out.output = parsed.output;
   if (typeof parsed.previewLines === "number" && Number.isFinite(parsed.previewLines) && parsed.previewLines > 0) out.previewLines = Math.min(2e3, Math.floor(parsed.previewLines));
+  if (typeof parsed.onlyAttached === "boolean") out.onlyAttached = parsed.onlyAttached;
   if (out.planOnly) out.dryRun = false;
   return out;
 }
@@ -55200,6 +55260,12 @@ var init_FilePlanBuilder = __esm({
   }
 });
 async function validatePlan(plans, opts) {
+  if (process.env.MARIA_DEBUG === "1") {
+    try {
+      console.log("[DEBUG/orchestrator] validatePlan.input.count", plans.length);
+    } catch {
+    }
+  }
   const warnings = [];
   const skipped = [];
   const seenLC = /* @__PURE__ */ new Set();
@@ -55216,6 +55282,10 @@ async function validatePlan(plans, opts) {
   }
   const safe = [];
   for (const fp of outFiltered) {
+    if (fp.action === "skip") {
+      skipped.push(fp.path);
+      continue;
+    }
     const rel = fp.path.replace(/^\/+/, "");
     if (rel.includes("..")) {
       warnings.push(`Path traversal denied: ${fp.path}`);
@@ -55297,7 +55367,18 @@ async function validatePlan(plans, opts) {
     }
     result.push({ ...fp, action: willModify ? "modify" : "create" });
   }
-  return { files: result, skipped, warnings };
+  const out = { files: result, skipped, warnings };
+  if (process.env.MARIA_DEBUG === "1") {
+    try {
+      console.log("[DEBUG/orchestrator] validatePlan.output", {
+        files: out.files.map((f3) => ({ path: f3.path, action: f3.action })),
+        skipped: out.skipped,
+        warnings: out.warnings
+      });
+    } catch {
+    }
+  }
+  return out;
 }
 async function exists(p) {
   try {
@@ -56091,7 +56172,7 @@ ${h2.head}`);
     const resp = await executeChat([
       { role: "system", content: system },
       { role: "user", content: user }
-    ]);
+    ], { provider: "google", model: "gemini-2.5-flash-lite" });
     const raw = (resp?.output || "").trim();
     const jsonText = extractJsonSafe(raw, "array") || raw;
     const arr = JSON.parse(jsonText);
@@ -56108,7 +56189,7 @@ ${h2.head}`);
     return [];
   }
 }
-async function llmMapBlocksBatch(root, request, blocks, repoFiles) {
+async function llmMapBlocksBatch(root, request, blocks, repoFiles, opts) {
   try {
     const candidates = repoFiles.filter((p) => /\.(html|css|js|ts|tsx)$/i.test(p)).slice(0, 120);
     const blockSnippets = blocks.slice(0, 20).map((b, i2) => {
@@ -56126,26 +56207,43 @@ ${head2}
 ${h2.head}`);
     }
     const system = [
-      "For each provided code block, decide whether to MODIFY an existing repo file or CREATE a new file.",
-      'Return JSON array of objects: [{ "index": number, "action": "modify"|"create", "path": string }].',
-      "When action is modify, path MUST be one of the candidate repo-relative paths listed."
+      "You act as a precise file mapper for code edits.",
+      "For each provided code block, decide to MODIFY an existing repo file or CREATE a new file.",
+      "Rules:",
+      "- Prefer MODIFY when an existing file in candidates plausibly matches the block (same technology, same area).",
+      "- If any TargetDirHints are provided, prefer files under those directories when choosing MODIFY targets.",
+      "- Only choose CREATE if NO suitable candidate exists. Do NOT invent frameworks or restructure.",
+      "- When MODIFY, the path MUST be one of the candidate repo-relative paths listed.",
+      'Return JSON array: [{ "index": number, "action": "modify"|"create", "path": string }].'
     ].join("\n");
     const user = [
       `Request: ${request}`,
       "Blocks:",
       blockSnippets,
       "Candidates:",
-      samples.join("\n\n")
+      samples.join("\n\n"),
+      `TargetDirHints: ${(opts?.dirHints || []).join(", ")}`
     ].join("\n\n");
-    const spin = new ProcessAnimation();
-    spin.start();
-    const resp = await executeChat([
-      { role: "system", content: system },
-      { role: "user", content: user }
-    ]);
+    let startedLocalSpinner = false;
+    let spin = null;
+    if (!ProcessAnimation.hasActive()) {
+      spin = new ProcessAnimation();
+      spin.start();
+      startedLocalSpinner = true;
+    }
+    let resp;
     try {
-      spin.stop();
-    } catch {
+      resp = await executeChat([
+        { role: "system", content: system },
+        { role: "user", content: user }
+      ], { provider: "google", model: "gemini-2.5-flash-lite" });
+    } finally {
+      if (startedLocalSpinner && spin) {
+        try {
+          spin.stop();
+        } catch {
+        }
+      }
     }
     const raw = (resp?.output || "").trim();
     const jsonText = extractJsonSafe(raw, "array") || raw;
@@ -56199,12 +56297,25 @@ function trackCodeFallback(event) {
   }
 }
 async function orchestrate(request, opts) {
+  const dbg = (...a) => {
+    if (process.env.MARIA_DEBUG === "1") {
+      try {
+        console.log("[DEBUG/orchestrator]", ...a);
+      } catch {
+      }
+    }
+  };
   const profile = await scanRepo(opts.root);
+  dbg("start", { root: opts.root, flags: {
+    ...opts.flags
+    /* redact */
+  }, attachedFiles: Array.isArray(opts.attachedFiles) ? opts.attachedFiles.length : 0 });
   const initial = [];
   const fallbackNotices = [];
   const withNotices = (base) => fallbackNotices.length > 0 ? [...fallbackNotices, ...base] : base;
   const explicitFilesRaw = parseExplicitFilenames(request);
   const explicitFiles = explicitFilesRaw.length > 0 ? await resolveExplicitPaths(opts.root, explicitFilesRaw, request) : [];
+  dbg("explicitFiles", { raw: explicitFilesRaw, resolved: explicitFiles });
   const explicitAbsMap = /* @__PURE__ */ Object.create(null);
   if (explicitFiles.length > 0) {
     const pathMod = await import('path');
@@ -56216,12 +56327,14 @@ async function orchestrate(request, opts) {
     explicitFiles,
     attachmentsCount: Array.isArray(opts.attachedFiles) ? opts.attachedFiles.length : 0
   });
+  dbg("intent", { isEditIntent });
   let editTargets = explicitFiles;
   if (isEditIntent && editTargets.length === 0) {
     try {
       const repoFiles = await getRepoFiles(opts.root);
       const llmTargets = await llmSelectEditTargets(opts.root, request, repoFiles);
       editTargets = llmTargets;
+      dbg("llmSelectEditTargets", { editTargets });
     } catch {
     }
   }
@@ -56233,6 +56346,7 @@ async function orchestrate(request, opts) {
       maxAttachments: opts.flags.maxAttachments || 50,
       allowDotfiles: !!opts.flags.allowDotfiles
     });
+    dbg("attachment.map", { mappedCount: mapRes.mapped.length, warnings: mapRes.warnings });
     mapRes.warnings.slice();
     for (const m2 of mapRes.mapped) {
       initial.push({
@@ -56244,7 +56358,7 @@ async function orchestrate(request, opts) {
       });
     }
   }
-  const onlyAttached = !!opts.flags.onlyAttached;
+  const onlyAttached = !!(opts.flags.onlyAttached && Array.isArray(opts.attachedFiles) && opts.attachedFiles.length > 0);
   if (!onlyAttached) {
     let codeOutput = "";
     if (process.env.MARIA_E2E_FAKE_CODE === "1") {
@@ -56264,10 +56378,37 @@ async function orchestrate(request, opts) {
               "[BEGIN file: path]\n<content>\n[END]",
               "Do not include any prose before/after; no menus/questions/suggestions; start immediately with ``` or [BEGIN file: ...]."
             ].join("\n");
+            let targetFilesAbs = [];
+            try {
+              const pathMod = await import('path');
+              const fromExplicit = Array.isArray(explicitFiles) && explicitFiles.length > 0 ? explicitFiles.map((rel) => explicitAbsMap[rel] || pathMod.join(opts.root, rel)) : [];
+              const fromEditTargets = Array.isArray(editTargets) && editTargets.length > 0 ? editTargets.map((rel) => pathMod.isAbsolute(rel) ? rel : pathMod.join(opts.root, rel)) : [];
+              const seen = /* @__PURE__ */ new Set();
+              for (const p of [...fromExplicit, ...fromEditTargets]) {
+                const norm = (p || "").replace(/\\/g, "/");
+                if (!norm) continue;
+                if (seen.has(norm)) continue;
+                seen.add(norm);
+                targetFilesAbs.push(norm);
+              }
+            } catch {
+            }
+            const targetDirsAbs = Array.from(new Set(targetFilesAbs.map((p) => p.split("/").slice(0, -1).join("/")).filter(Boolean)));
+            const targetFilesSection = targetFilesAbs.length > 0 ? ["// TARGET FILES (absolute):", ...targetFilesAbs.map((p) => `// - ${p}`)].join("\n") : "";
+            const targetDirsSection = targetDirsAbs.length > 0 ? ["// TARGET DIRECTORIES (absolute):", ...targetDirsAbs.map((p) => `// - ${p}`)].join("\n") : "";
             const requestPreamble = isEditIntent ? [
-              "// EDIT MODE: modify existing files, preserve unrelated content.",
-              "// Follow existing structure and only touch requested files.",
-              editContext ? "// Current file snapshots provided below." : ""
+              "// EDIT MODE RULES:",
+              "// 1) Read the entire target file(s) BEFORE making changes. Assume omitted lines must remain exactly as-is.",
+              "// 2) Preserve unrelated content and formatting (indentation, EOLs, imports order, license headers).",
+              "// 3) Do NOT rename, move, or delete files unless explicitly requested.",
+              "// 4) Apply the MINIMAL necessary change to achieve the request. Avoid broad refactors.",
+              "// 5) When returning a whole file, keep everything identical except for the exact lines you changed.",
+              "// 6) Do NOT introduce unrelated edits or code style churn.",
+              "// 7) Edit ONLY the files listed under TARGET FILES or inside TARGET DIRECTORIES unless explicitly instructed otherwise.",
+              "// 8) Do NOT create or scaffold new projects or files outside these targets (no package.json, no CRA/Vite scaffolds, etc.) unless such files already exist and are being modified.",
+              editContext ? "// Current file snapshots provided below." : "",
+              targetFilesSection,
+              targetDirsSection
             ].filter(Boolean).join("\n") : "";
             const enriched = `${FILE_FORMAT_INSTRUCTIONS}
 
@@ -56275,6 +56416,7 @@ ${requestPreamble}
 ${request}
 
 ${editContext}`;
+            dbg("executeCode.prompt.head", enriched.slice(0, 1400));
             const ctxAttachments = Array.isArray(opts.attachedFiles) && opts.attachedFiles.length > 0 ? opts.attachedFiles.map((f3) => ({
               name: f3.originalName,
               path: f3.pathHint,
@@ -56308,6 +56450,68 @@ ${editContext}`;
               } catch {
               }
             }
+            try {
+              const fs52 = await import('fs/promises');
+              const pathMod = await import('path');
+              const dirCandidates = Array.from(new Set(String(request).match(/[A-Za-z]:\\[^\s"']+|\.?\/?[^\s"']+[\/\\][^\s"']*/g) || []));
+              const maxFilesPerDir = 80;
+              for (const raw2 of dirCandidates) {
+                try {
+                  const normalized2 = raw2.replace(/^"|"$/g, "").replace(/^'|'$/g, "");
+                  const abs = pathMod.isAbsolute(normalized2) ? normalized2 : pathMod.join(opts.root, normalized2);
+                  const st = await fs52.stat(abs).catch(() => null);
+                  if (!st || !st.isDirectory()) continue;
+                  const collected = [];
+                  const walk2 = async (d) => {
+                    if (collected.length >= maxFilesPerDir) return;
+                    let entries = [];
+                    try {
+                      entries = await fs52.readdir(d, { withFileTypes: true });
+                    } catch {
+                      return;
+                    }
+                    for (const e2 of entries) {
+                      const name2 = e2.name;
+                      if (name2 === ".git" || name2 === "node_modules" || name2 === "dist" || name2 === "build" || name2 === ".maria") continue;
+                      const full = pathMod.join(d, name2);
+                      if (e2.isDirectory()) {
+                        await walk2(full);
+                        if (collected.length >= maxFilesPerDir) break;
+                        continue;
+                      }
+                      collected.push(full);
+                      if (collected.length >= maxFilesPerDir) break;
+                    }
+                  };
+                  await walk2(abs);
+                  for (const f3 of collected) {
+                    try {
+                      const key = f3.toLowerCase();
+                      if (attachedPathSet.has(key)) continue;
+                      const buf = await fs52.readFile(f3);
+                      const head2 = buf.subarray(0, Math.min(buf.length, 4096));
+                      let binaryLike = false;
+                      for (let i2 = 0; i2 < head2.length; i2++) {
+                        if (head2[i2] === 0) {
+                          binaryLike = true;
+                          break;
+                        }
+                      }
+                      if (binaryLike) continue;
+                      const sample = buf.subarray(0, Math.min(buf.length, 8192)).toString("utf8");
+                      const printable = sample.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F]/g, "");
+                      const ratio = sample.length === 0 ? 0 : printable.length / sample.length;
+                      if (ratio < 0.6 && sample.length > 0) continue;
+                      pathAttachments.push({ name: pathMod.basename(f3), path: f3, mime: "text/plain", data_base64: buf.toString("base64") });
+                      attachedPathSet.add(key);
+                    } catch {
+                    }
+                  }
+                } catch {
+                }
+              }
+            } catch {
+            }
             if (isEditIntent && Array.isArray(editTargets) && editTargets.length > 0) {
               try {
                 const fs52 = await import('fs/promises');
@@ -56362,9 +56566,34 @@ ${editContext}`;
                 hydratedCtx.push(...ctxAttachments);
               }
             }
-            const allAttachments = (hydratedCtx.length ? hydratedCtx : ctxAttachments).concat(pathAttachments);
+            const pathMod2 = await import('path');
+            const normalizeMime = (p, m2) => {
+              if (!p) return m2 || "text/plain";
+              const ext2 = pathMod2.extname(p).toLowerCase();
+              if (m2 && m2 !== "application/octet-stream") return m2;
+              if (ext2 === ".pdf") return "application/pdf";
+              if (ext2 === ".png") return "image/png";
+              if (ext2 === ".jpg" || ext2 === ".jpeg") return "image/jpeg";
+              if (ext2 === ".webp") return "image/webp";
+              if (ext2 === ".gif") return "image/gif";
+              if (ext2 === ".bmp") return "image/bmp";
+              if (ext2 === ".svg") return "image/svg+xml";
+              if (ext2 === ".tif" || ext2 === ".tiff") return "image/tiff";
+              if (ext2 === ".heic") return "image/heic";
+              if (ext2 === ".heif") return "image/heif";
+              return "text/plain";
+            };
+            const allAttachments = (hydratedCtx.length ? hydratedCtx : ctxAttachments).concat(pathAttachments).map((a) => ({
+              ...a,
+              mime: normalizeMime(a.path, a.mime)
+            }));
             const response = await executeCode(allAttachments.length > 0 ? { prompt: enriched, provider: "google", model: "gemini-2.5-flash", attachments: allAttachments } : enriched);
+            try {
+              dbg("executeCode.attachments.meta", { ctx: (hydratedCtx.length ? hydratedCtx : ctxAttachments).length, path: pathAttachments.length });
+            } catch {
+            }
             const raw = (response.output || response?.data?.content || "").trim();
+            dbg("executeCode.output.head", raw.slice(0, 1200));
             if (!raw) {
               return {
                 ok: false,
@@ -56402,6 +56631,7 @@ ${editContext}`;
       codeOutput = outcome.data?.output || "";
     }
     const blocks = extractBlocks(codeOutput);
+    dbg("extractBlocks.count", blocks.length);
     if (explicitFiles.length > 0 || isEditIntent && editTargets.length > 0) {
       const mapped = /* @__PURE__ */ new Set();
       const targets = explicitFiles.length > 0 ? explicitFiles : editTargets;
@@ -56439,23 +56669,49 @@ ${editContext}`;
     } else {
       try {
         const repoFiles = await getRepoFiles(opts.root);
-        const decisions = await llmMapBlocksBatch(opts.root, request, blocks, repoFiles);
+        let dirHints = [];
+        try {
+          const fs52 = await import('fs/promises');
+          const pathMod = await import('path');
+          const rawDirs = Array.from(new Set(String(request).match(/[A-Za-z]:\\[^\s"']+|\.?\/?[^\s"']+[\/\\][^\s"']*/g) || []));
+          for (const raw of rawDirs) {
+            try {
+              const normalized2 = raw.replace(/^"|"$/g, "").replace(/^'|'$/g, "");
+              const abs = pathMod.isAbsolute(normalized2) ? normalized2 : pathMod.join(opts.root, normalized2);
+              const st = await fs52.stat(abs).catch(() => null);
+              if (!st || !st.isDirectory()) continue;
+              const rel = pathMod.relative(opts.root, abs).replace(/\\/g, "/").replace(/^\/+/, "");
+              if (!rel || rel.startsWith("..")) continue;
+              dirHints.push(rel);
+            } catch {
+            }
+          }
+          if (dirHints.length === 0 && Array.isArray(editTargets) && editTargets.length > 0) {
+            dirHints = Array.from(new Set(editTargets.map((p) => (p || "").replace(/^\/+/, "").split("/").slice(0, -1).join("/")).filter(Boolean)));
+          }
+        } catch {
+        }
+        const decisions = await llmMapBlocksBatch(opts.root, request, blocks, repoFiles, { dirHints });
+        dbg("llmMapBlocksBatch.decisions", decisions);
         for (let i2 = 0; i2 < blocks.length; i2++) {
           const b = blocks[i2];
           const d = decisions[i2] || { action: "create", path: suggestName2(request, b.language, i2) };
-          if (d.action === "modify" && repoFiles.includes(d.path)) {
+          const hinted = b.filename && String(b.filename).trim() || extractFilenameHintFromComment(b.code);
+          const finalPath = hinted && hinted.trim() || d.path;
+          if (d.action === "modify" && repoFiles.includes(finalPath)) {
             const lang = languageFromExt(d.path.replace(/^.*(\.[a-z0-9]+)$/i, "$1"));
-            initial.push({ path: d.path, kind: "source", action: "modify", description: "Modify existing file", language: lang, preview: b.code });
+            initial.push({ path: finalPath, kind: "source", action: "modify", description: "Modify existing file", language: lang, preview: b.code, noNormalize: true });
           } else {
-            const pth = d.path || suggestName2(request, b.language, i2);
-            initial.push({ path: pth, kind: "source", action: "create", description: describe2(b.language, ""), language: b.language, preview: b.code });
+            const pth = finalPath && finalPath.trim() || d.path || suggestName2(request, b.language, i2);
+            initial.push({ path: pth, kind: "source", action: "create", description: describe2(b.language, ""), language: b.language, preview: b.code, noNormalize: true });
           }
         }
       } catch {
         for (let i2 = 0; i2 < blocks.length; i2++) {
           const b = blocks[i2];
-          const path65 = suggestName2(request, b.language, i2);
-          initial.push({ path: path65, kind: "source", action: "create", description: describe2(b.language, ""), language: b.language, preview: b.code });
+          const hinted = b.filename && String(b.filename).trim() || extractFilenameHintFromComment(b.code);
+          const path65 = hinted && hinted.trim() || suggestName2(request, b.language, i2);
+          initial.push({ path: path65, kind: "source", action: "create", description: describe2(b.language, ""), language: b.language, preview: b.code, noNormalize: true });
         }
       }
     }
@@ -56471,13 +56727,13 @@ ${editContext}`;
       }
     }
   }
-  if (explicitFiles.length > 0 && initial.filter((f3) => !!f3.preview).length === 0) {
+  if (!isEditIntent && explicitFiles.length > 0 && initial.filter((f3) => !!f3.preview).length === 0) {
     for (const f3 of explicitFiles) {
       initial.push(scaffoldForFilename(f3, explicitFiles));
     }
   }
   const normalized = await normalizePlans(
-    initial.map((p) => p.noNormalize ? p : p),
+    initial.map((p) => p.noNormalize ? { ...p } : p),
     { root: opts.root }
   );
   try {
@@ -56502,11 +56758,26 @@ ${editContext}`;
     }
   } catch {
   }
-  const validated = await validatePlan(normalized, { root: opts.root, profile, flags: { maxFiles: opts.flags.maxFiles, yes: opts.flags.yes, interactive: !!opts.flags.interactive, ...opts.flags } });
+  let filtered = normalized;
+  if (isEditIntent) {
+    const keepCreates = !!opts.flags.onlyAttached;
+    if (!keepCreates) {
+      filtered = normalized.map((f3) => f3.action === "create" ? { ...f3, action: "skip" } : f3);
+    }
+  }
+  const baseFlags = { ...opts.flags };
+  const effectiveFlags = {
+    ...baseFlags,
+    maxFiles: opts.flags.maxFiles,
+    interactive: !!opts.flags.interactive,
+    // Force yes when editing; if baseFlags.yes is already true, keep it true
+    yes: baseFlags?.yes === true || isEditIntent
+  };
+  const validated = await validatePlan(filtered, { root: opts.root, profile, flags: effectiveFlags });
   const hasAnyModify = validated.files.some((f3) => f3.action === "modify") || isEditIntent;
   const outputMode = !opts.flags.hideCode && hasAnyModify ? "diff" : resolveOutputMode(opts.flags.output, validated.files.length, !!opts.flags.hideCode);
   const skippedSetForLookup = new Set(validated.skipped || []);
-  const skippedPlans = normalized.filter((f3) => skippedSetForLookup.has(f3.path));
+  const skippedPlans = filtered.filter((f3) => skippedSetForLookup.has(f3.path));
   const remainingSkipped = (validated.skipped || []).filter((p) => !skippedPlans.some((sp) => sp.path === p)).map((p) => ({ path: p, kind: "source", action: "skip", description: "" }));
   const displayFiles = validated.files.concat(skippedPlans).concat(remainingSkipped);
   const summary = summarizePlan(displayFiles);
@@ -56699,6 +56970,21 @@ function extractBlocks(content) {
   if (blocks.length === 0 && looksLikeCode(content)) blocks.push({ language: detectLanguage(content), code: content.trim() });
   return blocks;
 }
+function extractFilenameHintFromComment(code) {
+  try {
+    const first = (code.split(/\r?\n/, 1)[0] || "").trim();
+    let m2 = first.match(/^\/\/\s*filename:\s*(.+)$/i);
+    if (m2?.[1]) return m2[1].trim();
+    m2 = first.match(/^#\s*filename:\s*(.+)$/i);
+    if (m2?.[1]) return m2[1].trim();
+    m2 = first.match(/^<!--\s*filename:\s*(.+?)\s*-->$/i);
+    if (m2?.[1]) return m2[1].trim();
+    m2 = first.match(/^\/\*\s*filename:\s*(.+?)\s*\*\/$/i);
+    if (m2?.[1]) return m2[1].trim();
+  } catch {
+  }
+  return void 0;
+}
 function looksLikeCode(s2) {
   return ["function ", "const ", "let ", "var ", "class ", "def ", "import ", "export "].some((k) => s2.includes(k));
 }
@@ -56856,48 +57142,100 @@ function parseExplicitFilenames(request) {
   return out;
 }
 async function detectEditIntentLLM(root, request, ctx2) {
+  let existingDirs = [];
+  let existingFiles = [];
+  let anyExistingPathMentioned = false;
   try {
+    const fs52 = await import('fs/promises');
+    const pathMod = await import('path');
+    const rawPaths = Array.from(new Set(String(request).match(/[A-Za-z]:\\[^\s"']+|\.?\/?[^\s"']+[\/\\][^\s"']*/g) || []));
+    existingDirs = [];
+    existingFiles = [];
+    for (const raw2 of rawPaths) {
+      try {
+        const normalized = raw2.replace(/^"|"$/g, "").replace(/^'|'$/g, "");
+        const abs = pathMod.isAbsolute(normalized) ? normalized : pathMod.join(root, normalized);
+        const st = await fs52.stat(abs).catch(() => null);
+        if (!st) continue;
+        anyExistingPathMentioned = true;
+        const rel = pathMod.relative(root, abs).replace(/\\/g, "/");
+        if (!rel || rel.startsWith("..")) continue;
+        if (st.isDirectory()) existingDirs.push(rel);
+        else if (st.isFile()) existingFiles.push(rel);
+      } catch {
+      }
+    }
     const repoFiles = await getRepoFiles(root);
-    const candidates = repoFiles;
+    let scope = [];
+    if (existingDirs.length > 0) {
+      const dirSet = existingDirs.map((d) => d.replace(/\\/g, "/").replace(/^\/+/, "").toLowerCase());
+      scope = repoFiles.filter((p) => dirSet.some((d) => p.toLowerCase().startsWith(d + "/")));
+    } else {
+      scope = repoFiles;
+    }
     const headSnippets = [];
-    for (const p of candidates) {
+    for (const p of scope) {
       const h2 = await readHeadTail(root, p, 5);
       headSnippets.push(`- ${p}
 ${h2.head}`);
     }
     const system = [
-      "Classify the user intent for the MARIA code orchestrator.",
-      "Decide strictly between EDIT_EXISTING (modify existing files) or CREATE_NEW (generate new project/files).",
-      "User is likely to have EDIT_EXITING intent when:",
-      "- the coding language is not specified",
-      "- it has a clear and/or relevant path of the file/directory exists",
-      "- it has attachments",
-      "- the wording implies modifying existing files (ex. fix, improve, update, change, patch, make it, clean up, etc.)",
-      'Return JSON: { "intent": "EDIT_EXISTING" | "CREATE_NEW" } only. No commentary.'
+      "You classify the intent for a code operation in an existing repository.",
+      "Choose strictly one: EDIT_EXISTING (modify existing files) or CREATE_NEW (generate a new project/files).",
+      "Decision rules (apply in order):",
+      "1) If the request references existing repo directory/file paths and does NOT explicitly say to create a new project/template/scaffold, prefer EDIT_EXISTING.",
+      "2) Wording like fix/improve/update/change/patch/make it work/enable X implies EDIT_EXISTING.",
+      "3) Wording like create/new project/scaffold/from scratch/template implies CREATE_NEW.",
+      "4) If attachments or explicit file paths are present, that increases likelihood of EDIT_EXISTING.",
+      'Return ONLY compact JSON: { "intent": "EDIT_EXISTING" | "CREATE_NEW" }.'
     ].join("\n");
+    const evidence = {
+      explicitFilesCount: (ctx2.explicitFiles || []).length,
+      attachmentsCount: ctx2.attachmentsCount || 0,
+      existingDirCount: existingDirs.length,
+      existingFileMentions: existingFiles.length,
+      existingDirs,
+      existingFiles
+    };
     const user = [
       `Request: ${request}`,
-      `ExplicitFiles: ${JSON.stringify(ctx2.explicitFiles || [])}`,
-      `AttachmentsCount: ${ctx2.attachmentsCount}`,
-      "Repo snapshot (paths with file heads):",
+      `Evidence: ${JSON.stringify(evidence)}`,
+      "Repo snapshot (trimmed):",
       headSnippets.join("\n\n")
     ].join("\n\n");
-    const spin1 = new ProcessAnimation();
-    spin1.start();
-    const resp = await executeChat([
-      { role: "system", content: system },
-      { role: "user", content: user }
-    ]);
+    if (existingDirs.length > 0 || existingFiles.length > 0 || ctx2.explicitFiles && ctx2.explicitFiles.length > 0 || ctx2.attachmentsCount > 0) {
+      return true;
+    }
+    let startedLocalSpinner = false;
+    let spin1 = null;
+    if (!ProcessAnimation.hasActive()) {
+      spin1 = new ProcessAnimation();
+      spin1.start();
+      startedLocalSpinner = true;
+    }
+    let resp;
     try {
-      spin1.stop();
-    } catch {
+      resp = await executeChat([
+        { role: "system", content: system },
+        { role: "user", content: user }
+      ], { provider: "google", model: "gemini-2.5-flash-lite" });
+    } finally {
+      if (startedLocalSpinner && spin1) {
+        try {
+          spin1.stop();
+        } catch {
+        }
+      }
     }
     const raw = (resp?.output || "").trim();
     const jsonText = extractJsonSafe(raw, "object") || raw;
     const parsed = JSON.parse(jsonText);
+    if (existingDirs.length > 0 || existingFiles.length > 0 || anyExistingPathMentioned || ctx2.explicitFiles && ctx2.explicitFiles.length > 0 || ctx2.attachmentsCount > 0) {
+      return true;
+    }
     return parsed?.intent === "EDIT_EXISTING";
   } catch {
-    return ctx2.explicitFiles && ctx2.explicitFiles.length > 0 || ctx2.attachmentsCount > 0;
+    return ctx2.explicitFiles && ctx2.explicitFiles.length > 0 || ctx2.attachmentsCount > 0 || existingDirs.length > 0 || existingFiles.length > 0 || anyExistingPathMentioned;
   }
 }
 function sanitizeFolderName(name2) {
@@ -57065,7 +57403,7 @@ async function resolveExplicitPaths(root, files, hintText) {
         const chat = await executeChat([
           { role: "system", content: system },
           { role: "user", content: user }
-        ]);
+        ], { provider: "google", model: "gemini-2.5-flash-lite" });
         const raw = (chat.output || "").trim();
         const pick = ranked.find((r2) => r2 === raw) || ranked.find((r2) => raw.includes(r2)) || ranked[0];
         return pick.replace(/^\/+/, "");
@@ -57240,7 +57578,16 @@ var init_code_command = __esm({
         }
       ];
       async execute(commandArgs, context2) {
+        const debug = (...args2) => {
+          if (process.env.MARIA_DEBUG === "1") {
+            try {
+              console.log("[DEBUG/code]", ...args2);
+            } catch {
+            }
+          }
+        };
         const request = await this.ensureLanguageDefaults(commandArgs.raw.join(" ").trim());
+        debug("request", request);
         if (!request) {
           return this.error("Please provide a code request \xB7 Example: /code create button component\nTip: Use --plan-only to safely review the plan, or --output detail to preview snippet heads.");
         }
@@ -57252,6 +57599,7 @@ var init_code_command = __esm({
             const explicitDry = commandArgs.raw.includes("--dry-run");
             const explicitOutput = commandArgs.raw.some((x2) => x2.startsWith("--output") || x2 === "--verbose" || x2 === "-v");
             const explicitPreview = commandArgs.raw.some((x2) => x2.startsWith("--preview-lines"));
+            const explicitOnlyAttached = commandArgs.raw.includes("--only-attached");
             const preSpin = new ProcessAnimation();
             preSpin.start();
             let inferred = {};
@@ -57263,6 +57611,8 @@ var init_code_command = __esm({
               } catch {
               }
             }
+            debug("inferCodeArgs.raw", rawText);
+            debug("inferCodeArgs.result", inferred);
             if (!explicitPlan && !explicitDry) {
               if (typeof inferred.planOnly === "boolean") opts.planOnly = inferred.planOnly;
               if (typeof inferred.dryRun === "boolean") opts.dryRun = inferred.dryRun;
@@ -57273,6 +57623,9 @@ var init_code_command = __esm({
             if (!explicitPreview && typeof inferred.previewLines === "number") {
               opts.previewLines = inferred.previewLines;
             }
+            if (!explicitOnlyAttached && typeof inferred.onlyAttached === "boolean") {
+              opts.onlyAttached = inferred.onlyAttached;
+            }
           } catch {
           }
           if (opts.planOnly) {
@@ -57287,13 +57640,27 @@ var init_code_command = __esm({
           const root = opts.root || process.cwd();
           const { orchestrate: orchestrate2 } = await Promise.resolve().then(() => (init_Orchestrator(), Orchestrator_exports));
           const attachments = await this.collectAttachedFiles(context2).catch(() => []);
+          try {
+            if (process.env.MARIA_DEBUG === "1") {
+              const attView = attachments.map((a) => ({ name: a.originalName, size: a.size, mime: a.mime, pathHint: a.pathHint })).slice(0, 50);
+              console.log("[DEBUG/code] collected.attachments", { count: attachments.length, attachments: attView });
+            }
+          } catch {
+          }
           const abort = new AbortController();
           const onSigint = () => abort.abort();
           process.once("SIGINT", onSigint);
-          const spinner = new ProcessAnimation();
-          spinner.start();
+          let startedLocalSpinner = false;
+          let spinner = null;
+          if (!ProcessAnimation.hasActive()) {
+            spinner = new ProcessAnimation();
+            spinner.start();
+            startedLocalSpinner = true;
+          }
           try {
-            const res = await orchestrate2(request, { root, flags: { planOnly: opts.planOnly, apply: opts.apply, dryRun: opts.dryRun, interactive: opts.interactive, yes: opts.yes, maxFiles: opts.maxFiles, output: opts.output, hideCode: opts.noCode, previewLines: this.normalizePreviewLines(opts.previewLines), verbose: opts.verbose, onlyAttached: opts.onlyAttached, attachMode: opts.attachMode, maxAttachments: opts.maxAttachments, diffLines: opts.diffLines, diffBytes: opts.diffBytes, diffHunks: opts.diffHunks, diffGlobalMaxFiles: opts.diffGlobalMaxFiles, diffGlobalMaxBytes: opts.diffGlobalMaxBytes, allowDotfiles: opts.allowDotfiles }, abortSignal: abort.signal, attachedFiles: attachments });
+            const effectiveOnlyAttached = opts.onlyAttached && attachments.length > 0;
+            const res = await orchestrate2(request, { root, flags: { planOnly: opts.planOnly, apply: opts.apply, dryRun: opts.dryRun, interactive: opts.interactive, yes: opts.yes, maxFiles: opts.maxFiles, output: opts.output, hideCode: opts.noCode, previewLines: this.normalizePreviewLines(opts.previewLines), verbose: opts.verbose, onlyAttached: effectiveOnlyAttached, attachMode: opts.attachMode, maxAttachments: opts.maxAttachments, diffLines: opts.diffLines, diffBytes: opts.diffBytes, diffHunks: opts.diffHunks, diffGlobalMaxFiles: opts.diffGlobalMaxFiles, diffGlobalMaxBytes: opts.diffGlobalMaxBytes, allowDotfiles: opts.allowDotfiles }, abortSignal: abort.signal, attachedFiles: attachments });
+            debug("orchestrate.summaryLines.head", Array.isArray(res?.summaryLines) ? res.summaryLines.slice(0, 10) : []);
             if (opts.planOnly) {
               const fs52 = await import('fs/promises');
               const path65 = await import('path');
@@ -57346,9 +57713,11 @@ var init_code_command = __esm({
             const out = Array.isArray(res?.summaryLines) ? res.summaryLines.join("\n") : "";
             return this.success(out);
           } finally {
-            try {
-              spinner.stop();
-            } catch {
+            if (startedLocalSpinner && spinner) {
+              try {
+                spinner.stop();
+              } catch {
+              }
             }
             process.removeListener("SIGINT", onSigint);
           }
@@ -57471,12 +57840,6 @@ ${pretty}`);
             if (llmLang) {
               const hint2 = (() => {
                 const l = llmLang.toLowerCase();
-                if (l === "tsx") return "TypeScript (React/TSX)";
-                if (l === "jsx") return "JavaScript (React/JSX)";
-                if (l === "typescript") return "TypeScript";
-                if (l === "javascript") return "JavaScript";
-                if (l === "html") return "HTML";
-                if (l === "css") return "CSS";
                 return llmLang;
               })();
               return raw + ` (Use ${hint2})`;
@@ -57489,7 +57852,7 @@ ${pretty}`);
           preSpin.start();
           const system = [
             "You analyze a user's code-generation request.",
-            "Decide if the user explicitly specified a programming language or framework/tooling (e.g., TypeScript, Python, Rust, Java, React, Vue, Node, etc.).",
+            "Decide if the user explicitly specified a programming language or framework/tooling.",
             'Return ONLY compact JSON with shape {"explicitLanguage": boolean, "language"?: string}.',
             "Do not add any commentary."
           ].join("\n");
@@ -57498,7 +57861,7 @@ ${pretty}`);
             method: "POST",
             body: {
               provider: "google",
-              model: "gemini-2.5-flash",
+              model: "gemini-2.5-flash-lite",
               taskType: "chat",
               prompt: `${system}
 
@@ -57543,6 +57906,14 @@ ${user}`
           if (parsed && parsed.explicitLanguage) return raw;
         } catch {
         }
+        try {
+          const pathMod = await import('path');
+          const hasPathToken = /[A-Za-z]:\\[^\s"']+|\.?\/?[^\s"']+[\/\\][^\s"']*/.test(raw);
+          if (hasPathToken) {
+            return raw;
+          }
+        } catch {
+        }
         const hint = " (Use TypeScript and React; prefer functional components and node)";
         return raw + hint;
       }
@@ -57552,9 +57923,7 @@ ${user}`
           const system = [
             "You are a programming language classifier.",
             "Given multiple short code excerpts, determine the dominant language across them.",
-            "Respond with ONLY a single token language name from this set:",
-            "[typescript, tsx, javascript, jsx, python, java, go, rust, php, cpp, c, swift, kotlin, ruby, csharp, html, css, scss, json, yaml, markdown].",
-            "If unsure between tsx and jsx, choose tsx if TypeScript types appear, else jsx."
+            "Respond with ONLY language name(s)"
           ].join("\n");
           const joined = samples.slice(0, 20).map((s2, i2) => `// sample ${i2 + 1}
 ${s2}`).join("\n\n");
@@ -57563,7 +57932,7 @@ ${s2}`).join("\n\n");
             method: "POST",
             body: {
               provider: "google",
-              model: "gemini-2.5-flash",
+              model: "gemini-2.5-flash-lite",
               taskType: "chat",
               prompt: `${system}
 
@@ -57869,64 +58238,6 @@ ${joined}`
           return false;
         }
       }
-      /**
-       * Extract code blocks from AI response
-       */
-      extractCodeBlocks(content) {
-        const blocks = [];
-        const codeBlockRegex = /```(\w*)\n([\s\S]*?)```/g;
-        let match2;
-        while ((match2 = codeBlockRegex.exec(content)) !== null) {
-          blocks.push({
-            language: match2[1] || "javascript",
-            code: match2[2].trim()
-          });
-        }
-        if (blocks.length === 0 && this.looksLikeCode(content)) {
-          blocks.push({
-            code: content.trim(),
-            language: this.detectLanguage(content)
-          });
-        }
-        return blocks;
-      }
-      /**
-       * Check if content looks like code
-       */
-      looksLikeCode(content) {
-        const codeIndicators = [
-          "function ",
-          "const ",
-          "let ",
-          "var ",
-          "class ",
-          "def ",
-          "import ",
-          "export ",
-          "{",
-          "}",
-          ";",
-          "//",
-          "/*"
-        ];
-        return codeIndicators.some((indicator) => content.includes(indicator));
-      }
-      /**
-       * Detect programming language from content
-       */
-      detectLanguage(code) {
-        const hasReact = /(^|\s)from\s+['"]react['"]|^\s*import\s+React/m.test(code);
-        const hasJSX = /<([A-Za-z][\w:-]*)(\s|>|\/)>?/m.test(code);
-        const hasTS = /(\binterface\s+\w+\b|\btype\s+\w+\s*=|:\s*[A-Za-z_][\w<>\[\]| &?:]*)/m.test(code) || /React\.FC\s*</m.test(code);
-        if (hasReact || hasJSX) return hasTS ? "tsx" : "jsx";
-        if (code.includes("interface ") || code.includes(": string")) return "typescript";
-        if (code.includes("def ") || code.includes("print(")) return "python";
-        if (code.includes("func ") || code.includes("package main")) return "go";
-        if (code.includes("fn ") || code.includes("let mut")) return "rust";
-        if (code.includes("<?php")) return "php";
-        if (code.includes("#include")) return "cpp";
-        return "javascript";
-      }
       /**
        * Save code block to file
        */
@@ -63724,11 +64035,10 @@ var init_clients_safe = __esm({
   }
 });
 function createSpinner(text) {
-  let frame = 0;
   let active = false;
-  let timer;
-  const render = () => {
-    const f3 = SPINNER_FRAMES[frame = (frame + 1) % SPINNER_FRAMES.length];
+  let frame = 0;
+  const renderOnce = () => {
+    const f3 = SPINNER_FRAMES[frame % SPINNER_FRAMES.length];
     process5__namespace.default.stdout.write(`\r ${chalk14__default.default.cyan(f3)} ${text}`);
   };
   return {
@@ -63738,13 +64048,11 @@ function createSpinner(text) {
     start() {
       if (active) return;
       active = true;
-      render();
-      timer = setInterval(render, 80);
+      renderOnce();
     },
     stop(symbol = "\u2714") {
       if (!active) return;
       active = false;
-      if (timer) clearInterval(timer);
       const finalSymbol = symbol === "\u2714" ? chalk14__default.default.green(symbol) : symbol === "\u26A0" ? chalk14__default.default.yellow(symbol) : symbol === "\u2716" ? chalk14__default.default.red(symbol) : symbol;
       process5__namespace.default.stdout.write(`\r ${finalSymbol} ${text}
 `);