@bonginkan/maria 4.3.38 → 4.3.39

package/dist/bin/maria.cjs

@@ -235,13 +235,13 @@ function getPackageJson() {
       )
     ];
     let packageJsonPath = null;
-    for (const path64 of possiblePaths) {
-      if (fs21.existsSync(path64)) {
+    for (const path65 of possiblePaths) {
+      if (fs21.existsSync(path65)) {
         try {
-          const content = fs21.readFileSync(path64, "utf-8");
+          const content = fs21.readFileSync(path65, "utf-8");
           const parsed = JSON.parse(content);
           if (parsed.name === "@bonginkan/maria") {
-            packageJsonPath = path64;
+            packageJsonPath = path65;
             break;
           }
         } catch {
@@ -5314,22 +5314,22 @@ var init_from = __esm({
     init_file();
     init_fetch_blob();
     ({ stat } = fs21.promises);
-    blobFromSync = (path64, type) => fromBlob(fs21.statSync(path64), path64, type);
-    blobFrom = (path64, type) => stat(path64).then((stat13) => fromBlob(stat13, path64, type));
-    fileFrom = (path64, type) => stat(path64).then((stat13) => fromFile(stat13, path64, type));
-    fileFromSync = (path64, type) => fromFile(fs21.statSync(path64), path64, type);
-    fromBlob = (stat13, path64, type = "") => new fetch_blob_default([new BlobDataItem({
-      path: path64,
+    blobFromSync = (path65, type) => fromBlob(fs21.statSync(path65), path65, type);
+    blobFrom = (path65, type) => stat(path65).then((stat13) => fromBlob(stat13, path65, type));
+    fileFrom = (path65, type) => stat(path65).then((stat13) => fromFile(stat13, path65, type));
+    fileFromSync = (path65, type) => fromFile(fs21.statSync(path65), path65, type);
+    fromBlob = (stat13, path65, type = "") => new fetch_blob_default([new BlobDataItem({
+      path: path65,
       size: stat13.size,
       lastModified: stat13.mtimeMs,
       start: 0
     })], { type });
-    fromFile = (stat13, path64, type = "") => new file_default([new BlobDataItem({
-      path: path64,
+    fromFile = (stat13, path65, type = "") => new file_default([new BlobDataItem({
+      path: path65,
       size: stat13.size,
       lastModified: stat13.mtimeMs,
       start: 0
-    })], path11.basename(path64), { type, lastModified: stat13.mtimeMs });
+    })], path11.basename(path65), { type, lastModified: stat13.mtimeMs });
     BlobDataItem = class _BlobDataItem {
       #path;
       #start;
@@ -9563,12 +9563,12 @@ ${this.toYamlLike(value, indent + 1)}`;
       }
       static async loadFromFile(configPath) {
         const { importNodeBuiltin: importNodeBuiltin2 } = await Promise.resolve().then(() => (init_import_helper(), import_helper_exports));
-        const fs51 = await importNodeBuiltin2("fs");
+        const fs52 = await importNodeBuiltin2("fs");
         const _path = await importNodeBuiltin2("_path");
         const os23 = await importNodeBuiltin2("os");
         const targetPath = configPath || _path.join(os23.homedir(), ".maria", "config.json");
         try {
-          const data = await fs51.promises.readFile(targetPath, "utf-8");
+          const data = await fs52.promises.readFile(targetPath, "utf-8");
           return JSON.parse(data);
         } catch (innerError) {
           if (innerError?.code === "ENOENT") {
@@ -9582,25 +9582,25 @@ ${this.toYamlLike(value, indent + 1)}`;
       }
       async save(configPath, options) {
         const { importNodeBuiltin: importNodeBuiltin2 } = await Promise.resolve().then(() => (init_import_helper(), import_helper_exports));
-        const fs51 = await importNodeBuiltin2("fs");
+        const fs52 = await importNodeBuiltin2("fs");
         const _path = await importNodeBuiltin2("_path");
         const os23 = await importNodeBuiltin2("os");
         const targetPath = configPath || _path.join(os23.homedir(), ".maria", "config.json");
         try {
           if (options?.backup) {
             try {
-              await fs51.promises.access(targetPath);
+              await fs52.promises.access(targetPath);
               const backupPath = `${targetPath}.backup.${Date.now()}`;
-              await fs51.promises.copyFile(targetPath, backupPath);
+              await fs52.promises.copyFile(targetPath, backupPath);
             } catch {
             }
           }
-          await fs51.promises.mkdir(_path.dirname(targetPath), { recursive: true });
+          await fs52.promises.mkdir(_path.dirname(targetPath), { recursive: true });
           const dataToSave = this.getAll({
             maskSensitive: options?.maskSensitive ?? true,
             includeSourceMap: options?.includeSourceMap ?? false
           });
-          await fs51.promises.writeFile(
+          await fs52.promises.writeFile(
             targetPath,
             JSON.stringify(dataToSave, null, 2),
             { mode: 384 }
@@ -9644,12 +9644,12 @@ ${this.toYamlLike(value, indent + 1)}`;
         }
         if (outputPath) {
           const { importNodeBuiltin: importNodeBuiltin2 } = await Promise.resolve().then(() => (init_import_helper(), import_helper_exports));
-          const fs51 = await importNodeBuiltin2("fs");
+          const fs52 = await importNodeBuiltin2("fs");
           const _path = await importNodeBuiltin2(
             "_path"
           );
-          await fs51.promises.mkdir(_path.dirname(outputPath), { recursive: true });
-          await fs51.promises.writeFile(outputPath, content, "utf-8");
+          await fs52.promises.mkdir(_path.dirname(outputPath), { recursive: true });
+          await fs52.promises.writeFile(outputPath, content, "utf-8");
           console.log(`\u2705 Configuration exported to ${outputPath}`);
         }
         return content;
@@ -9958,13 +9958,13 @@ async function loadEnvironmentConfig() {
   }
   try {
     const { importNodeBuiltin: importNodeBuiltin2, safeDynamicImport: safeDynamicImport2 } = await Promise.resolve().then(() => (init_import_helper(), import_helper_exports));
-    const fs51 = await safeDynamicImport2("fs-extra").catch(
+    const fs52 = await safeDynamicImport2("fs-extra").catch(
       () => importNodeBuiltin2("fs")
     );
     const _path = await importNodeBuiltin2("_path");
     const _envPath = _path.join(process.cwd(), ".env.local");
-    if (await fs51.pathExists(_envPath)) {
-      const _envContent = await fs51.readFile(_envPath, "utf-8");
+    if (await fs52.pathExists(_envPath)) {
+      const _envContent = await fs52.readFile(_envPath, "utf-8");
       console.log("Loading environment from:", _envPath);
       environmentLoaded = true;
       const _lines = _envContent.split("\n");
@@ -19536,8 +19536,8 @@ var init_ConfigService = __esm({
       /**
        * ネストされた設定値の取得
        */
-      getNestedValue(path64) {
-        const keys = path64.split(".");
+      getNestedValue(path65) {
+        const keys = path65.split(".");
         let value = this._config;
         for (const key of keys) {
           if (value && typeof value === "object" && key in value) {
@@ -19567,8 +19567,8 @@ var init_ConfigService = __esm({
       /**
        * ネストされた設定値の更新
        */
-      async setNestedValue(path64, value) {
-        const keys = path64.split(".");
+      async setNestedValue(path65, value) {
+        const keys = path65.split(".");
         const lastKey = keys.pop();
         let target = this._config;
         for (const key of keys) {
@@ -19581,7 +19581,7 @@ var init_ConfigService = __esm({
         target[lastKey] = value;
         this.validateConfig();
         this.emitChange({
-          path: path64,
+          path: path65,
           oldValue,
           newValue: value,
           timestamp: /* @__PURE__ */ new Date()
@@ -19626,8 +19626,8 @@ var init_ConfigService = __esm({
       setupAutoSave() {
         process.on("exit", () => {
           if (this._isDirty) {
-            const fs51 = __require("fs");
-            fs51.writeFileSync(
+            const fs52 = __require("fs");
+            fs52.writeFileSync(
               this._userConfigPath,
               JSON.stringify(this._config, null, 2),
               "utf-8"
@@ -19638,13 +19638,13 @@ var init_ConfigService = __esm({
       /**
        * 変更リスナーの登録
        */
-      onChange(path64, listener) {
-        if (!this._listeners.has(path64)) {
-          this._listeners.set(path64, []);
+      onChange(path65, listener) {
+        if (!this._listeners.has(path65)) {
+          this._listeners.set(path65, []);
         }
-        this._listeners.get(path64).push(listener);
+        this._listeners.get(path65).push(listener);
         return () => {
-          const listeners = this._listeners.get(path64);
+          const listeners = this._listeners.get(path65);
           if (listeners) {
             const index = listeners.indexOf(listener);
             if (index !== -1) {
@@ -20133,7 +20133,7 @@ var init_ValidationService = __esm({
         );
         this._schemas.set(
           "filePath",
-          zod.z.string().min(1).max(this._config.maxFilePathLength).refine((path64) => !this.containsPathTraversal(path64), {
+          zod.z.string().min(1).max(this._config.maxFilePathLength).refine((path65) => !this.containsPathTraversal(path65), {
             message: "Path traversal detected"
           })
         );
@@ -20272,11 +20272,11 @@ var init_ValidationService = __esm({
       /**
        * ファイルパス検証
        */
-      validateFilePath(path64) {
+      validateFilePath(path65) {
         try {
           const schema = this._schemas.get("filePath");
-          const result = schema.parse(path64);
-          if (this.isSystemPath(path64)) {
+          const result = schema.parse(path65);
+          if (this.isSystemPath(path65)) {
             return {
               valid: false,
               errors: [
@@ -20422,8 +20422,8 @@ var init_ValidationService = __esm({
       /**
        * パストラバーサルの検出
        */
-      containsPathTraversal(path64) {
-        return /\.\.[/\\]/.test(path64) || path64.includes("..\\") || path64.includes("../");
+      containsPathTraversal(path65) {
+        return /\.\.[/\\]/.test(path65) || path65.includes("..\\") || path65.includes("../");
       }
       /**
        * 危険なコマンドの判定
@@ -20450,7 +20450,7 @@ var init_ValidationService = __esm({
       /**
        * システムパスの判定
        */
-      isSystemPath(path64) {
+      isSystemPath(path65) {
         const systemPaths = [
           "/etc",
           "/sys",
@@ -20464,7 +20464,7 @@ var init_ValidationService = __esm({
           "/sbin"
         ];
         return systemPaths.some(
-          (sysPath) => path64.toLowerCase().startsWith(sysPath.toLowerCase())
+          (sysPath) => path65.toLowerCase().startsWith(sysPath.toLowerCase())
         );
       }
       /**
@@ -25440,10 +25440,10 @@ Run /doctor --fix to automatically fix ${fixableCount} issue(s)`
         const finalize = async (text, data) => {
           if (outputPath) {
             try {
-              const fs51 = await import('fs/promises');
-              const path64 = await import('path');
-              const abs = path64.resolve(outputPath);
-              await fs51.writeFile(abs, text, "utf-8");
+              const fs52 = await import('fs/promises');
+              const path65 = await import('path');
+              const abs = path65.resolve(outputPath);
+              await fs52.writeFile(abs, text, "utf-8");
               const msg = `Saved doctor report to ${abs}`;
               return { ok: true, message: msg, data: { path: abs, bytes: Buffer.byteLength(text, "utf-8") } };
             } catch (e2) {
@@ -25533,10 +25533,10 @@ Run /doctor --fix to automatically fix ${fixableCount} issue(s)`
         const finalize = async (text, data) => {
           if (outputPath) {
             try {
-              const fs51 = await import('fs/promises');
-              const path64 = await import('path');
-              const abs = path64.resolve(outputPath);
-              await fs51.writeFile(abs, text, "utf-8");
+              const fs52 = await import('fs/promises');
+              const path65 = await import('path');
+              const abs = path65.resolve(outputPath);
+              await fs52.writeFile(abs, text, "utf-8");
               const msg = `Saved metrics to ${abs}`;
               return { ok: true, message: msg, data: { path: abs, bytes: Buffer.byteLength(text, "utf-8") } };
             } catch (e2) {
@@ -25925,15 +25925,15 @@ var init_SessionOrchestrator = __esm({
       /**
        * 設定の取得
        */
-      getConfig(path64) {
-        return this._configService?.getNestedValue(path64);
+      getConfig(path65) {
+        return this._configService?.getNestedValue(path65);
       }
       /**
        * 設定の更新
        */
-      async setConfig(path64, value) {
+      async setConfig(path65, value) {
         if (this._configService) {
-          await this._configService.setNestedValue(path64, value);
+          await this._configService.setNestedValue(path65, value);
         }
       }
       /**
@@ -26051,11 +26051,11 @@ var init_interactive_session = __esm({
       getStats() {
         return this.orchestrator.getSessionStats();
       }
-      getConfig(path64) {
-        return this.orchestrator.getConfig(path64);
+      getConfig(path65) {
+        return this.orchestrator.getConfig(path65);
       }
-      async setConfig(path64, value) {
-        await this.orchestrator.setConfig(path64, value);
+      async setConfig(path65, value) {
+        await this.orchestrator.setConfig(path65, value);
       }
     };
   }
@@ -26066,8 +26066,8 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "@bonginkan/maria",
-      version: "4.3.38",
-      description: "\u{1F680} MARIA v4.3.38 - 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.39",
+      description: "\u{1F680} MARIA v4.3.39 - 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",
@@ -28104,7 +28104,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.38"}`
+              "User-Agent": `maria-cli/${process.env.CLI_VERSION || "4.3.39"}`
             }
           });
           if (response.status === 401) {
@@ -28745,9 +28745,9 @@ function clientThrottle(endpoint) {
   }
   rateLimitMap.set(endpoint, now2);
 }
-async function callApi(path64, init3 = {}) {
+async function callApi(path65, init3 = {}) {
   const apiBase = process.env.MARIA_API_BASE || "https://api.maria-code.ai";
-  const fullUrl = `${apiBase}${path64}`;
+  const fullUrl = `${apiBase}${path65}`;
   let tokens2 = await authManager.getValidTokens();
   if (!tokens2) {
     console.log(chalk14__default.default.red(ERR.AUTH_REQUIRED.msg));
@@ -28758,7 +28758,7 @@ async function callApi(path64, init3 = {}) {
     "Authorization": `Bearer ${token}`,
     "X-Device-Id": getDeviceId(),
     "X-Session-Id": getSessionId() || "",
-    "User-Agent": `maria-cli/${process.env.CLI_VERSION || "4.3.38"}`,
+    "User-Agent": `maria-cli/${process.env.CLI_VERSION || "4.3.39"}`,
     "Content-Type": init3.headers?.["Content-Type"] || "application/json"
   });
   const doFetch = async (token) => {
@@ -28816,8 +28816,8 @@ async function callApi(path64, init3 = {}) {
   }
   return response;
 }
-async function callApiJson(path64, init3 = {}) {
-  const response = await callApi(path64, init3);
+async function callApiJson(path65, init3 = {}) {
+  const response = await callApi(path65, init3);
   if (!response.ok) {
     const error2 = await response.json().catch(() => ({
       message: `API error: ${response.status} ${response.statusText}`
@@ -28826,8 +28826,8 @@ async function callApiJson(path64, init3 = {}) {
   }
   return response.json();
 }
-async function* streamApi(path64, init3 = {}) {
-  const response = await callApi(path64, {
+async function* streamApi(path65, init3 = {}) {
+  const response = await callApi(path65, {
     ...init3,
     headers: {
       ...init3.headers,
@@ -28853,13 +28853,13 @@ async function* streamApi(path64, init3 = {}) {
     reader.releaseLock();
   }
 }
-async function uploadFile(path64, file, metadata5 = {}) {
+async function uploadFile(path65, file, metadata5 = {}) {
   const formData = new FormData();
   formData.append("file", new Blob([file]));
   Object.entries(metadata5).forEach(([key, value]) => {
     formData.append(key, String(value));
   });
-  return callApiJson(path64, {
+  return callApiJson(path65, {
     method: "POST",
     body: formData,
     headers: {
@@ -29175,7 +29175,7 @@ async function mapInputToTopLevelCommand(input3) {
   const system = [
     "You are a router for the MARIA CLI.",
     "Decide the best command for a single user input.",
-    "Allowed commands: /help, /image, /code, /video, /whoami, /login, /logout, /evaluate, /research, chat.",
+    "Allowed commands: /help, /image, /code, /video, /whoami, /login, /logout, /evaluate, /research, /novel, chat.",
     "Note that /image and /video are for generating them. If a path of a file is provided, you should double think why it's referenced (it may be for coding or chatting or other commands, regarding on the context).",
     'Return JSON only with keys: { "command": string, "args"?: string[], "confidence": number }.',
     "Select chat when the input is a general question or conversation rather than a specific slash command.",
@@ -29203,7 +29203,7 @@ ${input3}`,
   }
   if (!parsed || typeof parsed.command !== "string") return null;
   const cmd = parsed.command;
-  if (!["/help", "/image", "/code", "/video", "/whoami", "/login", "/logout", "/evaluate", "/research", "chat"].includes(cmd)) return null;
+  if (!["/help", "/image", "/code", "/video", "/whoami", "/login", "/logout", "/evaluate", "/research", "/novel", "chat"].includes(cmd)) return null;
   const out = { command: cmd };
   if (Array.isArray(parsed.args)) {
     out.args = parsed.args.filter((a) => typeof a === "string" && a.trim()).map((s2) => s2.trim());
@@ -33819,12 +33819,12 @@ var init_esm4 = __esm({
       /**
        * Get the Path object referenced by the string path, resolved from this Path
        */
-      resolve(path64) {
-        if (!path64) {
+      resolve(path65) {
+        if (!path65) {
           return this;
         }
-        const rootPath = this.getRootString(path64);
-        const dir = path64.substring(rootPath.length);
+        const rootPath = this.getRootString(path65);
+        const dir = path65.substring(rootPath.length);
         const dirParts = dir.split(this.splitSep);
         const result = rootPath ? this.getRoot(rootPath).#resolveParts(dirParts) : this.#resolveParts(dirParts);
         return result;
@@ -34576,8 +34576,8 @@ var init_esm4 = __esm({
       /**
        * @internal
        */
-      getRootString(path64) {
-        return path11.win32.parse(path64).root;
+      getRootString(path65) {
+        return path11.win32.parse(path65).root;
       }
       /**
        * @internal
@@ -34623,8 +34623,8 @@ var init_esm4 = __esm({
       /**
        * @internal
        */
-      getRootString(path64) {
-        return path64.startsWith("/") ? "/" : "";
+      getRootString(path65) {
+        return path65.startsWith("/") ? "/" : "";
       }
       /**
        * @internal
@@ -34673,8 +34673,8 @@ var init_esm4 = __esm({
        *
        * @internal
        */
-      constructor(cwd2 = process.cwd(), pathImpl, sep4, { nocase, childrenCacheSize = 16 * 1024, fs: fs51 = defaultFS } = {}) {
-        this.#fs = fsFromOption(fs51);
+      constructor(cwd2 = process.cwd(), pathImpl, sep4, { nocase, childrenCacheSize = 16 * 1024, fs: fs52 = defaultFS } = {}) {
+        this.#fs = fsFromOption(fs52);
         if (cwd2 instanceof URL || cwd2.startsWith("file://")) {
           cwd2 = url.fileURLToPath(cwd2);
         }
@@ -34713,11 +34713,11 @@ var init_esm4 = __esm({
       /**
        * Get the depth of a provided path, string, or the cwd
        */
-      depth(path64 = this.cwd) {
-        if (typeof path64 === "string") {
-          path64 = this.cwd.resolve(path64);
+      depth(path65 = this.cwd) {
+        if (typeof path65 === "string") {
+          path65 = this.cwd.resolve(path65);
         }
-        return path64.depth();
+        return path65.depth();
       }
       /**
        * Return the cache of child entries.  Exposed so subclasses can create
@@ -35204,9 +35204,9 @@ var init_esm4 = __esm({
         process11();
         return results;
       }
-      chdir(path64 = this.cwd) {
+      chdir(path65 = this.cwd) {
         const oldCwd = this.cwd;
-        this.cwd = typeof path64 === "string" ? this.cwd.resolve(path64) : path64;
+        this.cwd = typeof path65 === "string" ? this.cwd.resolve(path65) : path65;
         this.cwd[setAsCwd](oldCwd);
       }
     };
@@ -35232,8 +35232,8 @@ var init_esm4 = __esm({
       /**
        * @internal
        */
-      newRoot(fs51) {
-        return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs51 });
+      newRoot(fs52) {
+        return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs52 });
       }
       /**
        * Return true if the provided path string is an absolute path
@@ -35261,8 +35261,8 @@ var init_esm4 = __esm({
       /**
        * @internal
        */
-      newRoot(fs51) {
-        return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs51 });
+      newRoot(fs52) {
+        return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs52 });
       }
       /**
        * Return true if the provided path string is an absolute path
@@ -35581,8 +35581,8 @@ var init_processor = __esm({
       }
       // match, absolute, ifdir
       entries() {
-        return [...this.store.entries()].map(([path64, n]) => [
-          path64,
+        return [...this.store.entries()].map(([path65, n]) => [
+          path65,
           !!(n & 2),
           !!(n & 1)
         ]);
@@ -35795,9 +35795,9 @@ var init_walker = __esm({
       signal;
       maxDepth;
       includeChildMatches;
-      constructor(patterns, path64, opts) {
+      constructor(patterns, path65, opts) {
         this.patterns = patterns;
-        this.path = path64;
+        this.path = path65;
         this.opts = opts;
         this.#sep = !opts.posix && opts.platform === "win32" ? "\\" : "/";
         this.includeChildMatches = opts.includeChildMatches !== false;
@@ -35816,11 +35816,11 @@ var init_walker = __esm({
           });
         }
       }
-      #ignored(path64) {
-        return this.seen.has(path64) || !!this.#ignore?.ignored?.(path64);
+      #ignored(path65) {
+        return this.seen.has(path65) || !!this.#ignore?.ignored?.(path65);
       }
-      #childrenIgnored(path64) {
-        return !!this.#ignore?.childrenIgnored?.(path64);
+      #childrenIgnored(path65) {
+        return !!this.#ignore?.childrenIgnored?.(path65);
       }
       // backpressure mechanism
       pause() {
@@ -36035,8 +36035,8 @@ var init_walker = __esm({
     };
     GlobWalker = class extends GlobUtil {
       matches = /* @__PURE__ */ new Set();
-      constructor(patterns, path64, opts) {
-        super(patterns, path64, opts);
+      constructor(patterns, path65, opts) {
+        super(patterns, path65, opts);
       }
       matchEmit(e2) {
         this.matches.add(e2);
@@ -36073,8 +36073,8 @@ var init_walker = __esm({
     };
     GlobStream = class extends GlobUtil {
       results;
-      constructor(patterns, path64, opts) {
-        super(patterns, path64, opts);
+      constructor(patterns, path65, opts) {
+        super(patterns, path65, opts);
         this.results = new Minipass({
           signal: this.signal,
           objectMode: true
@@ -41909,9 +41909,9 @@ var init_SafetyGuard = __esm({
           }
         }
         if (action.args.paths && Array.isArray(action.args.paths)) {
-          for (const path64 of action.args.paths) {
-            if (!this.validatePath(path64)) {
-              violations.push(`Invalid path: ${path64}`);
+          for (const path65 of action.args.paths) {
+            if (!this.validatePath(path65)) {
+              violations.push(`Invalid path: ${path65}`);
             }
           }
         }
@@ -41967,15 +41967,15 @@ var init_SafetyGuard = __esm({
        * Validate file path against allowed/blocked lists
        */
       validatePath(filePath) {
-        const path64 = __require("path");
-        const resolvedPath = path64.resolve(filePath);
+        const path65 = __require("path");
+        const resolvedPath = path65.resolve(filePath);
         for (const blockedPath of this.constraints.blockedPaths) {
-          if (resolvedPath.startsWith(path64.resolve(blockedPath))) {
+          if (resolvedPath.startsWith(path65.resolve(blockedPath))) {
             return false;
           }
         }
         for (const allowedPath of this.constraints.allowedPaths) {
-          if (resolvedPath.startsWith(path64.resolve(allowedPath))) {
+          if (resolvedPath.startsWith(path65.resolve(allowedPath))) {
             return true;
           }
         }
@@ -42004,9 +42004,9 @@ var init_SafetyGuard = __esm({
             violations.push(`Invalid path in ${action.type}: ${action.args.path}`);
           }
           if (action.args.paths && Array.isArray(action.args.paths)) {
-            for (const path64 of action.args.paths) {
-              if (!this.validatePath(path64)) {
-                violations.push(`Invalid path in ${action.type}: ${path64}`);
+            for (const path65 of action.args.paths) {
+              if (!this.validatePath(path65)) {
+                violations.push(`Invalid path in ${action.type}: ${path65}`);
               }
             }
           }
@@ -42975,8 +42975,8 @@ var init_ConfigActionExecutor = __esm({
       /**
        * Set nested configuration value using dot notation
        */
-      setNestedValue(obj, path64, value) {
-        const keys = path64.split(".");
+      setNestedValue(obj, path65, value) {
+        const keys = path65.split(".");
         let current = obj;
         for (let i2 = 0; i2 < keys.length - 1; i2++) {
           const key = keys[i2];
@@ -51261,7 +51261,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.38"));
+        output3.push(chalk14__default.default.cyan.bold("\u{1F916} About MARIA v4.3.39"));
         output3.push(chalk14__default.default.gray("\u2550".repeat(40)));
         output3.push("");
         output3.push(chalk14__default.default.white.bold("MARIA - Minimal API, Maximum Power"));
@@ -54325,88 +54325,6 @@ var init_SystemCommandFactory = __esm({
     };
   }
 });
-function handleRateLimitError(error2) {
-  console.log();
-  console.log(chalk14__default.default.yellow("\u23F1\uFE0F  Rate Limit Exceeded"));
-  console.log(chalk14__default.default.gray("\u2501".repeat(50)));
-  const route = error2.route || error2.details?.endpoint || "API";
-  const plan = error2.plan || error2.details?.plan || "Unknown";
-  const limit = error2.limit || (error2.details?.limit ? parseInt(error2.details.limit) : null);
-  const retryAfter = error2.retryAfter || error2.details?.retryAfterSeconds;
-  const resetAt = error2.resetAt || (error2.details?.resetAt ? Date.parse(error2.details.resetAt) : null);
-  const waitTime = Number.isFinite(retryAfter) ? `${retryAfter} second${retryAfter > 1 ? "s" : ""}` : "a few seconds";
-  let resetTime = "";
-  if (resetAt && Number.isFinite(resetAt)) {
-    const resetDate = new Date(resetAt);
-    const now2 = /* @__PURE__ */ new Date();
-    const diffMs = resetDate.getTime() - now2.getTime();
-    if (diffMs > 0 && diffMs < 6e4) {
-      resetTime = `in ${Math.ceil(diffMs / 1e3)} seconds`;
-    } else if (diffMs > 0) {
-      resetTime = `at ${resetDate.toLocaleTimeString()}`;
-    }
-  }
-  console.log(chalk14__default.default.white(`Plan: ${chalk14__default.default.bold(plan)}`));
-  console.log(chalk14__default.default.white(`Endpoint: ${chalk14__default.default.bold(route)}`));
-  if (limit !== null) {
-    console.log(chalk14__default.default.white(`Limit: ${chalk14__default.default.bold(limit)} requests`));
-  }
-  if (error2.remaining !== void 0) {
-    console.log(chalk14__default.default.white(`Remaining: ${chalk14__default.default.bold(error2.remaining)} requests`));
-  }
-  console.log();
-  console.log(chalk14__default.default.cyan(`Please wait ${chalk14__default.default.bold(waitTime)} before trying again`));
-  if (resetTime) {
-    console.log(chalk14__default.default.gray(`Rate limit resets ${resetTime}`));
-  }
-  if (error2.hint) {
-    console.log();
-    console.log(chalk14__default.default.magenta("\u{1F4A1} " + error2.hint));
-  }
-  console.log(chalk14__default.default.gray("\u2501".repeat(50)));
-  console.log();
-}
-async function parseRateLimitResponse(response) {
-  if (response.status !== 429) {
-    return null;
-  }
-  const rateLimitInfo = {
-    limit: parseInt(response.headers.get("RateLimit-Limit") || "0") || void 0,
-    remaining: parseInt(response.headers.get("RateLimit-Remaining") || "0") || void 0,
-    resetAt: parseInt(response.headers.get("RateLimit-Reset") || "0") || void 0,
-    retryAfter: parseInt(response.headers.get("Retry-After") || "0") || void 0
-  };
-  try {
-    const data = await response.json();
-    if (data.error === "rate_limited" || data.error === "rate_limit_exceeded") {
-      return {
-        ...data,
-        // Merge header info if not in body
-        limit: data.limit || rateLimitInfo.limit,
-        remaining: data.remaining || rateLimitInfo.remaining,
-        resetAt: data.resetAt || rateLimitInfo.resetAt,
-        retryAfter: data.retryAfter || rateLimitInfo.retryAfter
-      };
-    }
-    return {
-      error: "rate_limited",
-      message: data.message || "Rate limit exceeded. Please wait and try again.",
-      hint: data.hint || "Consider upgrading your plan for higher limits.",
-      ...rateLimitInfo
-    };
-  } catch {
-    return {
-      error: "rate_limited",
-      message: "Rate limit exceeded. Please wait and try again.",
-      hint: "Consider upgrading your plan for higher limits.",
-      ...rateLimitInfo
-    };
-  }
-}
-var init_rate_limit_handler = __esm({
-  "src/services/api-client/rate-limit-handler.ts"() {
-  }
-});
 function extractCodeInfo(codeBlock) {
   const match2 = codeBlock.match(/```([^\n]*)\n?([\s\S]*?)```/);
   if (!match2) {
@@ -54651,8 +54569,408 @@ var init_code_utils = __esm({
   }
 });
 
-// src/services/code-orchestrator/ArgumentInference.ts
+// src/services/creative/NovelArgumentInference.ts
 function extractFirstJson4(text) {
+  if (!text) return null;
+  const start = text.indexOf("{");
+  const end = text.lastIndexOf("}");
+  if (start !== -1 && end !== -1 && end > start) {
+    const cand = text.slice(start, end + 1);
+    try {
+      JSON.parse(cand);
+      return cand;
+    } catch {
+    }
+  }
+  return null;
+}
+async function inferNovelArgs(rawText) {
+  const system = [
+    "You extract structured options for a novel generation command.",
+    'Return JSON ONLY with keys among: { "title"?: string, "lang"?: string, "format"?: "md"|"markdown"|"txt"|"plaintext", "genre"?: string, "planOnly"?: boolean, "chapters"?: number }.',
+    'Infer reasonable values from natural language. Keep chapters between 3 and 50 if specified. If format suggests plain text, choose "plaintext".',
+    "If the user requests outline only, set planOnly=true.",
+    "Do not add commentary."
+  ].join("\n");
+  const resp = await callAPI("/v1/ai-proxy", {
+    method: "POST",
+    body: {
+      prompt: `${system}
+
+---
+
+${rawText}`,
+      taskType: "creative"
+    }
+  });
+  const raw = (resp?.data?.content || resp?.output || "").trim();
+  const jsonText = extractFirstJson4(raw) || raw;
+  let parsed = {};
+  try {
+    parsed = JSON.parse(jsonText);
+  } catch {
+    return {};
+  }
+  const out = {};
+  if (typeof parsed.title === "string" && parsed.title.trim()) out.title = parsed.title.trim();
+  if (typeof parsed.lang === "string" && parsed.lang.trim()) out.lang = parsed.lang.trim().toLowerCase();
+  if (typeof parsed.format === "string") {
+    const f3 = parsed.format.toLowerCase();
+    if (f3 === "md" || f3 === "markdown") out.format = "md";
+    else if (f3 === "txt" || f3 === "plaintext" || f3 === "text") out.format = "txt";
+  }
+  if (typeof parsed.genre === "string" && parsed.genre.trim()) out.genre = parsed.genre.trim();
+  if (typeof parsed.planOnly === "boolean") out.planOnly = parsed.planOnly;
+  if (typeof parsed.chapters === "number" && Number.isFinite(parsed.chapters)) {
+    const n = Math.max(1, Math.min(100, Math.floor(parsed.chapters)));
+    out.chapters = n;
+  }
+  return out;
+}
+var init_NovelArgumentInference = __esm({
+  "src/services/creative/NovelArgumentInference.ts"() {
+    init_api_caller();
+  }
+});
+
+// src/slash-commands/categories/creative/novel.command.ts
+var novel_command_exports = {};
+__export(novel_command_exports, {
+  NovelCommand: () => NovelCommand,
+  default: () => novel_command_default
+});
+function normalizeFormat(fmt) {
+  const f3 = (fmt).toLowerCase();
+  if (f3 === "txt" || f3 === "plaintext" || f3 === "text") return "txt";
+  return "md";
+}
+function normalizeLang(lang) {
+  const l = (lang).toLowerCase();
+  if (!l) return "en";
+  if (["en", "ja", "jp", "zh", "ko", "fr", "de", "es", "it", "pt"].includes(l)) {
+    return l === "jp" ? "ja" : l;
+  }
+  return "en";
+}
+async function writeText(filePath, content) {
+  const dir = path11__namespace.dirname(filePath);
+  await fsp__namespace.mkdir(dir, { recursive: true });
+  await fsp__namespace.writeFile(filePath, content, "utf8");
+}
+function extractFirstJsonArray(text) {
+  if (!text) return null;
+  const t2 = text.trim();
+  const fenced = t2.match(/```json\s*([\s\S]*?)```/i) || t2.match(/```\s*([\s\S]*?)```/);
+  if (fenced && fenced[1]) {
+    const body = fenced[1].trim();
+    try {
+      const arr = JSON.parse(body);
+      return Array.isArray(arr) ? arr : null;
+    } catch {
+    }
+  }
+  const defenced = t2.replace(/```json|```/gi, "").trim();
+  try {
+    const arr = JSON.parse(defenced);
+    return Array.isArray(arr) ? arr : null;
+  } catch {
+  }
+  const s2 = t2.indexOf("[");
+  const e2 = t2.lastIndexOf("]");
+  if (s2 !== -1 && e2 !== -1 && e2 > s2) {
+    const slice = t2.slice(s2, e2 + 1);
+    try {
+      const arr = JSON.parse(slice);
+      return Array.isArray(arr) ? arr : null;
+    } catch {
+    }
+  }
+  return null;
+}
+async function generatePlan(prompt, lang, title, genre) {
+  const system = [
+    "You generate a detailed novel outline (plot).",
+    "Return Markdown with clear sections: Title, Logline, Themes, Characters, Chapter Outline.",
+    "The language should match the requested language."
+  ].join("\n");
+  const user = [
+    `Language: ${lang}`,
+    `Title: ${title}`,
+    genre ? `Genre: ${genre}` : "",
+    "Prompt:",
+    prompt
+  ].filter(Boolean).join("\n");
+  const resp = await callAPI("/v1/ai-proxy", { method: "POST", body: { prompt: `${system}
+
+---
+
+${user}`, taskType: "creative" } });
+  const out = (resp?.data?.content || resp?.output || "").trim();
+  return out;
+}
+async function generateChapters(planMarkdown, lang, chapters) {
+  const system = [
+    "You expand a novel outline into chapter texts.",
+    "Return only JSON array: [{ index: number, title: string, content: string }].",
+    "Write in the requested language and maintain consistency with the outline."
+  ].join("\n");
+  const prompt = `${system}
+
+LANG=${lang}
+CHAPTERS=${chapters}
+
+OUTLINE:
+${planMarkdown}`;
+  const resp = await callAPI("/v1/ai-proxy", { method: "POST", body: { prompt, taskType: "creative" } });
+  const raw = (resp?.data?.content || resp?.output || "").trim();
+  const arr = extractFirstJsonArray(raw);
+  if (Array.isArray(arr)) {
+    return arr.map((it, i2) => ({
+      index: typeof it.index === "number" ? it.index : i2,
+      title: typeof it.title === "string" ? it.title : `Chapter ${i2 + 1}`,
+      content: typeof it.content === "string" ? it.content : ""
+    }));
+  }
+  return [{ index: 0, title: "Chapter 1", content: raw }];
+}
+async function generateTitle(idea, lang, genre) {
+  const system = [
+    "You craft a concise, compelling novel title. Return only the title string.",
+    "Consider the idea and genre. Use the requested language."
+  ].join("\n");
+  const user = [
+    `Language: ${lang}`,
+    genre ? `Genre: ${genre}` : "",
+    "Idea:",
+    idea
+  ].filter(Boolean).join("\n");
+  const resp = await callAPI("/v1/ai-proxy", { method: "POST", body: { prompt: `${system}
+
+---
+
+${user}`, taskType: "creative" } });
+  const raw = (resp?.data?.content || resp?.output || "").trim();
+  try {
+    const obj = JSON.parse(raw);
+    if (typeof obj?.title === "string") return obj.title.trim();
+  } catch {
+  }
+  const matched = raw.match(/```[a-z]*\s*([\s\S]*?)```/i);
+  const text = matched ? matched[1].trim() : raw;
+  return text.split("\n")[0].trim();
+}
+var NovelCommand, novel_command_default;
+var init_novel_command = __esm({
+  "src/slash-commands/categories/creative/novel.command.ts"() {
+    init_base_command();
+    init_code_utils();
+    init_api_caller();
+    init_NovelArgumentInference();
+    init_animations();
+    NovelCommand = class extends BaseCommand {
+      name = "novel";
+      category = "creative";
+      description = "Generate a novel: outline plan and full chapters with language/format options";
+      aliases = ["story"];
+      usage = "<idea or title> [--lang <code>] [--format md|txt] [--genre <name>] [--plan-only] [--chapters <n>]";
+      examples = [
+        { input: "/novel cyberpunk heist in Tokyo --lang ja", description: "\u65E5\u672C\u8A9E\u3067\u30B5\u30A4\u30D0\u30FC\u30D1\u30F3\u30AF\u5C0F\u8AAC\u3092\u751F\u6210" },
+        { input: '/novel "A voyage to Europa" --format txt --genre sci-fi', description: "\u82F1\u8A9E\u30FB\u30D7\u30EC\u30FC\u30F3\u30C6\u30AD\u30B9\u30C8\u3067\u751F\u6210" },
+        { input: "/novel detective mystery --plan-only", description: "\u30D7\u30ED\u30C3\u30C8\u306E\u307F\u3092\u4F5C\u6210\u3057\u3066\u4FDD\u5B58" }
+      ];
+      async execute(args2, context2) {
+        const raw = Array.isArray(args2.raw) ? args2.raw : [];
+        const ideaText = raw.join(" ").trim();
+        if (!ideaText) {
+          return this.error("Usage: /novel <idea or title> [--lang <code>] [--format md|txt] [--genre <name>] [--plan-only] [--chapters <n>]");
+        }
+        const explicit = {
+          lang: typeof args2.options["lang"] === "string" ? String(args2.options["lang"]) : void 0,
+          format: typeof args2.options["format"] === "string" ? String(args2.options["format"]) : void 0,
+          genre: typeof args2.options["genre"] === "string" ? String(args2.options["genre"]) : void 0,
+          chapters: typeof args2.options["chapters"] === "string" ? Number(args2.options["chapters"]) : void 0,
+          planOnly: args2.flags["plan-only"] === true || args2.flags["sow"] === true
+        };
+        let inferred = {};
+        try {
+          const spin = new ProcessAnimation();
+          spin.start();
+          try {
+            inferred = await inferNovelArgs(ideaText);
+          } finally {
+            try {
+              spin.stop();
+            } catch {
+            }
+          }
+        } catch {
+        }
+        const lang = normalizeLang(explicit.lang || inferred.lang || "en");
+        const format = normalizeFormat(explicit.format || inferred.format || "md");
+        const planOnly = explicit.planOnly || inferred.planOnly === true;
+        const chapters = Number.isFinite(explicit.chapters) && explicit.chapters > 0 ? Math.floor(explicit.chapters) : typeof inferred.chapters === "number" && inferred.chapters > 0 ? Math.floor(inferred.chapters) : 8;
+        const genre = explicit.genre || inferred.genre;
+        let generatedTitle = inferred.title;
+        if (!generatedTitle) {
+          const spin = new ProcessAnimation();
+          spin.start();
+          try {
+            generatedTitle = await generateTitle(ideaText, lang, genre);
+          } finally {
+            try {
+              spin.stop();
+            } catch {
+            }
+          }
+        }
+        const titleRaw = (generatedTitle || "novel").slice(0, 120);
+        const title = sanitizeFilenameStrict(titleRaw);
+        const root = process.cwd();
+        const novelDir = await ensureUniquePath(safeResolve(root, path11__namespace.join("novel", title)));
+        await fsp__namespace.mkdir(novelDir, { recursive: true });
+        let plan = "";
+        {
+          const spin = new ProcessAnimation();
+          spin.start();
+          try {
+            plan = await generatePlan(ideaText, lang, title, genre);
+          } finally {
+            try {
+              spin.stop();
+            } catch {
+            }
+          }
+        }
+        const planExt = format === "txt" ? ".txt" : ".md";
+        const planPath = await ensureUniquePath(path11__namespace.join(novelDir, `00_plan${planExt}`));
+        await writeText(planPath, plan);
+        if (planOnly) {
+          const msg2 = [`Saved plan to ${planPath}`, "", "Files:", `- ${planPath}`].join("\n");
+          return this.success(msg2, { dir: novelDir, plan: planPath });
+        }
+        const chapterObjs = await (async () => {
+          const spin = new ProcessAnimation();
+          spin.start();
+          try {
+            return await generateChapters(plan, lang, chapters);
+          } finally {
+            try {
+              spin.stop();
+            } catch {
+            }
+          }
+        })();
+        let index = 1;
+        const saved = [planPath];
+        for (const ch of chapterObjs) {
+          const num = String(index).padStart(2, "0");
+          const chTitle = sanitizeFilenameStrict(ch.title || `chapter-${index}`);
+          const file = path11__namespace.join(novelDir, `${num}_${chTitle}${planExt}`);
+          const finalPath = await ensureUniquePath(file);
+          const content = format === "md" ? `# ${ch.title}
+
+${ch.content}` : ch.content;
+          await writeText(finalPath, content);
+          saved.push(finalPath);
+          index++;
+        }
+        const msg = [
+          `Saved novel to ${novelDir}`,
+          "",
+          "Files:",
+          ...saved.map((p) => `- ${p}`)
+        ].join("\n");
+        return this.success(msg, { dir: novelDir, files: saved });
+      }
+    };
+    novel_command_default = NovelCommand;
+  }
+});
+function handleRateLimitError(error2) {
+  console.log();
+  console.log(chalk14__default.default.yellow("\u23F1\uFE0F  Rate Limit Exceeded"));
+  console.log(chalk14__default.default.gray("\u2501".repeat(50)));
+  const route = error2.route || error2.details?.endpoint || "API";
+  const plan = error2.plan || error2.details?.plan || "Unknown";
+  const limit = error2.limit || (error2.details?.limit ? parseInt(error2.details.limit) : null);
+  const retryAfter = error2.retryAfter || error2.details?.retryAfterSeconds;
+  const resetAt = error2.resetAt || (error2.details?.resetAt ? Date.parse(error2.details.resetAt) : null);
+  const waitTime = Number.isFinite(retryAfter) ? `${retryAfter} second${retryAfter > 1 ? "s" : ""}` : "a few seconds";
+  let resetTime = "";
+  if (resetAt && Number.isFinite(resetAt)) {
+    const resetDate = new Date(resetAt);
+    const now2 = /* @__PURE__ */ new Date();
+    const diffMs = resetDate.getTime() - now2.getTime();
+    if (diffMs > 0 && diffMs < 6e4) {
+      resetTime = `in ${Math.ceil(diffMs / 1e3)} seconds`;
+    } else if (diffMs > 0) {
+      resetTime = `at ${resetDate.toLocaleTimeString()}`;
+    }
+  }
+  console.log(chalk14__default.default.white(`Plan: ${chalk14__default.default.bold(plan)}`));
+  console.log(chalk14__default.default.white(`Endpoint: ${chalk14__default.default.bold(route)}`));
+  if (limit !== null) {
+    console.log(chalk14__default.default.white(`Limit: ${chalk14__default.default.bold(limit)} requests`));
+  }
+  if (error2.remaining !== void 0) {
+    console.log(chalk14__default.default.white(`Remaining: ${chalk14__default.default.bold(error2.remaining)} requests`));
+  }
+  console.log();
+  console.log(chalk14__default.default.cyan(`Please wait ${chalk14__default.default.bold(waitTime)} before trying again`));
+  if (resetTime) {
+    console.log(chalk14__default.default.gray(`Rate limit resets ${resetTime}`));
+  }
+  if (error2.hint) {
+    console.log();
+    console.log(chalk14__default.default.magenta("\u{1F4A1} " + error2.hint));
+  }
+  console.log(chalk14__default.default.gray("\u2501".repeat(50)));
+  console.log();
+}
+async function parseRateLimitResponse(response) {
+  if (response.status !== 429) {
+    return null;
+  }
+  const rateLimitInfo = {
+    limit: parseInt(response.headers.get("RateLimit-Limit") || "0") || void 0,
+    remaining: parseInt(response.headers.get("RateLimit-Remaining") || "0") || void 0,
+    resetAt: parseInt(response.headers.get("RateLimit-Reset") || "0") || void 0,
+    retryAfter: parseInt(response.headers.get("Retry-After") || "0") || void 0
+  };
+  try {
+    const data = await response.json();
+    if (data.error === "rate_limited" || data.error === "rate_limit_exceeded") {
+      return {
+        ...data,
+        // Merge header info if not in body
+        limit: data.limit || rateLimitInfo.limit,
+        remaining: data.remaining || rateLimitInfo.remaining,
+        resetAt: data.resetAt || rateLimitInfo.resetAt,
+        retryAfter: data.retryAfter || rateLimitInfo.retryAfter
+      };
+    }
+    return {
+      error: "rate_limited",
+      message: data.message || "Rate limit exceeded. Please wait and try again.",
+      hint: data.hint || "Consider upgrading your plan for higher limits.",
+      ...rateLimitInfo
+    };
+  } catch {
+    return {
+      error: "rate_limited",
+      message: "Rate limit exceeded. Please wait and try again.",
+      hint: "Consider upgrading your plan for higher limits.",
+      ...rateLimitInfo
+    };
+  }
+}
+var init_rate_limit_handler = __esm({
+  "src/services/api-client/rate-limit-handler.ts"() {
+  }
+});
+
+// src/services/code-orchestrator/ArgumentInference.ts
+function extractFirstJson5(text) {
   const fence = /```json\r?\n([\s\S]*?)```/i.exec(text);
   if (fence) return fence[1];
   const start = text.indexOf("{");
@@ -54686,7 +55004,7 @@ ${rawText}`,
     }
   });
   const raw = (resp?.data?.content || resp?.output || "").trim();
-  const jsonText = extractFirstJson4(raw) || raw;
+  const jsonText = extractFirstJson5(raw) || raw;
   let parsed = {};
   try {
     parsed = JSON.parse(jsonText);
@@ -54798,10 +55116,10 @@ function suggestName(fp, p) {
   const base = (fp.description || "file").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
   return base || "file";
 }
-function guessKindByPath(path64) {
-  if (/__tests__|\.spec\.(t|j)sx?$|^tests\//.test(path64)) return "test";
-  if (/^docs\//.test(path64) || /\.md$/.test(path64)) return "doc";
-  if (/\.(json|cjs|js|ts)$/.test(path64) && !/src\//.test(path64)) return "config";
+function guessKindByPath(path65) {
+  if (/__tests__|\.spec\.(t|j)sx?$|^tests\//.test(path65)) return "test";
+  if (/^docs\//.test(path65) || /\.md$/.test(path65)) return "doc";
+  if (/\.(json|cjs|js|ts)$/.test(path65) && !/src\//.test(path65)) return "config";
   return "source";
 }
 var init_PathInferencer = __esm({
@@ -55065,9 +55383,9 @@ function formatPlanAsDiff(files, opts) {
 function readCurrentFileSafe(root, rel, abs) {
   if (!root && !abs) return "";
   try {
-    const fs51 = __require("fs");
+    const fs52 = __require("fs");
     const p = abs ? abs : __require("path").join(root, rel);
-    return fs51.existsSync(p) ? fs51.readFileSync(p, "utf8") : "";
+    return fs52.existsSync(p) ? fs52.readFileSync(p, "utf8") : "";
   } catch {
     return "";
   }
@@ -55402,7 +55720,8 @@ async function listRepoFiles(root) {
     }
     for (const e2 of entries) {
       const name2 = e2.name;
-      if (name2 === ".git" || name2 === "node_modules" || name2 === "dist" || name2 === ".maria") continue;
+      if (name2 === ".git" || name2 === "node_modules" || name2 === "dist" || name2 === ".maria" || // macOS system/hidden dirs that shouldn't be scanned
+      name2 === ".DS_Store" || name2 === ".Spotlight-V100" || name2 === ".Trashes" || name2 === ".fseventsd" || name2 === ".TemporaryItems") continue;
       const full = path11__namespace.default.join(dir, name2);
       const rel = path11__namespace.default.relative(root, full).replace(/\\/g, "/");
       if (e2.isDirectory()) {
@@ -55655,6 +55974,60 @@ var Orchestrator_exports = {};
 __export(Orchestrator_exports, {
   orchestrate: () => orchestrate
 });
+async function getRepoFiles(root) {
+  if (_repoFileIndexCache && _repoFileIndexCache.root === root) return _repoFileIndexCache.files;
+  const fs52 = await import('fs/promises');
+  const pathMod = await import('path');
+  const ignoreDir = /* @__PURE__ */ new Set([
+    ".git",
+    "node_modules",
+    "dist",
+    "build",
+    ".maria",
+    ".next",
+    "coverage",
+    ".DS_Store",
+    ".Spotlight-V100",
+    ".Trashes",
+    ".fseventsd",
+    ".TemporaryItems"
+  ]);
+  const out = [];
+  async function walk2(dir) {
+    let entries = [];
+    try {
+      entries = await fs52.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e2 of entries) {
+      const name2 = e2.name;
+      if (ignoreDir.has(name2)) continue;
+      const full = pathMod.join(dir, name2);
+      if (e2.isDirectory()) {
+        await walk2(full);
+        continue;
+      }
+      out.push(pathMod.relative(root, full).replace(/\\/g, "/"));
+    }
+  }
+  await walk2(root);
+  _repoFileIndexCache = { root, files: out };
+  return out;
+}
+function languageFromExt(ext2) {
+  const e2 = ext2.toLowerCase().replace(/^\./, "");
+  if (e2 === "ts") return "typescript";
+  if (e2 === "tsx") return "tsx";
+  if (e2 === "js" || e2 === "mjs" || e2 === "cjs") return "javascript";
+  if (e2 === "jsx") return "jsx";
+  if (e2 === "json") return "json";
+  if (e2 === "html") return "html";
+  if (e2 === "css" || e2 === "scss") return "css";
+  if (e2 === "md") return "markdown";
+  if (e2 === "yaml" || e2 === "yml") return "yaml";
+  return void 0;
+}
 async function ensureCodeFallbackManager() {
   const policy = await loadFallbackPolicy().catch(() => getDefaultFallbackPolicy());
   const signature = JSON.stringify(policy);
@@ -55693,11 +56066,19 @@ async function orchestrate(request, opts) {
       explicitAbsMap[rel] = pathMod.join(opts.root, rel);
     }
   }
-  const isEditIntent = detectEditIntent(request, {
+  const isEditIntent = await detectEditIntentEnhanced(opts.root, request, {
     hasAttachments: !!(opts.attachedFiles && opts.attachedFiles.length > 0),
-    explicitFilesCount: explicitFiles.length
-  });
-  const editContext = isEditIntent && explicitFiles.length > 0 ? await buildEditContext(opts.root, explicitFiles, 200, 512 * 1024) : "";
+    explicitFiles});
+  let editTargets = explicitFiles;
+  if (isEditIntent && editTargets.length === 0) {
+    try {
+      const repoFiles = await getRepoFiles(opts.root);
+      const likely = repoFiles.filter((p) => /\.(ts|tsx|js|jsx|html|css|scss|json|md)$/i.test(p));
+      editTargets = likely.slice(0, 20);
+    } catch {
+    }
+  }
+  const editContext = isEditIntent && editTargets.length > 0 ? await buildEditContext(opts.root, editTargets, 200, 512 * 1024) : "";
   if (opts.attachedFiles && opts.attachedFiles.length > 0) {
     const mapRes = await mapAttachmentsToTargets(opts.attachedFiles, {
       root: opts.root,
@@ -55756,14 +56137,14 @@ ${editContext}`;
             const pathAttachments = [];
             if (explicitFiles.length > 0) {
               try {
-                const fs51 = await import('fs/promises');
+                const fs52 = await import('fs/promises');
                 const pathMod = await import('path');
                 for (const rel of explicitFiles) {
                   try {
                     const full = explicitAbsMap[rel] || pathMod.join(opts.root, rel);
-                    const stat13 = await fs51.stat(full).catch(() => null);
+                    const stat13 = await fs52.stat(full).catch(() => null);
                     if (!stat13 || !stat13.isFile()) continue;
-                    const buf = await fs51.readFile(full);
+                    const buf = await fs52.readFile(full);
                     const ext2 = (pathMod.extname(full) || "").toLowerCase();
                     const mime = ext2 === ".pdf" ? "application/pdf" : ext2 === ".png" ? "image/png" : ext2 === ".jpg" || ext2 === ".jpeg" ? "image/jpeg" : ext2 === ".webp" ? "image/webp" : ext2 === ".gif" ? "image/gif" : ext2 === ".bmp" ? "image/bmp" : ext2 === ".svg" ? "image/svg+xml" : ext2 === ".tif" || ext2 === ".tiff" ? "image/tiff" : ext2 === ".heic" ? "image/heic" : ext2 === ".heif" ? "image/heif" : "text/plain";
                     pathAttachments.push({
@@ -55781,7 +56162,7 @@ ${editContext}`;
             const hydratedCtx = [];
             if (ctxAttachments.length > 0) {
               try {
-                const fs51 = await import('fs/promises');
+                const fs52 = await import('fs/promises');
                 for (const a of ctxAttachments) {
                   if (a.data_base64) {
                     hydratedCtx.push(a);
@@ -55792,12 +56173,12 @@ ${editContext}`;
                     continue;
                   }
                   try {
-                    const stat13 = await fs51.stat(p).catch(() => null);
+                    const stat13 = await fs52.stat(p).catch(() => null);
                     if (!stat13 || !stat13.isFile()) {
                       hydratedCtx.push(a);
                       continue;
                     }
-                    const buf = await fs51.readFile(p);
+                    const buf = await fs52.readFile(p);
                     hydratedCtx.push({ ...a, data_base64: buf.toString("base64") });
                   } catch {
                     hydratedCtx.push(a);
@@ -55847,40 +56228,44 @@ ${editContext}`;
       codeOutput = outcome.data?.output || "";
     }
     const blocks = extractBlocks(codeOutput);
-    if (explicitFiles.length > 0) {
+    if (explicitFiles.length > 0 || isEditIntent && editTargets.length > 0) {
       const mapped = /* @__PURE__ */ new Set();
+      const targets = explicitFiles.length > 0 ? explicitFiles : editTargets;
+      const absMap = explicitFiles.length > 0 ? explicitAbsMap : /* @__PURE__ */ Object.create(null);
       const htmlIdx = blocks.findIndex((b) => /html/i.test(b.language));
-      const htmlFile = explicitFiles.find((f3) => f3.toLowerCase().endsWith(".html"));
+      const htmlFile = targets.find((f3) => f3.toLowerCase().endsWith(".html"));
       if (htmlIdx >= 0 && htmlFile) {
-        initial.push({ path: htmlFile, absPath: explicitAbsMap[htmlFile], noNormalize: true, kind: "source", action: "create", description: "HTML page", language: "html", preview: blocks[htmlIdx].code });
+        initial.push({ path: htmlFile, absPath: absMap[htmlFile], noNormalize: true, kind: "source", action: "modify", description: "HTML page", language: "html", preview: blocks[htmlIdx].code });
         mapped.add(htmlFile);
       }
       const jsIdx = blocks.findIndex((b) => /(ts|tsx|jsx|javascript|js)/i.test(b.language));
-      const jsFile = explicitFiles.find((f3) => f3.toLowerCase().endsWith(".js"));
+      const jsFile = targets.find((f3) => f3.toLowerCase().endsWith(".js"));
       if (jsIdx >= 0 && jsFile && !mapped.has(jsFile)) {
-        initial.push({ path: jsFile, absPath: explicitAbsMap[jsFile], noNormalize: true, kind: "source", action: "create", description: "Script", language: "javascript", preview: blocks[jsIdx].code });
+        initial.push({ path: jsFile, absPath: absMap[jsFile], noNormalize: true, kind: "source", action: "modify", description: "Script", language: "javascript", preview: blocks[jsIdx].code });
         mapped.add(jsFile);
       }
       const cssIdx = blocks.findIndex((b) => /css/i.test(b.language));
-      const cssFile = explicitFiles.find((f3) => f3.toLowerCase().endsWith(".css"));
+      const cssFile = targets.find((f3) => f3.toLowerCase().endsWith(".css"));
       if (cssIdx >= 0 && cssFile && !mapped.has(cssFile)) {
-        initial.push({ path: cssFile, absPath: explicitAbsMap[cssFile], noNormalize: true, kind: "source", action: "create", description: "Stylesheet", language: "css", preview: blocks[cssIdx].code });
+        initial.push({ path: cssFile, absPath: absMap[cssFile], noNormalize: true, kind: "source", action: "modify", description: "Stylesheet", language: "css", preview: blocks[cssIdx].code });
         mapped.add(cssFile);
       }
-      for (const f3 of explicitFiles) {
+      for (const f3 of targets) {
         if (mapped.has(f3)) continue;
-        const plan = scaffoldForFilename(f3, explicitFiles);
-        plan.absPath = explicitAbsMap[f3];
-        plan.noNormalize = true;
-        initial.push(plan);
+        const ext2 = (() => {
+          const m2 = f3.lastIndexOf(".");
+          return m2 >= 0 ? f3.slice(m2) : "";
+        })();
+        const lang = languageFromExt(ext2);
+        initial.push({ path: f3, absPath: absMap[f3], noNormalize: true, kind: "source", action: "modify", description: "Edit target", language: lang, preview: "" });
       }
     } else {
       for (let i2 = 0; i2 < blocks.length; i2++) {
         const b = blocks[i2];
         const desired = typeof b.filename === "string" && b.filename.trim() ? b.filename.trim() : null;
-        const path64 = desired || suggestName2(request, b.language, i2);
+        const path65 = desired || suggestName2(request, b.language, i2);
         initial.push({
-          path: path64,
+          path: path65,
           kind: "source",
           action: "create",
           description: describe2(b.language, ""),
@@ -55911,13 +56296,13 @@ ${editContext}`;
     { root: opts.root }
   );
   try {
-    const [{ access: access18 }, path64] = await Promise.all([
+    const [{ access: access18 }, path65] = await Promise.all([
       import('fs/promises'),
       import('path')
     ]);
     for (const p of normalized) {
       try {
-        const absCandidate = p.absPath ? p.absPath : path64.join(opts.root, p.path);
+        const absCandidate = p.absPath ? p.absPath : path65.join(opts.root, p.path);
         await access18(absCandidate);
         p.action = "modify";
         if (isEditIntent) {
@@ -56155,12 +56540,12 @@ function languageExt(lang) {
 }
 async function journalResume(root, request, files) {
   try {
-    const fs51 = await import('fs/promises');
+    const fs52 = await import('fs/promises');
     const dir = path11__namespace.default.join(root, ".maria", "memory");
-    await fs51.mkdir(dir, { recursive: true });
+    await fs52.mkdir(dir, { recursive: true });
     const out = path11__namespace.default.join(dir, "resume-plan.json");
     const payload = { request, createdAt: (/* @__PURE__ */ new Date()).toISOString(), files };
-    await fs51.writeFile(out, JSON.stringify(payload, null, 2), "utf8");
+    await fs52.writeFile(out, JSON.stringify(payload, null, 2), "utf8");
   } catch {
   }
 }
@@ -56288,6 +56673,68 @@ function detectEditIntent(request, ctx2) {
   const mentionsEdit = editKeywords.some((k) => r2.includes(k));
   return ctx2.hasAttachments || ctx2.explicitFilesCount > 0 || mentionsEdit;
 }
+async function detectEditIntentEnhanced(root, request, ctx2) {
+  const baseline = detectEditIntent(request, { hasAttachments: ctx2.hasAttachments, explicitFilesCount: ctx2.explicitFiles.length });
+  if (baseline) return true;
+  const r2 = request.toLowerCase();
+  const softHints = ["improve", "enhance", "make it", "change the", "adjust", "tweak", "rework", "revamp", "retro", "modernize", "clean up", "polish"];
+  const hasSoftHint = softHints.some((k) => r2.includes(k));
+  if (!hasSoftHint) return false;
+  try {
+    const fs52 = await import('fs/promises');
+    const pathMod = await import('path');
+    const { loadGlobby: loadGlobby2 } = await Promise.resolve().then(() => (init_esm_compat(), esm_compat_exports));
+    const globby = await loadGlobby2();
+    const ignore = [
+      "**/node_modules/**",
+      "**/.git/**",
+      "**/dist/**",
+      "**/build/**",
+      "**/.maria/**",
+      "**/.next/**",
+      "**/coverage/**",
+      "**/.DS_Store/**",
+      "**/.DS_Store",
+      "**/.Spotlight-V100/**",
+      "**/.Spotlight-V100",
+      "**/.Trashes/**",
+      "**/.Trashes",
+      "**/.fseventsd/**",
+      "**/.fseventsd",
+      "**/.TemporaryItems/**",
+      "**/.TemporaryItems"
+    ];
+    const candidates = await globby(["**/*.{html,css,js,ts,tsx}"], { cwd: root, absolute: true, gitignore: true, ignore, deep: 3 });
+    if (candidates && candidates.length > 0) return true;
+  } catch {
+  }
+  try {
+    const short = request.trim().length <= 160;
+    if (!short) return false;
+    const system = [
+      "You are classifying whether the user intends to EDIT existing files vs CREATE a new project.",
+      'Return JSON: { "edit": true|false } only.'
+    ].join("\n");
+    const user = `Instruction: ${request}`;
+    const resp = await executeChat([
+      { role: "system", content: system },
+      { role: "user", content: user }
+    ]);
+    const raw = (resp?.output || "").trim();
+    const jsonText = (() => {
+      try {
+        const m2 = raw.match(/\{[\s\S]*\}/);
+        return m2 ? m2[0] : raw;
+      } catch {
+        return raw;
+      }
+    })();
+    const parsed = JSON.parse(jsonText);
+    if (typeof parsed?.edit === "boolean") return !!parsed.edit;
+  } catch {
+  }
+  return false;
+}
 function sanitizeFolderName(name2) {
   const base = name2.toLowerCase().replace(/[`~!@#$%^&*()+=\[\]{}|;:'",<>/?\\]/g, " ").replace(/\s+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48);
   return base || "project";
@@ -56320,14 +56767,14 @@ async function ensureTopFolder(root, proposed, plans) {
   return { folderName: unique };
 }
 async function ensureUniqueFolder(root, base) {
-  const fs51 = await import('fs/promises');
+  const fs52 = await import('fs/promises');
   const pathMod = await import('path');
   let name2 = sanitizeFolderName(base);
   let suffix = 0;
   for (; suffix < Number.MAX_SAFE_INTEGER; ) {
     const candidate = suffix === 0 ? name2 : `${name2}-${String(suffix).padStart(2, "0")}`;
     try {
-      await fs51.access(pathMod.join(root, candidate));
+      await fs52.access(pathMod.join(root, candidate));
       suffix += 1;
     } catch {
       return candidate;
@@ -56337,13 +56784,13 @@ async function ensureUniqueFolder(root, base) {
 }
 async function buildEditContext(root, files, maxLines, maxBytes) {
   try {
-    const fs51 = await import('fs/promises');
+    const fs52 = await import('fs/promises');
     const pathMod = await import('path');
     const sections = [];
     for (const rel of files) {
       const full = pathMod.join(root, rel);
       try {
-        const buf = await fs51.readFile(full);
+        const buf = await fs52.readFile(full);
         const clipped = buf.length > maxBytes ? buf.subarray(0, maxBytes) : buf;
         const text = clipped.toString("utf8").replace(/\r\n/g, "\n");
         const lines = text.split("\n").slice(0, maxLines).join("\n");
@@ -56360,84 +56807,58 @@ ${lines}
   }
 }
 async function resolveExplicitPaths(root, files, hintText) {
-  const fs51 = await import('fs/promises');
+  const fs52 = await import('fs/promises');
   const pathMod = await import('path');
-  const { loadGlobby: loadGlobby2 } = await Promise.resolve().then(() => (init_esm_compat(), esm_compat_exports));
-  const globby = await loadGlobby2();
-  const ignore = [
-    "**/node_modules/**",
-    "**/.git/**",
-    "**/dist/**",
-    "**/build/**",
-    "**/.maria/**",
-    "**/.next/**",
-    "**/coverage/**"
-  ];
-  const hintTokens = Array.from(new Set(hintText.toLowerCase().replace(/[^a-z0-9_/.-]+/g, " ").split(/\s+/).filter(Boolean)));
-  async function findBest(rel) {
-    const normalized = rel.replace(/^\/+/, "").replace(/\\/g, "/");
-    const fullExact = pathMod.join(root, normalized);
-    try {
-      await fs51.access(fullExact);
-      return normalized;
-    } catch {
+  const ignoreDir = /* @__PURE__ */ new Set([
+    ".git",
+    "node_modules",
+    "dist",
+    "build",
+    ".maria",
+    ".next",
+    "coverage",
+    ".DS_Store",
+    ".Spotlight-V100",
+    ".Trashes",
+    ".fseventsd",
+    ".TemporaryItems"
+  ]);
+  async function buildRepoIndex() {
+    if (_repoFileIndexCache && _repoFileIndexCache.root === root) return _repoFileIndexCache.files;
+    const out2 = [];
+    async function walk2(dir) {
+      let entries = [];
+      try {
+        entries = await fs52.readdir(dir, { withFileTypes: true });
+      } catch {
+        return;
+      }
+      for (const e2 of entries) {
+        const name2 = e2.name;
+        if (ignoreDir.has(name2)) continue;
+        const full = pathMod.join(dir, name2);
+        if (e2.isDirectory()) {
+          await walk2(full);
+          continue;
+        }
+        out2.push(pathMod.relative(root, full).replace(/\\/g, "/"));
+      }
     }
+    await walk2(root);
+    _repoFileIndexCache = { root, files: out2 };
+    return out2;
+  }
+  const allFiles = await buildRepoIndex();
+  const hintTokens = Array.from(new Set(hintText.toLowerCase().replace(/[^a-z0-9_/.-]+/g, " ").split(/\s+/).filter(Boolean)));
+  async function rankCandidates(candidates, desired) {
+    const normalized = desired.replace(/^\/+/, "").replace(/\\/g, "/");
     const lowerRel = normalized.toLowerCase();
     const ext2 = (pathMod.extname(normalized) || "").toLowerCase();
     const base = pathMod.basename(normalized);
-    const nameNoExt = base.replace(/\.[^.]+$/, "").toLowerCase();
+    base.replace(/\.[^.]+$/, "").toLowerCase();
     const parentPath = pathMod.dirname(normalized);
     const parent = parentPath.split("/").pop() || "";
     const dirParts = parentPath === "." ? [] : parentPath.split("/").filter(Boolean).map((s2) => s2.toLowerCase());
-    const patterns = [];
-    patterns.push(`**/${normalized}`);
-    if (parent && parent !== "." && parent !== "/") patterns.push(`**/${parent}/${base}`);
-    if (base) patterns.push(`**/${base}`);
-    patterns.push(`**/*${base}`);
-    if (!ext2) {
-      patterns.push(`**/${nameNoExt}.*`);
-    }
-    const uniqPatterns = Array.from(new Set(patterns));
-    const candidatesSet = /* @__PURE__ */ new Set();
-    for (const pat of uniqPatterns) {
-      const found = await globby(pat, { cwd: root, absolute: false, gitignore: true, ignore });
-      for (const f3 of found) {
-        candidatesSet.add(f3.replace(/\\/g, "/"));
-      }
-      if (candidatesSet.size > 200) break;
-    }
-    let candidates = Array.from(candidatesSet);
-    if (dirParts.length > 0) {
-      const filtered = candidates.filter((relp) => {
-        const segs = relp.toLowerCase().split("/");
-        let pos = -1;
-        for (const part of dirParts) {
-          const next = segs.indexOf(part, pos + 1);
-          if (next === -1) return false;
-          pos = next;
-        }
-        return true;
-      });
-      if (filtered.length > 0) candidates = filtered;
-    }
-    if (candidates.length === 0) {
-      const prefixes = ["", "src/", "app/", "pages/"];
-      for (const pre of prefixes) {
-        const cand = pathMod.join(root, pre + normalized);
-        try {
-          await fs51.access(cand);
-          return (pre + normalized).replace(/^\/+/, "");
-        } catch {
-        }
-      }
-      if (dirParts.length > 0) {
-        if (/^(src|app|pages)\//i.test(normalized)) return normalized;
-        const pref = await pickExistingFolderPrefix(root, parentPath);
-        const combined = (pref + normalized).replace(/^\/+/, "").replace(/^(src\/)src\//i, "$1");
-        return combined;
-      }
-      return normalized.replace(/^(src\/)src\//i, "$1");
-    }
     function score(relPath) {
       const lower2 = relPath.toLowerCase();
       let s2 = 0;
@@ -56461,10 +56882,36 @@ async function resolveExplicitPaths(root, files, hintText) {
       s2 -= Math.min(10, Math.floor(relPath.length / 80));
       return s2;
     }
-    let best = candidates[0];
+    const limited = candidates.slice(0, Math.min(50, candidates.length));
+    if (limited.length > 1) {
+      try {
+        const ranked = limited.map((p) => ({ p, s: score(p) })).sort((a, b) => b.s - a.s).slice(0, 5).map((x2) => x2.p);
+        const system = [
+          "You are helping choose the most relevant target file path for an edit operation.",
+          "Given a user request and several candidate repo-relative paths, pick ONE best path.",
+          "Return ONLY the raw path text. No code blocks. No explanations."
+        ].join("\n");
+        const user = [
+          `User request: ${hintText}`,
+          "Candidates:",
+          ...ranked.map((r2, i2) => `${i2 + 1}. ${r2}`),
+          "",
+          "Answer with exactly one of the candidate paths."
+        ].join("\n");
+        const chat = await executeChat([
+          { role: "system", content: system },
+          { role: "user", content: user }
+        ]);
+        const raw = (chat.output || "").trim();
+        const pick = ranked.find((r2) => r2 === raw) || ranked.find((r2) => raw.includes(r2)) || ranked[0];
+        return pick.replace(/^\/+/, "");
+      } catch {
+      }
+    }
+    let best = limited[0];
     let bestScore = score(best);
-    for (let i2 = 1; i2 < candidates.length; i2++) {
-      const c = candidates[i2];
+    for (let i2 = 1; i2 < limited.length; i2++) {
+      const c = limited[i2];
       const sc = score(c);
       if (sc > bestScore) {
         best = c;
@@ -56474,20 +56921,41 @@ async function resolveExplicitPaths(root, files, hintText) {
     return best.replace(/^\/+/, "");
   }
   const out = [];
-  for (const f3 of files) {
-    out.push(await findBest(f3));
+  for (const desired of files) {
+    const normalized = desired.replace(/^\/+/, "").replace(/\\/g, "/");
+    if (allFiles.includes(normalized)) {
+      out.push(normalized);
+      continue;
+    }
+    const base = pathMod.basename(normalized).toLowerCase();
+    const nameNoExt = base.replace(/\.[^.]+$/, "");
+    const candidates = allFiles.filter((p) => {
+      const b = pathMod.basename(p).toLowerCase();
+      return b === base || b.includes(base) || !base.includes(".") && (b === `${nameNoExt}.ts` || b === `${nameNoExt}.js` || b.startsWith(nameNoExt));
+    });
+    if (candidates.length === 0) {
+      const parentPath = pathMod.dirname(normalized);
+      if (parentPath && parentPath !== ".") {
+        const pref = await pickExistingFolderPrefix(root, parentPath);
+        out.push((pref + normalized).replace(/^\/+/, "").replace(/^(src\/)src\//i, "$1"));
+      } else {
+        out.push(normalized.replace(/^(src\/)src\//i, "$1"));
+      }
+      continue;
+    }
+    out.push(await rankCandidates(candidates, normalized));
   }
   return out;
 }
 async function pickExistingFolderPrefix(root, parentPath) {
-  const fs51 = await import('fs/promises');
+  const fs52 = await import('fs/promises');
   const pathMod = await import('path');
   const parts = parentPath.replace(/^\/+/, "").split("/").filter(Boolean);
   const prefixes = ["src", "app", "pages", ""];
   for (const pre of prefixes) {
     const test = pre ? pathMod.join(root, pre, ...parts) : pathMod.join(root, ...parts);
     try {
-      await fs51.access(test);
+      await fs52.access(test);
       return pre ? `${pre}/` : "";
     } catch {
     }
@@ -56534,7 +57002,7 @@ requestAnimationFrame(step);`;
   }
   return { path: filename, kind: "source", action: "create", description: "Source file", preview: "" };
 }
-var codeFallbackManager, codeFallbackPolicySignature;
+var codeFallbackManager, _repoFileIndexCache, codeFallbackPolicySignature;
 var init_Orchestrator = __esm({
   "src/services/code-orchestrator/Orchestrator.ts"() {
     init_RepoScanner();
@@ -56549,6 +57017,7 @@ var init_Orchestrator = __esm({
     init_FallbackManager();
     init_policy();
     codeFallbackManager = null;
+    _repoFileIndexCache = null;
     codeFallbackPolicySignature = null;
   }
 });
@@ -56661,8 +57130,8 @@ var init_code_command = __esm({
           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 });
             if (opts.planOnly) {
-              const fs51 = await import('fs/promises');
-              const path64 = await import('path');
+              const fs52 = await import('fs/promises');
+              const path65 = await import('path');
               const spec = res?.specMarkdown;
               const lines = Array.isArray(res?.summaryLines) ? res.summaryLines : [];
               const planItems = [];
@@ -56696,13 +57165,13 @@ var init_code_command = __esm({
                 if (planItems.length) md.push(...planItems);
                 else md.push("- (no summary available)");
               }
-              const plansDir = path64.join(root, ".maria", "plans");
-              await fs51.mkdir(plansDir, { recursive: true });
+              const plansDir = path65.join(root, ".maria", "plans");
+              await fs52.mkdir(plansDir, { recursive: true });
               const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
               const fileName = `code-plan-${ts}.md`;
-              const outPath = path64.join(plansDir, fileName);
-              await fs51.writeFile(outPath, md.join("\n") + "\n", "utf8");
-              const rel = path64.relative(root, outPath);
+              const outPath = path65.join(plansDir, fileName);
+              await fs52.writeFile(outPath, md.join("\n") + "\n", "utf8");
+              const rel = path65.relative(root, outPath);
               return this.success(`Code plan saved: ${rel}`);
             }
             const detail = res?.detailLines;
@@ -56762,6 +57231,97 @@ ${pretty}`);
       // Add default language hints when not specified by the user (LLM-assisted detection)
       async ensureLanguageDefaults(raw) {
         try {
+          const fs52 = await import('fs/promises');
+          const pathMod = await import('path');
+          const cwd2 = process.cwd();
+          const ignoreDir = /* @__PURE__ */ new Set([".git", "node_modules", "dist", "build", ".maria", ".next", "coverage", ".DS_Store", ".Spotlight-V100", ".Trashes", ".fseventsd", ".TemporaryItems"]);
+          const pathTokens = /* @__PURE__ */ new Set();
+          const fileLike = raw.match(/([\w\-./\\:]+\.[A-Za-z0-9]{1,10})/g) || [];
+          for (const t2 of fileLike) pathTokens.add(t2);
+          const slashLike = raw.match(/[^\s"']*[\\/][^\s"']+/g) || [];
+          for (const t2 of slashLike) pathTokens.add(t2);
+          const listFilesUnder = async (dir, maxCount) => {
+            const out = [];
+            const walk2 = async (d) => {
+              if (out.length >= maxCount) return;
+              let entries = [];
+              try {
+                entries = await fs52.readdir(d, { withFileTypes: true });
+              } catch {
+                return;
+              }
+              for (const e2 of entries) {
+                const name2 = e2.name;
+                if (ignoreDir.has(name2)) continue;
+                const full = pathMod.join(d, name2);
+                if (e2.isDirectory()) {
+                  await walk2(full);
+                  if (out.length >= maxCount) break;
+                  continue;
+                }
+                if (/\.(ts|tsx|js|jsx|py|java|kt|go|rs|rb|swift|cs|c|cpp|hpp|php|scala|hs|ex|exs|dart|lua|zig|sol|sql|html|css|scss|md|json)$/i.test(name2)) {
+                  out.push(full);
+                  if (out.length >= maxCount) break;
+                }
+              }
+            };
+            await walk2(dir);
+            return out;
+          };
+          const readHead = async (full, lines) => {
+            try {
+              const buf = await fs52.readFile(full, "utf8");
+              return buf.split(/\r?\n/).slice(0, lines).join("\n");
+            } catch {
+              return "";
+            }
+          };
+          const samples = [];
+          for (const tok of Array.from(pathTokens)) {
+            const abs = pathMod.isAbsolute(tok) ? tok : pathMod.join(cwd2, tok);
+            try {
+              const st = await fs52.stat(abs);
+              if (st.isFile()) {
+                samples.push(await readHead(abs, 10));
+              } else if (st.isDirectory()) {
+                const files = await listFilesUnder(abs, 25);
+                for (const f3 of files) samples.push(await readHead(f3, 10));
+              }
+            } catch {
+            }
+            if (samples.length >= 50) break;
+          }
+          if (samples.length > 0) {
+            const preSpin = new ProcessAnimation();
+            preSpin.start();
+            let llmLang = null;
+            try {
+              llmLang = await this.detectLanguageLLMFromSamples(samples);
+            } finally {
+              try {
+                preSpin.stop();
+              } catch {
+              }
+            }
+            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})`;
+            }
+          }
+        } catch {
+        }
+        try {
+          const preSpin = new ProcessAnimation();
+          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.).",
@@ -56780,8 +57340,12 @@ ${pretty}`);
 ${user}`
             }
           });
+          try {
+            preSpin.stop();
+          } catch {
+          }
           const content = (resp?.data?.content || resp?.content || "").trim();
-          const extractFirstJson6 = (text) => {
+          const extractFirstJson7 = (text) => {
             const fence = /```\s*json\s*\r?\n([\s\S]*?)```/i.exec(text);
             if (fence) return fence[1];
             const generic = /```\s*\r?\n([\s\S]*?)```/i.exec(text);
@@ -56804,7 +57368,7 @@ ${user}`
             }
             return null;
           };
-          const jsonText = extractFirstJson6(content) || content;
+          const jsonText = extractFirstJson7(content) || content;
           let parsed = {};
           try {
             parsed = JSON.parse(jsonText);
@@ -56817,6 +57381,76 @@ ${user}`
         const hint = " (Use TypeScript and React; prefer functional components and node)";
         return raw + hint;
       }
+      // LLM-based language detection from sample code heads (top-10 lines per file)
+      async detectLanguageLLMFromSamples(samples) {
+        try {
+          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."
+          ].join("\n");
+          const joined = samples.slice(0, 20).map((s2, i2) => `// sample ${i2 + 1}
+${s2}`).join("\n\n");
+          const { callAPI: callAPI2 } = await Promise.resolve().then(() => (init_api_caller(), api_caller_exports));
+          const resp = await callAPI2("/v1/ai-proxy", {
+            method: "POST",
+            body: {
+              provider: "google",
+              model: "gemini-2.5-flash",
+              taskType: "chat",
+              prompt: `${system}
+
+${joined}`
+            }
+          });
+          const content = (resp?.data?.content || resp?.content || "").trim();
+          const token = content.replace(/```[\s\S]*?```/g, "").trim().toLowerCase();
+          const norm = this.normalizeLanguageName(token);
+          return norm || null;
+        } catch {
+          return null;
+        }
+      }
+      normalizeLanguageName(lang) {
+        const l = (lang || "").toLowerCase().trim();
+        if (!l) return null;
+        const map = {
+          "ts": "typescript",
+          "typescript": "typescript",
+          "tsx": "tsx",
+          "jsx": "jsx",
+          "js": "javascript",
+          "javascript": "javascript",
+          "py": "python",
+          "python": "python",
+          "java": "java",
+          "go": "go",
+          "rust": "rust",
+          "rs": "rust",
+          "php": "php",
+          "c++": "cpp",
+          "cpp": "cpp",
+          "c": "c",
+          "swift": "swift",
+          "kotlin": "kotlin",
+          "rb": "ruby",
+          "ruby": "ruby",
+          "cs": "csharp",
+          "c#": "csharp",
+          "csharp": "csharp",
+          "html": "html",
+          "css": "css",
+          "scss": "scss",
+          "json": "json",
+          "yaml": "yaml",
+          "yml": "yaml",
+          "markdown": "markdown",
+          "md": "markdown"
+        };
+        return map[l] || null;
+      }
       // v2.0 helpers
       parseV2Options(raw) {
         const opts = { planOnly: false, apply: false, dryRun: false, interactive: false, yes: false, rollback: true, output: void 0, noCode: false, previewLines: 0, root: void 0, maxFiles: void 0, verbose: false, gitGuard: void 0, allowDotfiles: false, confirmOverwrites: [], gitCommit: void 0, gitBranch: void 0, gitTag: void 0, gitTagPrefix: void 0, gitPush: void 0, gitPushRemote: void 0, onlyAttached: false, attachMode: "assist", maxAttachments: 50, diffLines: void 0, diffBytes: void 0, diffHunks: void 0, diffGlobalMaxFiles: void 0, diffGlobalMaxBytes: void 0 };
@@ -57012,16 +57646,16 @@ ${user}`
       }
       async persistLastPlan(root, plans) {
         try {
-          const fs51 = await import('fs/promises');
+          const fs52 = await import('fs/promises');
           const p = path11__namespace.join(root, ".maria");
-          await fs51.mkdir(p, { recursive: true });
+          await fs52.mkdir(p, { recursive: true });
           const out = path11__namespace.join(p, "last-plan.json");
-          await fs51.writeFile(out, JSON.stringify({ createdAt: (/* @__PURE__ */ new Date()).toISOString(), plans }, null, 2), "utf8");
+          await fs52.writeFile(out, JSON.stringify({ createdAt: (/* @__PURE__ */ new Date()).toISOString(), plans }, null, 2), "utf8");
         } catch {
         }
       }
       async applyPlan(plans, options) {
-        const fs51 = await import('fs/promises');
+        const fs52 = await import('fs/promises');
         const created = [];
         const modified = [];
         const skipped = [];
@@ -57040,9 +57674,9 @@ ${user}`
               continue;
             }
             const tmp = full + `.tmp-${process.pid}-${Date.now()}`;
-            await fs51.mkdir(path11__namespace.dirname(full), { recursive: true });
-            await fs51.writeFile(tmp, plan.preview || "", "utf8");
-            await fs51.rename(tmp, full);
+            await fs52.mkdir(path11__namespace.dirname(full), { recursive: true });
+            await fs52.writeFile(tmp, plan.preview || "", "utf8");
+            await fs52.rename(tmp, full);
             if (exists2) modified.push(plan.path);
             else created.push(plan.path);
             written++;
@@ -57053,7 +57687,7 @@ ${user}`
           if (options.rollback) {
             for (const p of [...created, ...modified]) {
               try {
-                await fs51.unlink(path11__namespace.join(options.root, p));
+                await fs52.unlink(path11__namespace.join(options.root, p));
               } catch {
               }
             }
@@ -57063,8 +57697,8 @@ ${user}`
       }
       async pathExists(p) {
         try {
-          const fs51 = await import('fs/promises');
-          await fs51.access(p);
+          const fs52 = await import('fs/promises');
+          await fs52.access(p);
           return true;
         } catch {
           return false;
@@ -57175,17 +57809,17 @@ ${user}`
       // Attempt to collect attached files from context; map to AttachedFileContext
       async collectAttachedFiles(context2) {
         const list = [];
-        const fs51 = await import('fs/promises');
-        const path64 = await import('path');
+        const fs52 = await import('fs/promises');
+        const path65 = await import('path');
         const att = context2 && (context2.attachments || context2.input?.attachments) || [];
         for (const a of att) {
           try {
             const p = a.path || a.filePath || a.name || "";
-            const originalName = a.name || path64.basename(p || `attachment_${Date.now().toString(36)}`);
+            const originalName = a.name || path65.basename(p || `attachment_${Date.now().toString(36)}`);
             let content = a.content;
             if (!content && p) {
-              const abs = path64.isAbsolute(p) ? p : path64.join(process.cwd(), p);
-              content = await fs51.readFile(abs, "utf8");
+              const abs = path65.isAbsolute(p) ? p : path65.join(process.cwd(), p);
+              content = await fs52.readFile(abs, "utf8");
             }
             if (!content) continue;
             list.push({ originalName, pathHint: p || void 0, content, size: Buffer.byteLength(content, "utf8"), mime: a.mime || a.type });
@@ -63874,17 +64508,17 @@ var init_GraphEngine = __esm({
         const visited = /* @__PURE__ */ new Set();
         const queue = [{ id: from, path: [from] }];
         while (queue.length) {
-          const { id, path: path64 } = queue.shift();
+          const { id, path: path65 } = queue.shift();
           if (visited.has(id)) continue;
           visited.add(id);
           const neighbors = this.edges.get(id) || /* @__PURE__ */ new Set();
           for (const e2 of neighbors) {
             if (e2.to === to) {
-              const res = [...path64, to];
+              const res = [...path65, to];
               this.recordQueryTime(Date.now() - start);
               return res;
             }
-            if (!visited.has(e2.to)) queue.push({ id: e2.to, path: [...path64, e2.to] });
+            if (!visited.has(e2.to)) queue.push({ id: e2.to, path: [...path65, e2.to] });
           }
         }
         this.recordQueryTime(Date.now() - start);
@@ -66551,12 +67185,12 @@ This will:
         };
         const result = await this.deltaDetector.detectDelta(root, deltaOptions);
         const files = [
-          ...result.changed.map((path64) => ({
-            _path: path64,
-            type: previousState?.fileHashes?.[path64] ? "modified" : "added"
+          ...result.changed.map((path65) => ({
+            _path: path65,
+            type: previousState?.fileHashes?.[path65] ? "modified" : "added"
           })),
-          ...result.deleted.map((path64) => ({
-            _path: path64,
+          ...result.deleted.map((path65) => ({
+            _path: path65,
             type: "deleted"
           }))
         ];
@@ -69992,13 +70626,13 @@ async function checkShield(commandName, userPlan = "free") {
 }
 async function loadManifest() {
   try {
-    const fs51 = await import('fs');
-    const path64 = await import('path');
-    const manifestPath = path64.join(
+    const fs52 = await import('fs');
+    const path65 = await import('path');
+    const manifestPath = path65.join(
       __dirname,
       "../command-manifest-v2.1.json"
     );
-    const content = fs51.readFileSync(manifestPath, "utf-8");
+    const content = fs52.readFileSync(manifestPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return { commands: [] };
@@ -71493,7 +72127,7 @@ ${user}`,
     };
   }
 });
-function extractFirstJson5(text) {
+function extractFirstJson6(text) {
   const fence = /```json\r?\n([\s\S]*?)```/i.exec(text);
   if (fence) return fence[1];
   const start = text.indexOf("{");
@@ -71540,7 +72174,7 @@ ${user}`,
     }
   });
   const raw = (response?.data?.content || response?.output || "").trim();
-  const jsonText = extractFirstJson5(raw) || raw;
+  const jsonText = extractFirstJson6(raw) || raw;
   let parsed = {};
   try {
     parsed = JSON.parse(jsonText);
@@ -72400,6 +73034,15 @@ async function registerBuiltInCommands() {
     } catch (error2) {
       console.error("Failed to register media commands:", error2);
     }
+    try {
+      const NovelModule = await Promise.resolve().then(() => (init_novel_command(), novel_command_exports));
+      const NovelClass = NovelModule.NovelCommand || NovelModule.default;
+      const novel = new NovelClass();
+      if (novel.initialize) await novel.initialize();
+      commandRegistry.register(novel);
+    } catch (error2) {
+      console.error("Failed to register novel command:", error2);
+    }
     try {
       const { codeCommand: codeCommand2 } = await Promise.resolve().then(() => (init_code_command(), code_command_exports));
       try {
@@ -74932,16 +75575,16 @@ var init_ai_response_service = __esm({
                 if (p) candidates.add(p);
               }
               if (candidates.size > 0) {
-                const fs51 = await import('fs/promises');
+                const fs52 = await import('fs/promises');
                 const pathMod = await import('path');
                 const cwd2 = process.cwd();
                 for (const cand of candidates) {
                   try {
                     const normalized = cand.replace(/^"|"$/g, "").replace(/^'|'$/g, "");
                     const abs = pathMod.isAbsolute(normalized) ? normalized : pathMod.join(cwd2, normalized);
-                    const st = await fs51.stat(abs).catch(() => null);
+                    const st = await fs52.stat(abs).catch(() => null);
                     if (!st || !st.isFile()) continue;
-                    const buf = await fs51.readFile(abs);
+                    const buf = await fs52.readFile(abs);
                     const ext2 = (pathMod.extname(abs) || "").toLowerCase();
                     const mime = ext2 === ".pdf" ? "application/pdf" : ext2 === ".png" ? "image/png" : ext2 === ".jpg" || ext2 === ".jpeg" ? "image/jpeg" : ext2 === ".webp" ? "image/webp" : ext2 === ".gif" ? "image/gif" : ext2 === ".bmp" ? "image/bmp" : ext2 === ".svg" ? "image/svg+xml" : ext2 === ".tif" || ext2 === ".tiff" ? "image/tiff" : ext2 === ".heic" ? "image/heic" : ext2 === ".heif" ? "image/heif" : "text/plain";
                     autoAttachments.push({ name: pathMod.basename(abs), path: abs, mime, data_base64: buf.toString("base64") });