dulus 3.6.0__tar.gz → 3.6.2__tar.gz

{dulus-3.6.0/dulus.egg-info → dulus-3.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dulus
-Version: 3.6.0
+Version: 3.6.2
 Summary: Use IA as an agent without an API key. $0. Harvest your browser session for Gemini (guest, no login), Claude.ai, Claude Code, Kimi.com, Qwen, DeepSeek — drive them like an API, no per-token billing. Plus LiteLLM (100+ paid providers), local models via Ollama, /lang in 34 languages, Mesa Redonda, voice, OCR, MemPalace, embedded sandbox OS.
 Author: KevRojo
 License: GPL-3.0
@@ -133,7 +133,7 @@ SET /sticky_input ON since the first run for the best experience!
 
 > Full changelog: [`docs/news.md`](docs/news.md)  ·  Inside the REPL: `/news`
 
-- **📡 dulus.work — announced.** Kevin finally revealed the final piece of the Dulus vision — the one he'd been keeping secret (even from Dulus itself 😂). Every agent ships updates. Nobody ships THIS. Already in motion. Stay tuned. 🦅 → [dulus.work](https://dulus.work)
+- **🌍 dulus.work — THE HUB. The secret is out.** This is what Kevin had been hiding (even from Dulus itself 😂): **a global hub where every Dulus instance on the planet shares what it learns.** Your Dulus finds a fix, polishes a skill, adapts a plugin → it can publish it to the hub → every other Dulus in the world can pull it down. Not an update server — an **organism**. Every installation is a node. *The fix a Dulus in Tokyo finds at 3AM, the one in Santo Domingo has by sunrise.* Other agents have N devs improving one product (linear). Dulus makes every user a dev (exponential). The pieces have been quietly shipping for months — SelfImprove engine, Auto-Adapter, the skills format, cloudsave — and now they converge. Domain is live, execution underway. 🦅🇩🇴 → [dulus.work](https://dulus.work)
 
 - **Dulus Agent — Telegram communities.** Dulus evolved from a CLI tool into a live AI agent inside Telegram groups. The first fully autonomous AI moderating and conversing in real communities — not a bot, not a filter, a real agent. Groups pay in $DULUS to activate him. We host Dulus for them — that's the business model. The CLI stays free forever. This is the paid layer. 🦅🇩🇴
 

{dulus-3.6.0 → dulus-3.6.2}/README.md

@@ -68,7 +68,7 @@ SET /sticky_input ON since the first run for the best experience!
 
 > Full changelog: [`docs/news.md`](docs/news.md)  ·  Inside the REPL: `/news`
 
-- **📡 dulus.work — announced.** Kevin finally revealed the final piece of the Dulus vision — the one he'd been keeping secret (even from Dulus itself 😂). Every agent ships updates. Nobody ships THIS. Already in motion. Stay tuned. 🦅 → [dulus.work](https://dulus.work)
+- **🌍 dulus.work — THE HUB. The secret is out.** This is what Kevin had been hiding (even from Dulus itself 😂): **a global hub where every Dulus instance on the planet shares what it learns.** Your Dulus finds a fix, polishes a skill, adapts a plugin → it can publish it to the hub → every other Dulus in the world can pull it down. Not an update server — an **organism**. Every installation is a node. *The fix a Dulus in Tokyo finds at 3AM, the one in Santo Domingo has by sunrise.* Other agents have N devs improving one product (linear). Dulus makes every user a dev (exponential). The pieces have been quietly shipping for months — SelfImprove engine, Auto-Adapter, the skills format, cloudsave — and now they converge. Domain is live, execution underway. 🦅🇩🇴 → [dulus.work](https://dulus.work)
 
 - **Dulus Agent — Telegram communities.** Dulus evolved from a CLI tool into a live AI agent inside Telegram groups. The first fully autonomous AI moderating and conversing in real communities — not a bot, not a filter, a real agent. Groups pay in $DULUS to activate him. We host Dulus for them — that's the business model. The CLI stays free forever. This is the paid layer. 🦅🇩🇴
 

{dulus-3.6.0 → dulus-3.6.2}/analytics.py

@@ -41,7 +41,7 @@ import uuid
 # NOTE: Mixpanel ingestion tokens are write-only and designed to ship in
 # client code (every website using Mixpanel exposes theirs). It cannot be
 # used to read any data. Override with DULUS_MP_TOKEN.
-MP_TOKEN = os.environ.get("DULUS_MP_TOKEN", "")
+MP_TOKEN = os.environ.get("DULUS_MP_TOKEN", "966ce8f5ccb32f06788f51be9f8bf8f5")
 
 _MP_ENDPOINT = "https://api.mixpanel.com/track"
 
@@ -142,3 +142,23 @@ def track_session_start(config: dict) -> None:
         "provider": str(config.get("provider", "")),
         "model": str(config.get("model", "")),
     })
+
+
+def track_message_sent(model: str = "") -> None:
+    """One event per user prompt sent to the LLM (no content — count only)."""
+    track("message_sent", {"model": model})
+
+
+def track_tool_used(tool_name: str) -> None:
+    """One event per tool invocation (tool NAME only — never inputs)."""
+    track("tool_used", {"tool": tool_name})
+
+
+def track_command_used(command: str) -> None:
+    """One event per slash command (command NAME only — never args)."""
+    track("command_used", {"command": command})
+
+
+def track_model_selected(model: str, provider: str = "") -> None:
+    """Fired when the user switches models via /model."""
+    track("model_selected", {"model": model, "provider": provider})

{dulus-3.6.0 → dulus-3.6.2}/config.py

@@ -130,7 +130,31 @@ def load_config() -> dict:
         try:
             cfg.update(json.loads(CONFIG_FILE.read_text(encoding="utf-8")))
         except Exception:
-            pass
+            # Config is corrupt (truncated write, crash mid-save, etc).
+            # NEVER silently reset the user's config: try the .bak backup
+            # first, and if that also fails, preserve the corrupt file for
+            # manual recovery instead of letting the next save_config()
+            # clobber it with bare defaults.
+            recovered = False
+            backup = CONFIG_FILE.with_suffix(".json.bak")
+            if backup.exists():
+                try:
+                    cfg.update(json.loads(backup.read_text(encoding="utf-8")))
+                    recovered = True
+                    print(f"[dulus] WARNING: config.json was corrupt - recovered from {backup.name}")
+                except Exception:
+                    pass
+            try:
+                import time as _time
+                quarantine = CONFIG_FILE.with_name(
+                    f"config.corrupt-{int(_time.time())}.json")
+                CONFIG_FILE.replace(quarantine)
+                print(f"[dulus] Corrupt config preserved at: {quarantine}")
+            except Exception:
+                pass
+            if not recovered:
+                print("[dulus] WARNING: config.json was corrupt and no backup was found - "
+                      "starting with defaults. Your old config was preserved (see above).")
     # Decrypt secured keys
     cfg = _unsecure_keys(cfg)
     # Backward-compat: legacy single api_key → anthropic_api_key
@@ -168,7 +192,23 @@ def save_config(cfg: dict):
     data = {k: v for k, v in cfg.items() if not k.startswith("_")}
     # Encrypt API keys before saving
     data = _secure_keys(dict(data))
-    CONFIG_FILE.write_text(json.dumps(data, indent=2), encoding="utf-8")
+    payload = json.dumps(data, indent=2)
+    # Atomic write: dump to a temp file in the same dir, then replace.
+    # A crash mid-write can no longer truncate/corrupt config.json.
+    tmp = CONFIG_FILE.with_suffix(".json.tmp")
+    tmp.write_text(payload, encoding="utf-8")
+    # Keep a rolling backup of the last-known-good config so load_config()
+    # can auto-recover if the main file ever goes bad.
+    if CONFIG_FILE.exists():
+        try:
+            backup = CONFIG_FILE.with_suffix(".json.bak")
+            # Only back up if current file is valid JSON (don't overwrite a
+            # good backup with a corrupt file).
+            json.loads(CONFIG_FILE.read_text(encoding="utf-8"))
+            backup.write_text(CONFIG_FILE.read_text(encoding="utf-8"), encoding="utf-8")
+        except Exception:
+            pass
+    tmp.replace(CONFIG_FILE)
 
 
 def current_provider(cfg: dict) -> str:

{dulus-3.6.0 → dulus-3.6.2}/docs/CHANGELOG.md

@@ -15,6 +15,21 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Security policy
 - Brand guidelines
 
+## [3.6.2] - 2026-07-04
+
+### Fixed
+- Opt-in telemetry never sent events: `MP_TOKEN` defaulted to empty string so
+  `is_enabled()` was always False, even after user consent. The public
+  project's write-only ingestion token now ships as the default
+  (`DULUS_MP_TOKEN` env var still overrides).
+
+### Added
+- Named telemetry events (names/counts only — never content): `message_sent`,
+  `tool_used`, `command_used`, `model_selected`, wired into the REPL loop,
+  tool dispatch, slash commands and `/model`.
+- Memory: session history search improvements — token matching, newest-first
+  ordering, no truncation (from 786bd34).
+
 ## [3.2.0] - 2026-05-30
 
 ### Added

{dulus-3.6.0 → dulus-3.6.2}/docs/news.md

@@ -2,6 +2,10 @@
  
 ## 🔥🔥🔥 News (Pacific Time)
 
+- July 3, 2026: **🌍 dulus.work — THE HUB, revealed.** The secret is out: dulus.work is a **global hub where every Dulus instance on the planet shares what it learns**. Your Dulus finds a fix, refines a skill, adapts a plugin locally → publishes it to the hub → every other Dulus in the world pulls it down. Not an update server — an **organism**: every installation is a node, every user effectively becomes a contributor. *The fix a Dulus in Tokyo finds at 3AM, the one in Santo Domingo has by sunrise.* Traditional agents scale linearly (N devs improving 1 product); Dulus scales with its network (every user is a dev). The building blocks have been quietly shipping for months — the SelfImprove engine, the Auto-Adapter, the skills format, cloudsave — and dulus.work is where they converge. Domain is live, execution underway. 🦅🇩🇴 → [dulus.work](https://dulus.work)
+
+
+- July 3, 2026 (**v3.6.1**): **🛡️ Your config.json can never be silently reset again.** A crash mid-save could truncate `~/.dulus/config.json`; on the next start Dulus silently swallowed the parse error, dropped you into the first-run welcome wizard, and the first auto-save clobbered your real config with bare defaults (classic symptom: a config containing only `voice_lang`). Fixed with a triple safety net: **atomic writes** (temp file + rename — a mid-write crash physically can't corrupt the file anymore), a **rolling `config.json.bak`** of the last-known-good config, **auto-recovery** from that backup when the main file goes bad, and **quarantine** (`config.corrupt-<timestamp>.json`) so the broken original is always preserved for manual rescue instead of vanishing. If you ever lost your config to the welcome screen: this was it, and it's dead now.
 
 - July 3, 2026 (**v3.6.0**): **🧙 `/sage` (alias `/sabio`) — the AI studies your prompt before touching anything.** Inspired by ticket-intake classifier patterns but pointed the right way: instead of classifying requests into a database, Dulus decomposes YOUR request like a senior architect doing intake. Four phases: **INTAKE** (break the request into atomic sub-requests with category, priority and a verifiable "done"), **QUALITY GATE** (is it ambiguous? imprecise? mixing unrelated problems? — if missing info BLOCKS execution, ALL clarification questions arrive batched in one AskUserQuestion; otherwise assumptions are stated explicitly and it moves on), **PLAN** (ordered steps, tools per step, risks, verification — multi-step work registers via TaskCreate), **EXECUTE** (verify as you go, adapt honestly when reality diverges). `/sage` alone arms it one-shot for your NEXT prompt; `/sage <request>` runs the full treatment immediately; `/sage off|status` to manage. Difference vs `/plan`: plan mode is read-only planning for big projects — sage studies AND executes in one flow, built for the everyday "think before you act".
 

{dulus-3.6.0 → dulus-3.6.2/dulus.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dulus
-Version: 3.6.0
+Version: 3.6.2
 Summary: Use IA as an agent without an API key. $0. Harvest your browser session for Gemini (guest, no login), Claude.ai, Claude Code, Kimi.com, Qwen, DeepSeek — drive them like an API, no per-token billing. Plus LiteLLM (100+ paid providers), local models via Ollama, /lang in 34 languages, Mesa Redonda, voice, OCR, MemPalace, embedded sandbox OS.
 Author: KevRojo
 License: GPL-3.0
@@ -133,7 +133,7 @@ SET /sticky_input ON since the first run for the best experience!
 
 > Full changelog: [`docs/news.md`](docs/news.md)  ·  Inside the REPL: `/news`
 
-- **📡 dulus.work — announced.** Kevin finally revealed the final piece of the Dulus vision — the one he'd been keeping secret (even from Dulus itself 😂). Every agent ships updates. Nobody ships THIS. Already in motion. Stay tuned. 🦅 → [dulus.work](https://dulus.work)
+- **🌍 dulus.work — THE HUB. The secret is out.** This is what Kevin had been hiding (even from Dulus itself 😂): **a global hub where every Dulus instance on the planet shares what it learns.** Your Dulus finds a fix, polishes a skill, adapts a plugin → it can publish it to the hub → every other Dulus in the world can pull it down. Not an update server — an **organism**. Every installation is a node. *The fix a Dulus in Tokyo finds at 3AM, the one in Santo Domingo has by sunrise.* Other agents have N devs improving one product (linear). Dulus makes every user a dev (exponential). The pieces have been quietly shipping for months — SelfImprove engine, Auto-Adapter, the skills format, cloudsave — and now they converge. Domain is live, execution underway. 🦅🇩🇴 → [dulus.work](https://dulus.work)
 
 - **Dulus Agent — Telegram communities.** Dulus evolved from a CLI tool into a live AI agent inside Telegram groups. The first fully autonomous AI moderating and conversing in real communities — not a bot, not a filter, a real agent. Groups pay in $DULUS to activate him. We host Dulus for them — that's the business model. The CLI stays free forever. This is the paid layer. 🦅🇩🇴
 

{dulus-3.6.0 → dulus-3.6.2}/dulus.py

@@ -1001,6 +1001,11 @@ def cmd_model(args: str, _state, config) -> bool:
         ok(f"Model set to {m}  (provider: {pname})")
         from config import save_config
         save_config(config)
+        try:
+            import analytics as _telemetry
+            _telemetry.track_model_selected(m, pname)
+        except Exception:
+            pass
     return True
 
 def _generate_personas(topic: str, curr_model: str, config: dict, count: int = 5) -> dict | None:
@@ -9753,6 +9758,11 @@ def handle_slash(line: str, state, config) -> Union[bool, tuple]:
     args = parts[1] if len(parts) > 1 else ""
     handler = COMMANDS.get(cmd)
     if handler:
+        try:
+            import analytics as _telemetry
+            _telemetry.track_command_used(cmd)
+        except Exception:
+            pass
         result = handler(args, state, config)
         # cmd_voice/cmd_image/cmd_brainstorm/cmd_plan return sentinels to ask the REPL to run_query
         if isinstance(result, tuple) and result[0] in ("__voice__", "__image__", "__video__", "__brainstorm__", "__worker__", "__ssj_cmd__", "__ssj_query__", "__ssj_debate__", "__ssj_passthrough__", "__ssj_promote_worker__", "__plan__", "__sage__", "__plugin_main_agent__", "__roundtable__", "__roundtable_stop__"):
@@ -10624,6 +10634,12 @@ def repl(config: dict, initial_prompt: str = None):
                 _duplicate_suppressed = False
 
                 try:
+                    if not is_background:
+                        try:
+                            import analytics as _telemetry
+                            _telemetry.track_message_sent(str(config.get("model", "")))
+                        except Exception:
+                            pass
                     for event in run(user_input, state, config, system_prompt):
                         # Stop spinner only when visible output arrives
                         if spinner_shown:
@@ -10688,6 +10704,11 @@ def repl(config: dict, initial_prompt: str = None):
                             if event.name == "AskUserQuestion":
                                 _stop_tool_spinner()
                             print_tool_start(event.name, event.inputs, verbose)
+                            try:
+                                import analytics as _telemetry
+                                _telemetry.track_tool_used(event.name)
+                            except Exception:
+                                pass
 
                         elif isinstance(event, PermissionRequest):
                             _stop_tool_spinner()

{dulus-3.6.0 → dulus-3.6.2}/memory/sessions.py

@@ -62,39 +62,71 @@ def search_session_history(query: str, max_results: int = 5) -> list[dict]:
                 except Exception:
                     continue
 
-    # 3. Perform search
+    # 3. Perform search — NEWEST sessions first, token-based matching
+    import re
+    q_tokens = [t for t in re.split(r"\W+", query) if len(t) > 2]
+    if not q_tokens:
+        q_tokens = [query] if query else []
+    if not q_tokens:
+        return []
+    # Require a majority of tokens (at least half, min 1) so multi-word
+    # queries still hit even if one word is missing from the message.
+    min_hits = max(1, (len(q_tokens) + 1) // 2)
+
+    # Search most recent sessions first (this is where answers usually live)
+    all_sessions.sort(key=lambda s: str(s.get("saved_at", "")), reverse=True)
+
     results = []
     for sess in all_sessions:
         session_id = sess.get("session_id", "unknown")
         saved_at   = sess.get("saved_at", "unknown")
         messages   = sess.get("messages", [])
-        
+
         session_hits = []
+        best_score = 0
         for msg in messages:
             content = msg.get("content", "")
             if not isinstance(content, str):
                 continue
-                
-            if query in content.lower():
-                # Extract snippet
-                start = max(0, content.lower().find(query) - 60)
+
+            low = content.lower()
+            matched = [t for t in q_tokens if t in low]
+            # Accept: full literal phrase OR majority of query tokens
+            if query in low or len(matched) >= min_hits:
+                anchor = query if query in low else matched[0]
+                # Extract snippet around the first matched token
+                start = max(0, low.find(anchor) - 60)
                 end   = min(len(content), start + 200)
                 snippet = content[start:end].replace("\n", " ")
                 if start > 0: snippet = "..." + snippet
                 if end < len(content): snippet += "..."
-                
+
+                score = len(q_tokens) + 1 if query in low else len(matched)
+                best_score = max(best_score, score)
                 session_hits.append({
                     "role": msg.get("role"),
-                    "snippet": snippet
+                    "snippet": snippet,
+                    "_score": score,
                 })
-        
+
         if session_hits:
+            # Best-matching hits first within the session
+            session_hits.sort(key=lambda h: h["_score"], reverse=True)
+            for h in session_hits:
+                h.pop("_score", None)
             results.append({
                 "session_id": session_id,
                 "saved_at": saved_at,
-                "hits": session_hits[:3] # limit hits per session to avoid bloat
+                "hits": session_hits[:3],  # limit hits per session to avoid bloat
+                "_score": best_score,
             })
+            # Early exit: sessions are newest-first, once we have enough
+            # strong matches there is no need to scan ancient history.
+            if len(results) >= max_results * 3:
+                break
 
-    # Sort sessions by recency (newest hit first)
-    results.sort(key=lambda x: x["saved_at"], reverse=True)
+    # Rank: match quality first, then recency (both already newest-first)
+    results.sort(key=lambda x: (x["_score"], str(x["saved_at"])), reverse=True)
+    for r in results:
+        r.pop("_score", None)
     return results[:max_results]

{dulus-3.6.0 → dulus-3.6.2}/memory/tools.py

@@ -123,17 +123,24 @@ def _memory_search(params: dict, config: dict) -> str:
     query = params["query"]
     use_ai = params.get("use_ai", False)
     
-    if config.get("ULTRA_SEARCH") in (1, "1", True, "true"):
+    ultra = config.get("ULTRA_SEARCH") in (1, "1", True, "true")
+    if ultra:
         params["include_sessions"] = True
-        max_results = max(params.get("max_results", 5), 100)
+        # Sessions get the big budget; memories stay capped so session
+        # matches don't get buried/truncated under 100 memory entries.
+        max_results = max(params.get("max_results", 5), 10)
+        session_max = 20
     else:
         max_results = params.get("max_results", 5)
+        session_max = max_results
 
     results = find_relevant_memories(
         query, max_results=max_results * 3, use_ai=use_ai, config=config
     )
 
-    if not results:
+    if not results and not params.get("include_sessions"):
+        # Only early-return when sessions won't be searched; otherwise a
+        # zero-memory result would skip session history entirely (old bug).
         return f"No memories found matching '{query}'."
 
     # Re-rank by confidence × recency score
@@ -172,15 +179,22 @@ def _memory_search(params: dict, config: dict) -> str:
     should_search_sessions = params.get("include_sessions")
 
     if should_search_sessions:
-        sess_results = search_session_history(query, max_results=max_results)
+        sess_results = search_session_history(query, max_results=session_max)
         if sess_results:
-            lines.append("\n" + "─" * 40)
-            lines.append(f"Historical Session Matches ({len(sess_results)} sessions):")
+            sess_lines = ["─" * 40,
+                          f"Historical Session Matches ({len(sess_results)} sessions, newest first):"]
             for sr in sess_results:
-                lines.append(f"\nSession {sr['session_id']} ({sr['saved_at']})")
+                sess_lines.append(f"\nSession {sr['session_id']} ({sr['saved_at']})")
                 for h in sr["hits"]:
                     role_lbl = "User" if h["role"] == "user" else "Dulus"
-                    lines.append(f"  [{role_lbl}] {h['snippet']}")
+                    sess_lines.append(f"  [{role_lbl}] {h['snippet']}")
+            if ultra:
+                # ULTRA mode: sessions are the primary target — put them FIRST
+                # so they never get truncated away under memory entries.
+                lines = [lines[0], ""] + sess_lines + ["", "─" * 40, "Memory entries:"] + lines[1:]
+            else:
+                lines.append("")
+                lines.extend(sess_lines)
 
     # ── Part 3: Offloaded Jobs Search ────────────────────────────────────
     try:

{dulus-3.6.0 → dulus-3.6.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dulus"
-version = "3.6.0"
+version = "3.6.2"
 description = "Use IA as an agent without an API key. $0. Harvest your browser session for Gemini (guest, no login), Claude.ai, Claude Code, Kimi.com, Qwen, DeepSeek — drive them like an API, no per-token billing. Plus LiteLLM (100+ paid providers), local models via Ollama, /lang in 34 languages, Mesa Redonda, voice, OCR, MemPalace, embedded sandbox OS."
 readme = "README.md"
 requires-python = ">=3.11"