dulus 3.5.0__tar.gz → 3.6.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dulus
-Version: 3.5.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.5.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.5.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.5.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.5.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.5.0 → dulus-3.6.2}/docs/news.md

@@ -2,6 +2,14 @@
  
 ## 🔥🔥🔥 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".
+
+- July 3, 2026 (**v3.5.0**): **🕵️ unbroker bundled — your agent removes you from data brokers, free.** Ported from [NousResearch/hermes-agent](https://github.com/NousResearch/hermes-agent) (MIT, by SHL0MS) and seasoned for Dulus: finds a consenting person's exposed PII (name, addresses, phones, relatives) across people-search sites and removes it — CCPA/GDPR opt-out emails, cluster-parents-first ordering, verified-before-disclosure, audit ledger, scheduled re-scans when brokers re-list you. Consent-gated, no CAPTCHA defeating, least-disclosure by design. What DeleteMe/Incogni charge a subscription for, as a transparent self-hosted skill your own agent runs. 22 curated brokers out of the box (~50 via BADBOOL refresh + the CA registry's ~545 with the DROP one-shot). Just say: *"remove my data from data brokers"*. Also in 3.5.0: modern web GUI (`dulus --gui`, React + SSE), opt-in anonymous telemetry, Claude vision attachment fix.
 
 - July 3, 2026: **📡 dulus.work — the final piece, announced.** Kevin finally revealed the idea he'd been keeping secret — even from Dulus itself (opsec against your own AI is crazy work 😂). Every agent ships updates. Nobody ships THIS. The domain is live, the pieces have been quietly shipping for months (SelfImprove engine, Auto-Adapter, skills format, cloudsave...), and now they converge. Already in motion. Stay tuned. 🦅🇩🇴 → [dulus.work](https://dulus.work)
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dulus
-Version: 3.5.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.5.0 → dulus-3.6.2}/dulus.py

@@ -52,6 +52,7 @@ Slash commands in REPL:
   /autojob    Toggle auto-job printer (auto-print job results)
   /auto_show  Toggle auto-show for visual tools (ASCII art, etc.)
   /ultra_search Toggle ULTRA_SEARCH mode
+  /sage [req]  Sage mode: decompose+quality-check+plan the prompt before executing (alias: /sabio; no arg = arm for next prompt)
   /permissions [mode]  Set permission mode
   /afk       Toggle AFK mode (auto-dismiss questions, auto-approve tools)
   /yolo      Toggle YOLO mode (auto-approve ALL actions without prompts)
