zelari-code 1.5.5 → 1.7.0

package/dist/cli/main.bundled.js

@@ -18401,6 +18401,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 +18768,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 +18801,7 @@ __export(skills_exports, {
   registerCustomTool: () => registerCustomTool,
   registerSkill: () => registerSkill,
   resolveAgentSkills: () => resolveAgentSkills,
+  resolveResponseLanguage: () => resolveResponseLanguage,
   resolveSkillDependencies: () => resolveSkillDependencies,
   setWorkspaceStubs: () => setWorkspaceStubs,
   unregisterCustomTool: () => unregisterCustomTool,
@@ -18453,6 +18819,7 @@ var init_skills2 = __esm({
     init_harnessToolBridge();
     init_promptModules();
     init_systemPromptBuilder();
+    init_languagePolicy();
   }
 });
 
@@ -18592,13 +18959,33 @@ var init_AgentHarness = __esm({
         this.maxQueuedIterations = config2.maxQueuedIterations ?? 3;
         this.maxToolLoopIterations = config2.maxToolLoopIterations ?? 30;
       }
+      /**
+       * Snapshot of the live transcript (`this.config.messages`) as mutated
+       * across `run()` iterations — the seed passed at construction plus any
+       * assistant turns (with `toolCalls`) and tool results the loop appended.
+       *
+       * Used by the single-agent chat loop to carry rolling history across
+       * turns: after a run completes, the caller reads the tail of this array
+       * (the assistant/tool messages produced this turn) and feeds it back as
+       * the seed for the next turn, so the model sees its own prior question
+       * when the user answers with a short reply.
+       *
+       * The returned reference is the live array — callers MUST treat it as
+       * read-only (do not mutate). Copy (`[...harness.getMessages()]`) before
+       * retaining across runs.
+       *
+       * @since v1.6.0
+       */
+      getMessages() {
+        return this.config.messages;
+      }
       /**
        * Member identity fields (memberId + memberName) to merge into every
        * event payload. Returns an empty object when the run is a direct
        * user prompt (no member context), so call sites can spread it
        * unconditionally.
        *
-       * @since 0.5.0
+       * @since v0.5.0
        */
       memberFields() {
         return {
@@ -23418,6 +23805,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,
@@ -23541,7 +23939,8 @@ async function* runCouncilPure(userMessage, config2, callbacks = {}) {
         effectiveModel,
         onToolCall: () => {
           toolCalls += 1;
-        }
+        },
+        languageModule: councilLanguageModule
       });
     } else if (isDesignPhase) {
       enforceDesignPhaseToolEmissions(agent.id, emittedToolNames);
@@ -23679,7 +24078,8 @@ async function* runCouncilPure(userMessage, config2, callbacks = {}) {
         effectiveModel,
         onToolCall: () => {
           toolCalls += 1;
-        }
+        },
+        languageModule: councilLanguageModule
       });
     } else if (isDesignPhase) {
       enforceDesignPhaseToolEmissions(oracle.id, emittedToolNames);
@@ -23847,7 +24247,8 @@ async function* runCouncilPure(userMessage, config2, callbacks = {}) {
         effectiveModel,
         onToolCall: () => {
           toolCalls += 1;
-        }
+        },
+        languageModule: councilLanguageModule
       });
     } else if (isDesignPhase) {
       enforceDesignPhaseToolEmissions(chairman.id, emittedToolNames);
@@ -23907,7 +24308,8 @@ async function* runCouncilPure(userMessage, config2, callbacks = {}) {
             onSuccessfulWrite: () => {
               successfulWriteCount += 1;
             },
-            onCouncilStatus: callbacks.onCouncilStatus
+            onCouncilStatus: callbacks.onCouncilStatus,
+            languageModule: councilLanguageModule
           });
         }
       }
@@ -23926,7 +24328,8 @@ async function* runCouncilPure(userMessage, config2, callbacks = {}) {
           effectiveModel,
           onToolCall: () => {
             toolCalls += 1;
-          }
+          },
+          languageModule: councilLanguageModule
         });
       }
       if (chairmanProjectRoot) {
@@ -23944,7 +24347,8 @@ async function* runCouncilPure(userMessage, config2, callbacks = {}) {
           onToolCall: () => {
             toolCalls += 1;
           },
-          onCouncilStatus: callbacks.onCouncilStatus
+          onCouncilStatus: callbacks.onCouncilStatus,
+          languageModule: councilLanguageModule
         });
       }
     }
