zelari-code 1.6.0 → 1.7.1

package/dist/cli/main.bundled.js

@@ -16576,6 +16576,28 @@ var init_filesystem = __esm({
 // packages/core/dist/core/tools/builtin/shellResolver.js
 import { existsSync as existsSync4 } from "node:fs";
 import { spawnSync } from "node:child_process";
+function isWslBashPath(p3) {
+  if (!p3 || typeof p3 !== "string")
+    return false;
+  const n = p3.replace(/\//g, "\\").toLowerCase();
+  if (n.includes("\\windows\\system32\\bash.exe"))
+    return true;
+  if (n.includes("\\windows\\syswow64\\bash.exe"))
+    return true;
+  if (n.includes("\\windowsapps\\bash.exe"))
+    return true;
+  return false;
+}
+function acceptBashPath(p3) {
+  if (!p3 || p3.trim().length === 0)
+    return null;
+  const trimmed = p3.trim();
+  if (isWslBashPath(trimmed))
+    return null;
+  if (!existsSyncSafe(trimmed))
+    return null;
+  return trimmed;
+}
 function resolveShell(forceReResolve = false) {
   if (memoized && !forceReResolve)
     return memoized;
@@ -16596,24 +16618,25 @@ function resolveShell(forceReResolve = false) {
   return memoized;
 }
 function resolveBashWindows() {
-  const envShell = process.env.ZELARI_SHELL;
-  if (envShell && envShell.trim().length > 0 && existsSyncSafe(envShell)) {
-    return envShell;
-  }
-  const sessionShell = process.env.SHELL;
-  if (sessionShell && sessionShell.trim().length > 0 && existsSyncSafe(sessionShell)) {
-    return sessionShell;
-  }
+  const fromEnv = acceptBashPath(process.env.ZELARI_SHELL);
+  if (fromEnv)
+    return fromEnv;
+  const fromSession = acceptBashPath(process.env.SHELL);
+  if (fromSession)
+    return fromSession;
   for (const p3 of STANDARD_BASH_PATHS) {
-    if (existsSyncSafe(p3))
-      return p3;
+    const accepted = acceptBashPath(p3);
+    if (accepted)
+      return accepted;
   }
   try {
     const result = spawnSync("where", ["bash"], { encoding: "utf-8", windowsHide: true });
     if (result.status === 0 && result.stdout) {
-      const first = result.stdout.split(/\r?\n/).find((l) => l.trim().length > 0);
-      if (first && existsSyncSafe(first))
-        return first.trim();
+      for (const line of result.stdout.split(/\r?\n/)) {
+        const accepted = acceptBashPath(line);
+        if (accepted)
+          return accepted;
+      }
     }
   } catch {
   }
@@ -16643,6 +16666,24 @@ var init_shellResolver = __esm({
 
 // packages/core/dist/core/tools/builtin/shell.js
 import { spawn } from "node:child_process";
+import { dirname } from "node:path";
+function withNodeDirOnPath(base) {
+  const env = { ...base };
+  try {
+    const nodeDir = dirname(process.execPath);
+    if (!nodeDir)
+      return env;
+    const sep = process.platform === "win32" ? ";" : ":";
+    const current = env.PATH ?? env.Path ?? "";
+    const parts = current.split(sep).filter((p3) => p3.length > 0);
+    const has = parts.some((p3) => p3.toLowerCase() === nodeDir.toLowerCase());
+    if (!has) {
+      env.PATH = `${nodeDir}${sep}${current}`;
+    }
+  } catch {
+  }
+  return env;
+}
 var BashArgsSchema, INTERACTIVE_CANCEL_RE, INTERACTIVE_HINT, bashTool;
 var init_shell = __esm({
   "packages/core/dist/core/tools/builtin/shell.js"() {
@@ -16669,7 +16710,10 @@ var init_shell = __esm({
           const cwd = args.cwd ?? ctx.cwd;
           const resolved = resolveShell();
           let child;
-          const baseEnv = { ...process.env, CI: process.env.CI ?? "1" };
+          const baseEnv = withNodeDirOnPath({
+            ...process.env,
+            CI: process.env.CI ?? "1"
+          });
           const env = resolved.isBash ? { ...baseEnv, MSYSTEM: process.env.MSYSTEM ?? "MINGW64" } : baseEnv;
           if (resolved.isBash) {
             child = spawn(resolved.shell, ["-c", args.command], {
@@ -18401,6 +18445,366 @@ var init_systemPromptBuilder = __esm({
   }
 });
 
+// packages/core/dist/agents/languagePolicy.js
+function isLetter(cp) {
+  return cp >= 65 && cp <= 90 || // A-Z
+  cp >= 97 && cp <= 122 || // a-z
+  cp >= 192 && cp <= 591 || // Latin-1 supplement + Extended A/B
+  cp >= 7680 && cp <= 7935 || // Latin Extended Additional
+  cp >= 880 && cp <= 1023 || // Greek
+  cp >= 1024 && cp <= 1279 || // Cyrillic
+  cp >= 1424 && cp <= 1535 || // Hebrew
+  cp >= 1536 && cp <= 1791 || // Arabic
+  cp >= 2304 && cp <= 2431 || // Devanagari
+  cp >= 12352 && cp <= 12543 || // Hiragana + Katakana
+  cp >= 19968 && cp <= 40959 || // CJK Unified
+  cp >= 44032 && cp <= 55215;
+}
+function isLatinChar(cp) {
+  return cp >= 65 && cp <= 90 || // A-Z
+  cp >= 97 && cp <= 122 || // a-z
+  cp >= 192 && cp <= 591 || // Latin-1 supplement + Extended A/B
+  cp >= 7680 && cp <= 7935;
+}
+function detectResponseLanguage(text) {
+  if (!text || text.trim().length === 0)
+    return "it";
+  const stripped = text.replace(/```[\s\S]*?```/g, " ").replace(/`[^`]*`/g, " ").toLowerCase();
+  if (stripped.trim().length === 0)
+    return "it";
+  let totalLetters = 0;
+  let nonLatinLetters = 0;
+  for (let i = 0; i < stripped.length; i++) {
+    const cp = stripped.codePointAt(i);
+    if (cp === void 0)
+      continue;
+    if (!isLetter(cp))
+      continue;
+    totalLetters += 1;
+    if (!isLatinChar(cp))
+      nonLatinLetters += 1;
+  }
+  const nonLatinRatio = totalLetters > 0 ? nonLatinLetters / totalLetters : 0;
+  const SCRIPT_DOMINANCE_THRESHOLD = 0.3;
+  if (nonLatinRatio >= SCRIPT_DOMINANCE_THRESHOLD) {
+    for (const { lang, ranges } of SCRIPT_RANGES) {
+      for (const [lo, hi] of ranges) {
+        for (let i = 0; i < stripped.length; i++) {
+          const cp = stripped.codePointAt(i);
+          if (cp !== void 0 && cp >= lo && cp <= hi)
+            return lang;
+        }
+      }
+    }
+  }
+  const ACCENT_VOTES = [
+    // Italian-specific
+    { lang: "it", weight: 2, chars: "\xE0\xE8\xE9\xEC\xF2\xF3\xF9" },
+    // French-only accents
+    { lang: "fr", weight: 2, chars: "\xE2\xE7\xEA\xEB\xEE\xEF\xF4\xFB\u0153\xE6" },
+    // German-only
+    { lang: "de", weight: 3, chars: "\xE4\xF6\xFC\xDF" },
+    // Spanish-only (ñ is the discriminator)
+    { lang: "es", weight: 3, chars: "\xF1\xE1\xED\xF3\xFA\xBF\xA1" },
+    // Portuguese-only (ã/õ are the discriminator)
+    { lang: "pt", weight: 3, chars: "\xE3\xF5\xE1\xE9\xED\xF3\xFA\xE2\xEA\xF4" },
+    // Dutch-only
+    { lang: "nl", weight: 2, chars: "\xE1\xE8\xE9\xEB\xED\xF3\xF6\xFA\xFC" }
+  ];
+  const accentScores = {};
+  for (const { lang, weight, chars } of ACCENT_VOTES) {
+    let hits = 0;
+    for (const c of chars)
+      if (stripped.includes(c))
+        hits += 1;
+    if (hits > 0)
+      accentScores[lang] = (accentScores[lang] ?? 0) + weight * hits;
+  }
+  const accentOrdered = Object.entries(accentScores).sort((a, b) => b[1] - a[1]).map(([l]) => l);
+  if (accentOrdered.length > 0 && accentOrdered.length === 1) {
+    return accentOrdered[0];
+  }
+  if (accentOrdered.length > 1) {
+    return accentOrdered[0];
+  }
+  const tokens = stripped.split(/[\s,;.!?()\[\]{}<>:'"\\/]+/).filter((t) => t.length > 1);
+  if (tokens.length === 0)
+    return "it";
+  const scores = {};
+  for (const [lang, words] of Object.entries(FUNCTION_WORDS)) {
+    let hits = 0;
+    const tokenSet = new Set(tokens);
+    for (const w of words) {
+      if (tokenSet.has(w))
+        hits += 1;
+    }
+    if (hits > 0)
+      scores[lang] = hits;
+  }
+  const ordered = Object.entries(scores).sort((a, b) => b[1] - a[1] || (a[0] === "it" ? -1 : b[0] === "it" ? 1 : 0)).map(([l]) => l);
+  if (ordered.length > 0)
+    return ordered[0];
+  return "it";
+}
+function resolveResponseLanguage(text, env = process.env) {
+  const raw = env.ZELARI_RESPONSE_LANG?.trim().toLowerCase();
+  if (raw && raw !== "auto") {
+    if (raw in LANGUAGE_LABELS)
+      return raw;
+    const sink = globalThis.__zelariLangWarnSink ?? ((msg) => console.warn(`[zelari-code] ${msg}`));
+    sink(`ZELARI_RESPONSE_LANG='${env.ZELARI_RESPONSE_LANG}' is not a supported language (known: ${Object.keys(LANGUAGE_LABELS).join(", ")}, or 'auto'). Falling back to detection.`);
+  }
+  return detectResponseLanguage(text);
+}
+function buildLanguageDirective(lang) {
+  const label = LANGUAGE_LABELS[lang];
+  return `# Response Language \u2014 ${label}
+
+Reply in **${label}** for the entirety of your response, including any final synthesis, clarifying questions, and tool-call descriptions. This directive applies in all modes (single agent, council members, zelari slices):
+
+- Read the user's last message in context and mirror its language. If the user's prompt is in ${label}, reply in ${label}. If it mixes languages, default to ${label}.
+- Do not switch to English (or any other language) for code, error messages, tool names, file paths, or technical terms \u2014 code is language-neutral and stays as-is.
+- If the user explicitly asks for a different language in the same turn (e.g. "reply in English"), honor that request for the rest of this turn only.
+- For clarifying questions (---QUESTION--- blocks), write the \`question\` and \`choices\` fields in ${label} so the picker UI matches the user's language.
+- For council synthesis (Lucifero) and any final-answer turn, the user-visible text is in ${label}; intermediate specialist notes that the user never sees directly can stay in their working language.`;
+}
+function buildLanguagePolicyModule(lang) {
+  return {
+    type: LANGUAGE_POLICY_MODULE_TYPE,
+    title: `Response Language (${LANGUAGE_LABELS[lang]})`,
+    priority: 5,
+    content: buildLanguageDirective(lang)
+  };
+}
+function buildLanguagePolicyModuleFor(userText, env = process.env) {
+  return buildLanguagePolicyModule(resolveResponseLanguage(userText, env));
+}
+var LANGUAGE_LABELS, SCRIPT_RANGES, FUNCTION_WORDS, LANGUAGE_POLICY_MODULE_TYPE;
+var init_languagePolicy = __esm({
+  "packages/core/dist/agents/languagePolicy.js"() {
+    "use strict";
+    LANGUAGE_LABELS = {
+      it: "Italian",
+      en: "English",
+      fr: "French",
+      es: "Spanish",
+      de: "German",
+      pt: "Portuguese",
+      nl: "Dutch",
+      zh: "Chinese (Simplified)",
+      ja: "Japanese",
+      ko: "Korean",
+      ru: "Russian",
+      ar: "Arabic"
+    };
+    SCRIPT_RANGES = [
+      // v1.7.0 fix: ja/kr MUST come before zh — kanji (CJK Unified) and hangul
+      // glyphs can fall in either's range when both languages are present, but
+      // hiragana/katakana (ja) and hangul jamo (kr) are unique owners. A mixed
+      // string like "こんにちは、関数の作り方を…" had kanji that triggered the
+      // zh range first, returning 'zh' for a clearly-Japanese message.
+      { lang: "ja", ranges: [[12352, 12447], [12448, 12543]] },
+      { lang: "ko", ranges: [[44032, 55215], [4352, 4607]] },
+      { lang: "zh", ranges: [[19968, 40959]] },
+      { lang: "ar", ranges: [[1536, 1791]] },
+      { lang: "ru", ranges: [[1024, 1279]] }
+    ];
+    FUNCTION_WORDS = {
+      it: [
+        "il",
+        "lo",
+        "la",
+        "gli",
+        "le",
+        "un",
+        "uno",
+        "una",
+        "di",
+        "del",
+        "della",
+        "dei",
+        "e",
+        "che",
+        "chi",
+        "come",
+        "con",
+        "per",
+        "non",
+        "sono",
+        "questo",
+        "questa",
+        "quello",
+        "quella",
+        "fare",
+        "fai",
+        "crea",
+        "creare",
+        "mostra",
+        "ciao",
+        "grazie",
+        "bene",
+        "male",
+        "puoi",
+        "come",
+        "cosa",
+        "questo"
+      ],
+      en: [
+        "the",
+        "a",
+        "an",
+        "of",
+        "and",
+        "is",
+        "are",
+        "was",
+        "were",
+        "to",
+        "for",
+        "with",
+        "that",
+        "this",
+        "these",
+        "those",
+        "do",
+        "does",
+        "make",
+        "create",
+        "show",
+        "hello",
+        "help",
+        "please",
+        "thanks",
+        "how",
+        "what",
+        "where",
+        "why"
+      ],
+      fr: [
+        "le",
+        "la",
+        "les",
+        "un",
+        "une",
+        "des",
+        "de",
+        "du",
+        "et",
+        "est",
+        "sont",
+        "que",
+        "qui",
+        "avec",
+        "pour",
+        "dans",
+        "pas",
+        "oui",
+        "non",
+        "faire",
+        "cr\xE9er",
+        "bonjour",
+        "merci",
+        "bien"
+      ],
+      es: [
+        "el",
+        "la",
+        "los",
+        "las",
+        "un",
+        "una",
+        "de",
+        "del",
+        "y",
+        "es",
+        "son",
+        "que",
+        "con",
+        "por",
+        "para",
+        "no",
+        "s\xED",
+        "hacer",
+        "crear",
+        "mostrar",
+        "hola",
+        "gracias",
+        "bueno"
+      ],
+      de: [
+        "der",
+        "die",
+        "das",
+        "den",
+        "dem",
+        "des",
+        "und",
+        "ist",
+        "sind",
+        "nicht",
+        "mit",
+        "f\xFCr",
+        "auf",
+        "zu",
+        "ja",
+        "nein",
+        "machen",
+        "erstellen",
+        "zeigen",
+        "hallo",
+        "danke",
+        "gut"
+      ],
+      pt: [
+        "o",
+        "a",
+        "os",
+        "as",
+        "um",
+        "uma",
+        "de",
+        "do",
+        "da",
+        "e",
+        "\xE9",
+        "s\xE3o",
+        "que",
+        "com",
+        "para",
+        "n\xE3o",
+        "sim",
+        "fazer",
+        "criar",
+        "mostrar",
+        "ol\xE1",
+        "obrigado",
+        "bom"
+      ],
+      nl: [
+        "de",
+        "het",
+        "een",
+        "van",
+        "en",
+        "is",
+        "zijn",
+        "niet",
+        "met",
+        "voor",
+        "ja",
+        "nee",
+        "doen",
+        "maken",
+        "tonen",
+        "hallo",
+        "dank",
+        "goed"
+      ]
+    };
+    LANGUAGE_POLICY_MODULE_TYPE = "language-policy";
+  }
+});
+
 // packages/core/dist/skills/index.js
 var skills_exports = {};
 __export(skills_exports, {
@@ -18408,14 +18812,19 @@ __export(skills_exports, {
   ALL_TOOLS: () => ALL_TOOLS,
   CODING_CATEGORY: () => CODING_CATEGORY,
   CODING_SKILL_CATALOG: () => CODING_SKILL_CATALOG,
+  LANGUAGE_POLICY_MODULE_TYPE: () => LANGUAGE_POLICY_MODULE_TYPE,
   SINGLE_AGENT_IDENTITY_MODULE: () => SINGLE_AGENT_IDENTITY_MODULE,
   SKILL_CATALOG: () => SKILL_CATALOG,
   TOOL_DEFINITIONS: () => TOOL_DEFINITIONS,
   VAULT_TOOL_DEFINITIONS: () => VAULT_TOOL_DEFINITIONS,
   buildCustomParameters: () => buildCustomParameters,
+  buildLanguageDirective: () => buildLanguageDirective,
+  buildLanguagePolicyModule: () => buildLanguagePolicyModule,
+  buildLanguagePolicyModuleFor: () => buildLanguagePolicyModuleFor,
   buildSystemPrompt: () => buildSystemPrompt,
   clearCustomTools: () => clearCustomTools,
   cliToolToEnhanced: () => cliToolToEnhanced,
+  detectResponseLanguage: () => detectResponseLanguage,
   executeTool: () => executeTool,
   findCodingSkillsByCategory: () => findCodingSkillsByCategory,
   findCodingSkillsByTag: () => findCodingSkillsByTag,
@@ -18436,6 +18845,7 @@ __export(skills_exports, {
   registerCustomTool: () => registerCustomTool,
   registerSkill: () => registerSkill,
   resolveAgentSkills: () => resolveAgentSkills,
+  resolveResponseLanguage: () => resolveResponseLanguage,
   resolveSkillDependencies: () => resolveSkillDependencies,
   setWorkspaceStubs: () => setWorkspaceStubs,
   unregisterCustomTool: () => unregisterCustomTool,
@@ -18453,6 +18863,7 @@ var init_skills2 = __esm({
     init_harnessToolBridge();
     init_promptModules();
     init_systemPromptBuilder();
+    init_languagePolicy();
   }
 });
 
@@ -23438,6 +23849,17 @@ async function* runCouncilPure(userMessage, config2, callbacks = {}) {
   const sessionId = config2.sessionId ?? crypto.randomUUID();
   const runMode = config2.runMode ?? "implementation";
   const isDesignPhase = runMode === "design-phase";
+  let councilLanguageModule;
+  try {
+    councilLanguageModule = buildLanguagePolicyModuleFor(userMessage);
+  } catch {
+    councilLanguageModule = {
+      type: "language-policy",
+      title: "Response Language",
+      priority: 5,
+      content: "# Response Language\nReply in the user's language when possible, otherwise Italian."
+    };
+  }
   yield createBrainEvent("council_mode", sessionId, {
     tier: councilTierFromSize(config2.councilSize),
     councilSize: config2.councilSize,
@@ -23561,7 +23983,8 @@ async function* runCouncilPure(userMessage, config2, callbacks = {}) {
         effectiveModel,
         onToolCall: () => {
           toolCalls += 1;
-        }
+        },
+        languageModule: councilLanguageModule
       });
     } else if (isDesignPhase) {
       enforceDesignPhaseToolEmissions(agent.id, emittedToolNames);
@@ -23699,7 +24122,8 @@ async function* runCouncilPure(userMessage, config2, callbacks = {}) {
         effectiveModel,
         onToolCall: () => {
           toolCalls += 1;
-        }
+        },
+        languageModule: councilLanguageModule
       });
     } else if (isDesignPhase) {
       enforceDesignPhaseToolEmissions(oracle.id, emittedToolNames);
@@ -23867,7 +24291,8 @@ async function* runCouncilPure(userMessage, config2, callbacks = {}) {
         effectiveModel,
         onToolCall: () => {
           toolCalls += 1;
-        }
+        },
+        languageModule: councilLanguageModule
       });
     } else if (isDesignPhase) {
       enforceDesignPhaseToolEmissions(chairman.id, emittedToolNames);
@@ -23927,7 +24352,8 @@ async function* runCouncilPure(userMessage, config2, callbacks = {}) {
             onSuccessfulWrite: () => {
               successfulWriteCount += 1;
             },
-            onCouncilStatus: callbacks.onCouncilStatus
+            onCouncilStatus: callbacks.onCouncilStatus,
+            languageModule: councilLanguageModule
           });
         }
       }
@@ -23946,7 +24372,8 @@ async function* runCouncilPure(userMessage, config2, callbacks = {}) {
           effectiveModel,
           onToolCall: () => {
             toolCalls += 1;
-          }
+          },
+          languageModule: councilLanguageModule
         });
       }
       if (chairmanProjectRoot) {
@@ -23964,7 +24391,8 @@ async function* runCouncilPure(userMessage, config2, callbacks = {}) {
           onToolCall: () => {
             toolCalls += 1;
           },
-          onCouncilStatus: callbacks.onCouncilStatus
+          onCouncilStatus: callbacks.onCouncilStatus,
+          languageModule: councilLanguageModule
         });
       }
     }
@@ -24030,7 +24458,8 @@ async function* applyCompletionRetry(args) {
       toolRegistry: args.config.tools,
       providerStream: args.config.providerStream,
       runMode: args.config.runMode,
-      retryPrompt: buildImplementationVerifyRetryPrompt(retryTool)
+      retryPrompt: buildImplementationVerifyRetryPrompt(retryTool),
+      languageModule: args.languageModule
     });
     for await (const event of retryGenerator) {
       if (event.type === "tool_execution_start") {
@@ -24088,7 +24517,8 @@ async function* applyImplementationWriteRetry(args) {
       toolRegistry: args.config.tools,
       providerStream: args.config.providerStream,
       runMode: "implementation",
-      retryPrompt: buildImplementationWriteRetryPrompt(args.userMessage)
+      retryPrompt: buildImplementationWriteRetryPrompt(args.userMessage),
+      languageModule: args.languageModule
     });
     for await (const event of retryGenerator) {
       if (event.type === "tool_execution_start")
@@ -24157,7 +24587,8 @@ async function* runChairmanDeliveryLoop(args) {
         toolRegistry: args.config.tools,
         providerStream: args.config.providerStream,
         runMode: "implementation",
-        retryPrompt: buildDeliveryFixPrompt(blocking, args.userMessage)
+        retryPrompt: buildDeliveryFixPrompt(blocking, args.userMessage),
+        languageModule: args.languageModule
       });
       for await (const event of fixGenerator) {
         if (event.type === "tool_execution_start")
@@ -24255,7 +24686,8 @@ async function* runChairmanFixLoop(args) {
         toolRegistry: args.config.tools,
         providerStream: args.config.providerStream,
         runMode: "implementation",
-        retryPrompt: buildMotionFixPrompt(current)
+        retryPrompt: buildMotionFixPrompt(current),
+        languageModule: args.languageModule
       });
       for await (const event of fixGenerator) {
         if (event.type === "tool_execution_start")
@@ -24400,7 +24832,8 @@ async function* applyRetryIfMissing(args) {
       eventBus: args.config.eventBus,
       toolRegistry: args.config.tools,
       providerStream: args.config.providerStream,
-      runMode: args.config.runMode
+      runMode: args.config.runMode,
+      languageModule: args.languageModule
     });
     for await (const event of retryGenerator) {
       if (event.type === "tool_execution_start") {
@@ -24422,6 +24855,7 @@ var init_councilApi = __esm({
     init_toolSchemas();
     init_systemPromptBuilder();
     init_tools();
+    init_languagePolicy();
     init_events();
     init_AgentHarness();
     init_modeBanners();
@@ -25820,7 +26254,7 @@ import {
   readdirSync as readdirSync2,
   renameSync as renameSync2
 } from "node:fs";
-import { dirname, join as join13 } from "node:path";
+import { dirname as dirname2, join as join13 } from "node:path";
 function parseFrontmatter(md) {
   const m = FRONTMATTER_RE.exec(md);
   if (!m) return { meta: {}, body: md };
@@ -26091,7 +26525,7 @@ var init_storage = __esm({
        * The meta object is serialized as YAML frontmatter; body as Markdown.
        */
       write(path34, meta3, body) {
-        mkdirSync7(dirname(path34), { recursive: true });
+        mkdirSync7(dirname2(path34), { recursive: true });
         const tmp = path34 + ".tmp-" + process.pid;
         const md = serializeFrontmatter(meta3, body);
         writeFileSync11(tmp, md, "utf8");
@@ -26146,7 +26580,7 @@ import {
   mkdirSync as mkdirSync8,
   renameSync as renameSync3
 } from "node:fs";
-import { join as join14, basename as basename2, dirname as dirname2, relative as relative2 } from "node:path";
+import { join as join14, basename as basename2, dirname as dirname3, relative as relative2 } from "node:path";
 function createWorkspaceContext(projectRoot = process.cwd()) {
   const rootDir = resolveWorkspaceRoot(projectRoot);
   return {
@@ -26185,7 +26619,7 @@ function readPlan(ctx) {
 }
 function writePlan(ctx, summary) {
   const jsonPath = planJsonPath(ctx);
-  mkdirSync8(dirname2(jsonPath), { recursive: true });
+  mkdirSync8(dirname3(jsonPath), { recursive: true });
   const tmp = jsonPath + ".tmp-" + process.pid;
   writeFileSync12(tmp, JSON.stringify(summary, null, 2), "utf8");
   renameSync3(tmp, jsonPath);
@@ -28764,29 +29198,47 @@ __export(prereqChecks_exports, {
   checkAgentGit: () => checkAgentGit,
   checkAgentNode: () => checkAgentNode,
   checkMainNode: () => checkMainNode,
+  isWslBashPath: () => isWslBashPath2,
   runPrereqChecks: () => runPrereqChecks
 });
 import { execSync, spawnSync as spawnSync2 } from "node:child_process";
 import { existsSync as existsSync25 } from "node:fs";
+import { dirname as dirname4 } from "node:path";
+function isWslBashPath2(p3) {
+  if (!p3 || typeof p3 !== "string") return false;
+  const n = p3.replace(/\//g, "\\").toLowerCase();
+  if (n.includes("\\windows\\system32\\bash.exe")) return true;
+  if (n.includes("\\windows\\syswow64\\bash.exe")) return true;
+  if (n.includes("\\windowsapps\\bash.exe")) return true;
+  return false;
+}
+function acceptBashPath2(p3) {
+  if (!p3 || p3.trim().length === 0) return null;
+  const trimmed = p3.trim();
+  if (isWslBashPath2(trimmed)) return null;
+  if (!existsSyncSafe2(trimmed)) return null;
+  return trimmed;
+}
 function resolveAgentShellSync() {
   if (process.platform !== "win32") {
     return { bashPath: null, isBash: true, via: "/bin/sh" };
   }
-  const envShell = process.env.ZELARI_SHELL;
-  if (envShell && envShell.trim().length > 0 && existsSyncSafe2(envShell)) {
-    return { bashPath: envShell, isBash: true, via: `bash (${envShell})` };
+  const fromEnv = acceptBashPath2(process.env.ZELARI_SHELL);
+  if (fromEnv) {
+    return { bashPath: fromEnv, isBash: true, via: `bash (${fromEnv})` };
   }
-  const sessionShell = process.env.SHELL;
-  if (sessionShell && sessionShell.trim().length > 0 && existsSyncSafe2(sessionShell)) {
+  const fromSession = acceptBashPath2(process.env.SHELL);
+  if (fromSession) {
     return {
-      bashPath: sessionShell,
+      bashPath: fromSession,
       isBash: true,
-      via: `bash (${sessionShell})`
+      via: `bash (${fromSession})`
     };
   }
   for (const p3 of STANDARD_BASH_PATHS2) {
-    if (existsSyncSafe2(p3)) {
-      return { bashPath: p3, isBash: true, via: `bash (${p3})` };
+    const accepted = acceptBashPath2(p3);
+    if (accepted) {
+      return { bashPath: accepted, isBash: true, via: `bash (${accepted})` };
     }
   }
   try {
@@ -28795,16 +29247,39 @@ function resolveAgentShellSync() {
       windowsHide: true
     });
     if (result.status === 0 && result.stdout) {
-      const first = result.stdout.split(/\r?\n/).find((l) => l.trim().length > 0);
-      if (first && existsSyncSafe2(first)) {
-        const trimmed = first.trim();
-        return { bashPath: trimmed, isBash: true, via: `bash (${trimmed})` };
+      for (const line of result.stdout.split(/\r?\n/)) {
+        const accepted = acceptBashPath2(line);
+        if (accepted) {
+          return {
+            bashPath: accepted,
+            isBash: true,
+            via: `bash (${accepted})`
+          };
+        }
       }
     }
   } catch {
   }
   return { bashPath: null, isBash: false, via: "cmd.exe" };
 }
+function agentProbeEnv() {
+  const env = { ...process.env };
+  try {
+    const nodeDir = dirname4(process.execPath);
+    if (!nodeDir) return env;
+    const sep = process.platform === "win32" ? ";" : ":";
+    const current = env.PATH ?? env.Path ?? "";
+    const parts = current.split(sep).filter((p3) => p3.length > 0);
+    const has = parts.some(
+      (p3) => p3.toLowerCase() === nodeDir.toLowerCase()
+    );
+    if (!has) {
+      env.PATH = `${nodeDir}${sep}${current}`;
+    }
+  } catch {
+  }
+  return env;
+}
 function existsSyncSafe2(p3) {
   try {
     return existsSync25(p3);
@@ -28815,12 +29290,14 @@ function existsSyncSafe2(p3) {
 function probeTool(tool) {
   const shell = resolveAgentShellSync();
   let stdout = "";
+  const env = agentProbeEnv();
   if (shell.bashPath) {
     try {
       const r = spawnSync2(shell.bashPath, ["-c", `${tool} --version`], {
         encoding: "utf8",
         stdio: ["ignore", "pipe", "ignore"],
-        windowsHide: true
+        windowsHide: true,
+        env
       });
       if (r.status === 0) stdout = (r.stdout || "").trim();
     } catch {
@@ -28829,7 +29306,8 @@ function probeTool(tool) {
     try {
       stdout = execSync(`${tool} --version`, {
         encoding: "utf8",
-        stdio: ["ignore", "pipe", "ignore"]
+        stdio: ["ignore", "pipe", "ignore"],
+        env
       }).trim();
     } catch {
     }
@@ -28837,7 +29315,8 @@ function probeTool(tool) {
     try {
       stdout = execSync(`${tool} --version`, {
         encoding: "utf8",
-        stdio: ["ignore", "pipe", "ignore"]
+        stdio: ["ignore", "pipe", "ignore"],
+        env
       }).trim();
     } catch {
     }
@@ -28852,14 +29331,21 @@ function probeTool(tool) {
 function nodeMissingHint() {
   const shell = resolveAgentShellSync();
   if (process.platform === "win32") {
+    if (!shell.isBash) {
+      return `node is not reachable from the agent's shell (${shell.via}).
+         Install Node >= ${MIN_NODE_MAJOR} (https://nodejs.org) and ensure it is
+         on PATH, then open a NEW terminal. Optional: install Git for
+         Windows so the agent can use real bash (https://git-scm.com/download/win).`;
+    }
     return `node is not reachable from the agent's shell (${shell.via}).
          This usually means Node was installed for "current user" only,
-         while Git Bash inherits the SYSTEM Path. Fix (pick one):
+         while Git Bash sees a different Path. Fix (pick one):
            - Reinstall Node (https://nodejs.org) and choose
              "Add to PATH for all users", OR
-           - Add C:\\Program Files\\nodejs\\ to the SYSTEM Path
-             (System Properties \u2192 Environment Variables \u2192 Path), OR
-           - Set ZELARI_SHELL to a bash that already sees node.`;
+           - Add your nodejs folder to the User or System Path, OR
+           - Set ZELARI_SHELL to a bash that already sees node.
+         Note: WSL's C:\\Windows\\System32\\bash.exe is NOT a valid agent
+         shell \u2014 install Git for Windows instead.`;
   }
   return `node is not on the agent's shell PATH.
          Install Node >= ${MIN_NODE_MAJOR} (https://nodejs.org) or, if you use
@@ -33163,12 +33649,32 @@ function finalizeStreamingAssistant(setMessages) {
   });
 }
 
+// src/cli/utils/envNumber.ts
+function envNumber(raw, opts) {
+  const { default: def, min, max } = opts;
+  if (raw === void 0 || raw === null) return def;
+  const trimmed = raw.trim();
+  if (trimmed.length === 0) return def;
+  if (trimmed.toLowerCase() === "undefined" || trimmed.toLowerCase() === "null") return def;
+  const parsed = Number.parseInt(trimmed, 10);
+  if (!Number.isFinite(parsed)) return def;
+  const absStr = `${Math.abs(parsed)}`;
+  const body = trimmed.replace(/^[-+]/, "").replace(/^0+(?=\d)/, "");
+  if (body !== absStr) return def;
+  const firstChar = trimmed[0];
+  const expectedSign = parsed < 0 ? "-" : /[0-9+]/.test(firstChar ?? "");
+  const actualSign = parsed < 0 ? firstChar === "-" : firstChar !== "-";
+  if (!expectedSign || !actualSign) return def;
+  let clamped = parsed;
+  if (min !== void 0 && clamped < min) clamped = min;
+  if (max !== void 0 && clamped > max) clamped = max;
+  return clamped;
+}
+
 // src/cli/hooks/historyCompaction.ts
 var COMPACT_MARKER = "[history] Earlier turns were compacted to stay within the context budget.";
 function resolveMaxMessages(opts) {
-  const raw = process.env.ZELARI_HISTORY_TURNS;
-  const parsed = raw ? Number.parseInt(raw, 10) : 6;
-  const envTurns = Number.isFinite(parsed) && parsed >= 0 ? parsed : 6;
+  const envTurns = envNumber(process.env.ZELARI_HISTORY_TURNS, { default: 6, min: 0 });
   const turns = opts?.maxMessages ? Math.ceil(opts.maxMessages / 4) : envTurns;
   if (turns <= 0) return 0;
   return turns * 4;
@@ -33379,21 +33885,24 @@ function useChatTurn(params) {
         const workspaceContext = [workspaceSummary, zelariReadHint].filter(Boolean).join("\n\n");
         let systemPrompt;
         try {
+          const languageModule = buildLanguagePolicyModuleFor(userText);
           systemPrompt = buildSystemPrompt(singleAgentRole, {
             tools: getAllTools(),
             toolNames: toolListNames,
             aiConfig: {
               enabledSkills: [],
               enabledTools: toolListNames,
-              customPromptModules: [SINGLE_AGENT_IDENTITY_MODULE],
+              customPromptModules: [SINGLE_AGENT_IDENTITY_MODULE, languageModule],
               agentSkillConfigs: []
             },
             workspaceContext: workspaceContext || void 0,
             ragContext: planSummary || void 0
           });
         } catch {
+          const languageModule = buildLanguagePolicyModuleFor(userText);
           systemPrompt = [
             SINGLE_AGENT_IDENTITY_MODULE.content,
+            languageModule.content,
             shellContextBlock,
             "# Available Tools",
             "You can call these tools. Use them to take action and gather information autonomously:",
@@ -33402,16 +33911,14 @@ function useChatTurn(params) {
             ...planSummary ? ["", planSummary] : []
           ].join("\n");
         }
-        const maxToolCallsPerTurn = (() => {
-          const raw = process.env.ZELARI_MAX_TOOL_CALLS;
-          const n = raw ? Number.parseInt(raw, 10) : 25;
-          return Number.isFinite(n) && n > 0 ? n : 25;
-        })();
-        const maxToolLoopIterations = (() => {
-          const raw = process.env.ZELARI_MAX_TOOL_LOOP_ITERATIONS;
-          const n = raw ? Number.parseInt(raw, 10) : 90;
-          return Number.isFinite(n) && n > 0 ? n : 90;
-        })();
+        const maxToolCallsPerTurn = envNumber(process.env.ZELARI_MAX_TOOL_CALLS, {
+          default: 25,
+          min: 1
+        });
+        const maxToolLoopIterations = envNumber(process.env.ZELARI_MAX_TOOL_LOOP_ITERATIONS, {
+          default: 90,
+          min: 1
+        });
         const harness2 = new AgentHarness({
           model: envConfig.model,
           provider: "openai-compatible",
@@ -33748,11 +34255,10 @@ async function dispatchCouncilPromptImpl(text, deps, overrides = {}) {
   const councilFeedbackStore = new FeedbackStore2();
   let streamContent = "";
   let streamMemberId = null;
-  const councilMaxToolCalls = (() => {
-    const raw = process.env.ZELARI_MAX_TOOL_CALLS;
-    const n = raw ? Number.parseInt(raw, 10) : 15;
-    return Number.isFinite(n) && n > 0 ? n : 15;
-  })();
+  const councilMaxToolCalls = envNumber(process.env.ZELARI_MAX_TOOL_CALLS, {
+    default: 15,
+    min: 1
+  });
   let membersCompleted = 0;
   let chairmanProducedOutput = false;
   let chairmanSynthesisText = "";
@@ -34129,11 +34635,10 @@ async function runZelariMissionInTui(userMessage, deps, emit) {
     hasPlan: hasWorkspacePlan2(projectRoot)
   });
   const memory = await getMemoryBackend2(projectRoot);
-  const chairmanBudget = (() => {
-    const raw = process.env.ZELARI_MODE_MAX_TOOLS_LUCIFER;
-    const n = raw ? Number.parseInt(raw, 10) : 30;
-    return Number.isFinite(n) && n > 0 ? n : 30;
-  })();
+  const chairmanBudget = envNumber(process.env.ZELARI_MODE_MAX_TOOLS_LUCIFER, {
+    default: 30,
+    min: 1
+  });
   try {
     await runZelariMission2(userMessage, brief, {
       projectRoot,
@@ -37295,6 +37800,7 @@ function emitEvent(event) {
 // src/cli/runHeadless.ts
 init_harness();
 init_toolRegistry();
+init_skills2();
 async function runHeadless(opts) {
   const { provider, model } = resolveHeadlessProvider(opts);
   const key = await resolveHeadlessKey(provider);
@@ -37322,11 +37828,61 @@ async function runHeadlessSingle(opts, provider, model, providerStream) {
     description: t.function.description,
     parameters: t.function.parameters
   }));
-  const systemPrompt = [
-    "You are zelari-code, a CLI coding agent. Be concise and direct.",
-    "When the user asks you to write code, debug, or explore, be proactive: list files and read key files to understand the project.",
-    "When you finish a task, briefly summarize what you did."
-  ].join("\n");
+  const toolNames = tools.map((t) => t.name);
+  let systemPrompt;
+  let languageDirectiveContent;
+  try {
+    languageDirectiveContent = buildLanguagePolicyModuleFor(opts.task).content;
+  } catch {
+    languageDirectiveContent = "# Response Language\nReply in the user's language when possible, otherwise Italian.";
+  }
+  try {
+    const headlessRole = {
+      id: "single",
+      name: "Zelari Code",
+      codename: "zelari",
+      role: "headless coding agent",
+      color: "#00d9a3",
+      avatar: "\u25C6",
+      tools: toolNames,
+      // v1.7.0 fix (agy audit): include platform/shell context in the role
+      // prompt so the agent knows its cwd and shell — previously this was
+      // empty (systemPrompt: '') and the agent lacked the platform block
+      // the TUI single-agent path gets.
+      systemPrompt: [
+        "# Platform",
+        `platform: ${process.platform}`,
+        `shell: ${process.platform === "win32" ? "cmd.exe / Git Bash (auto-detected)" : "/bin/sh"}`,
+        "",
+        "# Working Directory",
+        `You are running in: ${process.cwd()}`,
+        "All relative file paths are resolved against this directory.",
+        "The shell is NON-INTERACTIVE (stdin closed): pass non-interactive flags (--yes, --force, --template)."
+      ].join("\n")
+    };
+    systemPrompt = buildSystemPrompt(headlessRole, {
+      tools: getAllTools(),
+      toolNames,
+      aiConfig: {
+        enabledSkills: [],
+        enabledTools: toolNames,
+        customPromptModules: [SINGLE_AGENT_IDENTITY_MODULE, {
+          type: "language-policy",
+          title: "Response Language",
+          priority: 5,
+          content: languageDirectiveContent
+        }],
+        agentSkillConfigs: []
+      }
+    });
+  } catch {
+    systemPrompt = [
+      "You are zelari-code, a CLI coding agent. Be concise and direct.",
+      "When the user asks you to write code, debug, or explore, be proactive: list files and read key files to understand the project.",
+      "When you finish a task, briefly summarize what you did.",
+      languageDirectiveContent
+    ].join("\n");
+  }
   const harness = new AgentHarness({
     model,
     provider,
@@ -37339,9 +37895,8 @@ async function runHeadlessSingle(opts, provider, model, providerStream) {
     toolRegistry,
     providerStream,
     maxToolLoopIterations: (() => {
-      const raw = process.env.ZELARI_MAX_TOOL_LOOP_ITERATIONS;
-      const n = raw ? Number.parseInt(raw, 10) : 30;
-      return Number.isFinite(n) && n > 0 ? n : 30;
+      const n = envNumber(process.env.ZELARI_MAX_TOOL_LOOP_ITERATIONS, { default: 30, min: 1 });
+      return n;
     })()
   });
   let finalReason = "completed";