@@ -897,6 +898,7 @@ _HELP_PAGES = [
         ("/autojob",                "Auto-print job results (toggle)"),
         ("/auto_show",              "Auto-render visual tools (toggle)"),
         ("/ultra_search",           "Aggressive multi-query search"),
+        ("/sage [req]",             "Sage mode: study+plan prompt before executing (/sabio)"),
         ("/permissions [mode]",     "Set permission mode"),
         ("/afk",                    "AFK mode (auto-approve tools)"),
         ("/yolo",                   "YOLO mode (auto-approve ALL)"),
@@ -999,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:
@@ -8080,6 +8087,78 @@ def cmd_plan(args: str, state, config) -> bool:
     return ("__plan__", arg)
 
 
+# ── Sage mode (/sage · /sabio) ──────────────────────────────────────────────
+# Inspired by intake-classifier patterns: before executing, the AI studies the
+# request like a senior architect doing ticket intake — breaks it into atomic
+# issues, runs a quality gate (ambiguity/scope/actionability), asks blocking
+# clarification questions, THEN plans and executes.
+
+_SAGE_WRAPPER_PREFIX = """[SAGE MODE — structured intake & planning. Study the request below BEFORE acting.]
+
+Phase 1 — INTAKE (breakdown):
+Decompose the request into its atomic sub-requests. For each one state: a one-line summary, category (code / research / infra / content / ops / other), priority (low|med|high|critical), and what "done" looks like (verifiable).
+
+Phase 2 — QUALITY GATE:
+Evaluate the request itself: is it ambiguous? imprecise? does it mix multiple unrelated problems? is it actionable as stated? in scope for this environment?
+- If missing info BLOCKS correct execution → ask the user via AskUserQuestion (batch ALL questions into ONE call with options).
+- Otherwise, state your working assumptions explicitly in one short list and continue.
+
+Phase 3 — PLAN:
+Produce a concrete ordered plan: steps, the tools you will use per step, risks, and how you will verify each step actually worked. For multi-step work, register the plan with TaskCreate so progress is trackable.
+
+Phase 4 — EXECUTE:
+Execute the plan step by step, verifying as you go. If reality diverges from the plan, say so honestly and adapt. Never report "done" without having verified.
+
+Show Phases 1-3 to the user briefly (compact, no theater) before executing.
+
+USER REQUEST:
+"""
+
+
+def _sage_wrap(prompt: str) -> str:
+    """Wrap a raw user prompt in the sage intake+planning contract."""
+    return _SAGE_WRAPPER_PREFIX + prompt
+
+
+def cmd_sage(args: str, state, config):
+    """Sage mode — the AI studies, decomposes and plans your prompt before executing.
+
+    /sage               — arm sage mode for your NEXT prompt
+    /sage <request>     — run intake + planning + execution on <request> right now
+    /sage off           — disarm
+    /sage status        — show whether sage mode is armed
+    """
+    arg = args.strip()
+    low = arg.lower()
+
+    if low in ("off", "cancel", "no"):
+        if config.pop("_sage_armed", None):
+            info("Sage mode disarmed.")
+        else:
+            info("Sage mode was not armed.")
+        return True
+
+    if low == "status":
+        if config.get("_sage_armed"):
+            info("Sage mode: ARMED — next prompt will be studied + planned first.")
+        else:
+            info("Sage mode: inactive.")
+        return True
+
+    if not arg:
+        config["_sage_armed"] = True
+        ok("Sage mode armed 🧙 — your NEXT prompt will be decomposed, quality-checked and planned before execution.")
+        info("Cancel with /sage off")
+        return True
+
+    # /sage <request> — run it right now
+    return ("__sage__", arg)
+
+
+# /sabio is the Spanish alias for /sage
+cmd_sabio = cmd_sage
+
+
 def cmd_compact(args: str, state, config) -> bool:
     """Manually compact conversation history.
 
@@ -9640,6 +9719,8 @@ COMMANDS = {
     "checkpoint":  cmd_checkpoint,
     "rewind":      cmd_rewind,
     "plan":        cmd_plan,
+    "sage":        cmd_sage,
+    "sabio":       cmd_sabio,
     "compact":     cmd_compact,
     "init":        cmd_init,
     "export":      cmd_export,
@@ -9677,9 +9758,14 @@ 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__", "__plugin_main_agent__", "__roundtable__", "__roundtable_stop__"):
+        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__"):
             return result
         return True
 
@@ -9761,6 +9847,8 @@ _CMD_META: dict[str, tuple[str, list[str]]] = {
     "checkpoint":  ("List / restore checkpoints",          ["clear"]),
     "rewind":      ("Rewind to checkpoint (alias)",        ["clear"]),
     "plan":        ("Enter/exit plan mode",                ["done", "status"]),
+    "sage":        ("Sage mode — study+plan the prompt before executing", ["off", "status"]),
+    "sabio":       ("Modo sabio — estudia+planifica el prompt antes de ejecutar (alias)", ["off", "status"]),
     "compact":     ("Compact conversation history",         []),
     "init":        ("Initialize DULUS.md template",        []),
     "export":      ("Export conversation to file",          []),
@@ -10546,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:
@@ -10610,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()
@@ -11653,6 +11752,17 @@ def repl(config: dict, initial_prompt: str = None):
                     print(clr("\n  (interrupted)", "yellow"))
                 break
 
+            # Sage sentinel: ("__sage__", request) — intake + plan + execute
+            if result[0] == "__sage__":
+                _, sage_req = result
+                print(clr("  🧙 Sage mode — studying the request before acting…", "dim"))
+                try:
+                    run_query(_sage_wrap(sage_req))
+                except KeyboardInterrupt:
+                    _track_ctrl_c()
+                    print(clr("\n  (interrupted)", "yellow"))
+                break
+
             # Plugin main-agent handoff sentinel:
             # ("__plugin_main_agent__", plugin_name, plugin_source)
             # Triggered by `/plugin install name@url --main-agent` — the main agent
@@ -11881,6 +11991,11 @@ def repl(config: dict, initial_prompt: str = None):
             continue
 
         try:
+            # Sage mode armed via /sage (no args): wrap THIS prompt in the
+            # intake+planning contract, then disarm (one-shot).
+            if config.pop("_sage_armed", None):
+                print(clr("  🧙 Sage mode — studying the request before acting…", "dim"))
+                user_input = _sage_wrap(user_input)
             run_query(user_input)
             
             # Auto-save config after each turn for web providers to persist session IDs

{dulus-3.5.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.5.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.5.0 → dulus-3.6.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dulus"
-version = "3.5.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"