@@ -24010,7 +24414,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") {
@@ -24068,7 +24473,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")
@@ -24137,7 +24543,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")
@@ -24235,7 +24642,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")
@@ -24380,7 +24788,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") {
@@ -24402,6 +24811,7 @@ var init_councilApi = __esm({
     init_toolSchemas();
     init_systemPromptBuilder();
     init_tools();
+    init_languagePolicy();
     init_events();
     init_AgentHarness();
     init_modeBanners();
@@ -33050,6 +33460,14 @@ init_keyStore();
 init_toolRegistry();
 init_skills2();
 
+// packages/core/dist/events/index.js
+init_events();
+
+// packages/core/dist/index.js
+init_harness();
+init_council();
+init_skills2();
+
 // src/cli/hooks/messageHelpers.ts
 function appendSystem(setMessages, content, ts = Date.now()) {
   setMessages((prev2) => [
@@ -33135,6 +33553,81 @@ 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 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;
+}
+function findValidCutIndex(messages, naiveCut) {
+  let cut = naiveCut;
+  while (cut < messages.length) {
+    const kept = messages.slice(cut);
+    const declared = /* @__PURE__ */ new Set();
+    for (const m of kept) {
+      if (m.role === "assistant" && m.toolCalls) {
+        for (const tc of m.toolCalls) declared.add(tc.id);
+      }
+    }
+    let moved = false;
+    for (let k = 0; k < kept.length; k++) {
+      const m = kept[k];
+      if (m.role === "tool" && m.toolCallId && !declared.has(m.toolCallId)) {
+        for (let j = cut - 1; j >= 0; j--) {
+          const prev2 = messages[j];
+          if (prev2.role === "assistant" && prev2.toolCalls && prev2.toolCalls.some((tc) => tc.id === m.toolCallId)) {
+            cut = j;
+            moved = true;
+            break;
+          }
+        }
+        break;
+      }
+    }
+    if (!moved) break;
+  }
+  return cut;
+}
+function compactHistory(messages, opts) {
+  const maxMessages = resolveMaxMessages(opts);
+  if (maxMessages === 0) return [];
+  if (messages.length <= maxMessages * 2) return messages;
+  const naiveCut = messages.length - maxMessages;
+  const cut = findValidCutIndex(messages, naiveCut);
+  const dropped = cut;
+  if (dropped === 0) return messages;
+  const kept = messages.slice(cut);
+  const summary = {
+    role: "system",
+    content: `${COMPACT_MARKER} ${dropped} earlier message(s) dropped.`
+  };
+  return [summary, ...kept];
+}
+
 // src/cli/hooks/chatStats.ts
 function computeSessionStatsDelta(realUsage, userText, assistantContent, model, prev2) {
   const promptTokens = realUsage ? realUsage.promptTokens : Math.ceil(userText.length / 4);
@@ -33160,16 +33653,22 @@ function useChatTurn(params) {
     setSessionActive,
     setSessionStats,
     setLive,
-    liveRef
+    liveRef,
+    setPicker
   } = params;
   const harnessRef = useRef4(null);
   const [queueCount, setQueueCount] = useState6(0);
+  const historyRef = useRef4([]);
   const useLiveModel = !!(setLive && liveRef);
   const dispatchPrompt = useCallback2(
     async (userText, opts) => {
       let envConfig;
       let harness;
+      let historySeedLen = 0;
+      let turnSucceeded = false;
       try {
+        historyRef.current = compactHistory(historyRef.current);
+        historySeedLen = historyRef.current.length;
         envConfig = await providerFromEnv();
         if (!envConfig) {
           const active = resolveActiveProvider();
@@ -33290,21 +33789,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:",
@@ -33313,21 +33815,23 @@ 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",
           messages: [
             { role: "system", content: systemPrompt },
+            // v1.6.0: seed prior turns so the model sees its own last
+            // question when the user answers briefly. historyRef.current
+            // is compacted above (possibly empty if ZELARI_HISTORY_TURNS=0).
+            ...historyRef.current,
             { role: "user", content: userText }
           ],
           tools: toolRegistry.toOpenAITools().map((t) => ({
@@ -33458,10 +33962,53 @@ function useChatTurn(params) {
               }
             }
           }
+          turnSucceeded = true;
         } finally {
           flushStreaming();
           if (useLiveModel) finalizeStreaming(setMessages, setLive);
           else finalizeStreamingAssistant(setMessages);
+          try {
+            const h = harnessRef.current;
+            if (h && turnSucceeded) {
+              const all = h.getMessages();
+              const seedLen = 1 + historySeedLen + 1;
+              if (all.length > seedLen) {
+                historyRef.current = historyRef.current.concat(
+                  all.slice(seedLen)
+                );
+              }
+            }
+          } catch {
+          }
+          if (turnSucceeded && setPicker && assistantContent) {
+            try {
+              const clar = parseClarificationRequest(assistantContent);
+              if (clar && clar.choices && clar.choices.length >= 2) {
+                const cleaned = cleanAgentContent(assistantContent);
+                if (cleaned !== assistantContent) {
+                  setMessages((prev2) => {
+                    const next = [...prev2];
+                    for (let i = next.length - 1; i >= 0; i--) {
+                      if (next[i].role === "assistant") {
+                        next[i] = { ...next[i], content: cleaned };
+                        break;
+                      }
+                    }
+                    return next;
+                  });
+                }
+                setPicker({
+                  kind: "clarification",
+                  title: clar.question,
+                  items: clar.choices.map((c) => ({ value: c, label: c })),
+                  onAnswer: (value) => {
+                    void dispatchPrompt(value);
+                  }
+                });
+              }
+            } catch {
+            }
+          }
           harnessRef.current = null;
           setQueueCount(0);
           setBusy(false);
@@ -33612,11 +34159,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 = "";
@@ -33993,11 +34539,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,
@@ -36404,7 +36949,11 @@ function App() {
     setSessionActive: session.setSessionActive,
     setSessionStats,
     setLive: session.setLive,
-    liveRef: session.liveRef
+    liveRef: session.liveRef,
+    // v1.6.0: lets dispatchPrompt open a SelectList when the agent poses a
+    // ---QUESTION--- clarifying block, so the user picks from the offered
+    // choices instead of typing (and the answer binds via rolling history).
+    setPicker
   });
   const onNewSession = useCallback5((id) => {
     void session.writerRef.current?.close();
@@ -36445,8 +36994,12 @@ function App() {
   });
   const onPickerSelect = useCallback5((value) => {
     if (!picker) return;
-    const cmd = `${picker.commandPrefix} ${value}`;
     setPicker(null);
+    if (picker.kind === "clarification") {
+      picker.onAnswer?.(value);
+      return;
+    }
+    const cmd = `${picker.commandPrefix} ${value}`;
     void handleSubmit(cmd);
   }, [picker, handleSubmit]);
   const onPickerCancel = useCallback5(() => setPicker(null), []);
@@ -37151,6 +37704,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);
@@ -37178,11 +37732,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,
@@ -37195,9 +37799,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";