zelari-code 1.5.5 → 1.6.0

package/dist/cli/main.bundled.js

@@ -18592,13 +18592,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 {
@@ -33050,6 +33070,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 +33163,61 @@ function finalizeStreamingAssistant(setMessages) {
   });
 }
 
+// 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 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 +33243,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();
@@ -33328,6 +33417,10 @@ function useChatTurn(params) {
           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 +33551,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);
@@ -36404,7 +36540,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 +36585,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), []);