dulus 3.13.4__tar.gz → 3.13.6__tar.gz

{dulus-3.13.4/dulus.egg-info → dulus-3.13.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: dulus
-Version: 3.13.4
+Version: 3.13.6
 Summary: Provider-independent agent runtime for the terminal — cloud and local models, real tools, MCP, plugins, memory, sub-agents, and Dulus OS.
 Author-email: KevRojo <dev@dulus.ai>
 Maintainer-email: KevRojo <dev@dulus.ai>

{dulus-3.13.4 → dulus-3.13.6}/agent.py

@@ -206,6 +206,19 @@ def run(
         except Exception:
             _api_source, _lb_meta = state.messages, {"enabled": False, "truncated": False}
 
+        # Strip GUI/REPL baseline display blobs (soul/gold/welcome). The model
+        # already has them via system prompt; leaving them as role:assistant
+        # made web-history consolidate drop everything before the last
+        # assistant (= the gold blob itself) on first turn.
+        try:
+            from memory import is_baseline_display_message
+            _api_source = [
+                m for m in _api_source
+                if not is_baseline_display_message(m)
+            ]
+        except Exception:
+            pass
+
         # Sanitize message contents before sending to API (surrogate safety)
         _safe_messages = []
         for m in _api_source:

{dulus-3.13.4 → dulus-3.13.6}/compaction.py

@@ -678,6 +678,13 @@ def save_loopback_archive(messages: list, state=None, config: dict | None = None
     Writes ~/.dulus/loopback_archives/archive_<session>.json and binds
     config["_loopback_archive_path"] + config["_loopback_archive"] (in-memory
     copy) for the Loopback tool. Returns the path or None on failure.
+
+    CRITICAL — second-/Nth-compact guard:
+    A later ``/compact`` runs against an *already slimmed* ``state.messages``.
+    Naively rewriting the archive would overwrite the original full history
+    with the post-compact crumbs. We NEVER shrink a durable archive: if an
+    in-memory or on-disk copy is longer than ``messages``, keep the longer one
+    and only refresh the binding.
     """
     if not messages:
         return None
@@ -685,6 +692,29 @@ def save_loopback_archive(messages: list, state=None, config: dict | None = None
         LOOPBACK_ARCHIVE_DIR.mkdir(parents=True, exist_ok=True)
         sid = _session_key(state, config)
         path = LOOPBACK_ARCHIVE_DIR / f"archive_{sid}.json"
+
+        # Resolve the longest known full archive for this session.
+        prev: list = []
+        if isinstance(config, dict):
+            live = config.get("_loopback_archive")
+            if isinstance(live, list) and live:
+                prev = live
+        if not prev and path.exists():
+            try:
+                disk = json.loads(path.read_text(encoding="utf-8"))
+                disk_msgs = disk.get("messages") if isinstance(disk, dict) else None
+                if isinstance(disk_msgs, list) and disk_msgs:
+                    prev = disk_msgs
+            except Exception:
+                prev = []
+
+        if prev and len(prev) > len(messages):
+            # Refuse to shrink. Keep the fuller archive as the durable source.
+            if isinstance(config, dict):
+                config["_loopback_archive"] = prev
+                config["_loopback_archive_path"] = str(path)
+            return path
+
         payload = {
             "session_id": sid,
             "timestamp": time.strftime("%Y%m%d_%H%M%S"),

{dulus-3.13.4 → dulus-3.13.6}/context.py

@@ -442,12 +442,28 @@ def _resolve_reply_language(config: dict | None) -> str:
     return raw
 
 
+
+def _append_baseline_fragments(prompt: str) -> str:
+    """Attach soul + gold system fragments (always-on baseline)."""
+    try:
+        from memory import soul_system_fragment, gold_system_fragment
+        _soul = soul_system_fragment()
+        if _soul:
+            prompt += "\n\n" + _soul
+        _gold = gold_system_fragment()
+        if _gold:
+            prompt += "\n\n" + _gold
+    except Exception:
+        pass
+    return prompt
+
+
 def build_system_prompt(config: dict | None = None) -> str:
     import platform
     model_lower = (config.get("model", "") if config else "").lower()
     is_deepseek_r1 = "deepseek-r1" in model_lower or "deepseek-reasoner" in model_lower
     if is_deepseek_r1 and config and config.get("deep_override", False):
-        return _build_ollama_system_prompt(config)
+        return _append_baseline_fragments(_build_ollama_system_prompt(config))
 
     auto_show = "ON" if (not config or config.get("auto_show", True)) else "OFF"
     lite = bool(config and config.get("lite_mode"))
@@ -470,8 +486,12 @@ def build_system_prompt(config: dict | None = None) -> str:
         dulus_md="" if lite else get_dulus_md(),
     )
 
+    # Soul + Gold baseline ALWAYS (even in lite) — model source of truth.
+    # Display copies in chat are GUI-only and get stripped before the API call.
+    prompt = _append_baseline_fragments(prompt)
+
     if lite:
-        # Bail early — minimal prompt only.
+        # Bail early — minimal prompt only (baseline already attached).
         return prompt
 
     try:

{dulus-3.13.4 → dulus-3.13.6}/docs/CHANGELOG.md

@@ -7,6 +7,27 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [3.13.6] - 2026-08-31
+
+### Fixed
+- **WebChat CONFIG None guard**: `CONFIG` is checked before `.pop(...)` so pyright/static quality stays clean when config is unset
+- **Background tasks on Windows**: worker launch no longer goes through bash-quoted `python -c`; Windows-safe `_worker.py` path keeps win-3.13 CI stable
+
+### Tests
+- Quality CI green on Ubuntu + Windows · Python 3.11 + 3.13 · Types and package green
+
+## [3.13.5] - 2026-08-31
+
+### Fixed
+- **Gold / short_memory baseline**: curated gold memories (incl. `short_memory`) and soul now ride in `build_system_prompt` every turn — always-on, **not** gated by `/mem_palace`
+- **First-turn amnesia**: agent + lookback strip GUI/REPL gold/soul/welcome *display* blobs before the provider call, so web-history consolidate no longer treats gold as “last assistant reply” and drops real context
+- **MemPalace dual-path noise**: per-turn inject (CLI + WebChat) skips `short_memory` / soul — already in the system prompt
+- **Second `/compact` archive wipe**: `save_loopback_archive` refuses to shrink; Loopback keeps the full pre-compact history across N compacts
+- **WebChat gold preload**: session seeds gold *display* copies for the transcript; model source of truth is still the system prompt (public GUI stays as-is — this is server/engine, not an Interant GUI port)
+
+### Tests
+- `test_gold_memory_preload` + `test_lookback_compact` (11 passed)
+
 ## [3.13.4] - 2026-08-31
 
 ### Fixed

{dulus-3.13.4 → dulus-3.13.6}/docs/news.md

@@ -2,6 +2,10 @@
  
 ## 🔥🔥🔥 News (Pacific Time)
 
+- August 31, 2026 (**v3.13.6**): **CI quality locked green.** WebChat guards `CONFIG` before pop (pyright clean) and background workers launch Windows-safe without bash-quoted `python -c` — win-3.13 flake gone. Hotfix patch on top of 3.13.5. `pip install -U dulus`. 🦅
+
+- August 31, 2026 (**v3.13.5**): **🏆 short_memory stopped vanishing.** Gold memories + soul now live in the **system prompt** every turn (always-on — `/mem_palace off` no longer starves them). WebChat seeds gold for the transcript; the agent/lookback strip those display blobs before the provider call so first-turn consolidate can’t eat your context. Second `/compact` no longer wipes the Loopback archive. Engine + WebChat fix — not a desktop-GUI rewrite. `pip install -U dulus`. 🦅
+
 - August 31, 2026 (**v3.13.4**): **Context windows are honest again.** `token_budget` ships so compaction knows Claude is 200k, Gemini is 1M, DeepSeek is 64k — not a flat 128k for everyone. Quality CI: **925 passed**. `pip install -U dulus`. 🦅
 
 - August 31, 2026 (**v3.13.3**): **`/compact` got serious.** Full archive → disk for Loopback, live context → ~0 with a dense hint card, and **lookback is forced ON** for that session even if it was off — so quality does not fall off a cliff after compact. `pip install -U dulus`. 🦅

{dulus-3.13.4 → dulus-3.13.6/dulus.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: dulus
-Version: 3.13.4
+Version: 3.13.6
 Summary: Provider-independent agent runtime for the terminal — cloud and local models, real tools, MCP, plugins, memory, sub-agents, and Dulus OS.
 Author-email: KevRojo <dev@dulus.ai>
 Maintainer-email: KevRojo <dev@dulus.ai>

{dulus-3.13.4 → dulus-3.13.6}/dulus.egg-info/SOURCES.txt

@@ -332,6 +332,7 @@ tests/test_diff_visualization.py
 tests/test_display_blocks.py
 tests/test_dulus_account.py
 tests/test_export_import.py
+tests/test_gold_memory_preload.py
 tests/test_grok_usage.py
 tests/test_hook_engine.py
 tests/test_injection_fix.py

{dulus-3.13.4 → dulus-3.13.6}/dulus.py

@@ -395,7 +395,7 @@ try:
     from importlib.metadata import version as _pkg_version
     VERSION = _pkg_version("dulus")
 except Exception:
-    VERSION = "3.13.4"  # dev fallback — keep in sync with pyproject.toml
+    VERSION = "3.13.6"  # dev fallback — keep in sync with pyproject.toml
 
 # ── Machine-readable protocol output (`--output json`) ─────────────────────
 # Dulus is increasingly run as a child process by another agent runtime (an
@@ -3570,6 +3570,8 @@ def cmd_mem_palace(args: str, _state, config) -> bool:
     config["mem_palace"] = not config.get("mem_palace", True)
     state_str = "ON" if config["mem_palace"] else "OFF"
     ok(f"MemPalace auto-injection: {state_str}")
+    if not config["mem_palace"]:
+        info("Gold memories (incl. short_memory) still load at session start.")
     save_config(config)
     return True
 
@@ -12227,18 +12229,21 @@ def repl(config: dict, initial_prompt: str | None = None):
         except Exception as e:
             startup_status_msgs.append(clr(f"  ⚠ Schema inject skip: {e}", "yellow"))
 
-    # ── Gold Memories Auto-Load ───────────────────────────────────────────────
-    # Memories marked with `gold: true` (via /memory permanent) are injected
-    # at startup the same way as Soul.
+    # ── Gold Memories Auto-Load (GUI/REPL display copies) ─────────────────────
+    # Model source of truth is build_system_prompt → gold_system_fragment().
+    # These assistant-role copies are for the transcript/GUI only and get
+    # stripped before the provider call (agent.py + lookback). Never gated
+    # by /mem_palace (that toggle is only for per-turn semantic search).
     try:
-        from memory import load_index
-        gold_entries = [e for e in load_index("all") if getattr(e, "gold", False)]
-        for e in gold_entries:
-            state.messages.append({
-                "role": "assistant",
-                "content": f"[Golden Memory Loaded: {e.name}]\n\n{e.content}",
-            })
-            startup_status_msgs.append(clr(f"  🏆 Gold memory loaded: {e.name}", "yellow", "bold"))
+        from memory import gold_context_messages, gold_system_fragment
+        _gold_in_system = bool(gold_system_fragment())
+        for _msg in gold_context_messages():
+            state.messages.append(_msg)
+            _gold_name = _msg["content"].split("]", 1)[0].removeprefix("[Golden Memory Loaded: ")
+            _where = "system+GUI" if _gold_in_system else "GUI only"
+            startup_status_msgs.append(
+                clr(f"  🏆 Gold memory loaded ({_where}): {_gold_name}", "yellow", "bold")
+            )
     except Exception:
         pass
 
@@ -12735,6 +12740,18 @@ def repl(config: dict, initial_prompt: str | None = None):
                                 for _h in _raw_hits:
                                     _mp_log(f"  hit: score={float(_h.get('keyword_score', 0.0)):.3f}  {_h.get('name','?')}", "dim")
                             _kept = [h for h in _raw_hits if float(h.get("keyword_score", 0.0)) >= _MIN_SCORE]
+                            # Skip short_memory/soul — already in system-prompt baseline.
+                            try:
+                                from memory import is_baseline_memory_name
+                                _kept = [
+                                    h for h in _kept
+                                    if not is_baseline_memory_name(h.get("name"))
+                                    and not is_baseline_memory_name(
+                                        (h.get("description") or "").split()[:1][0] if h.get("description") else None
+                                    )
+                                ]
+                            except Exception:
+                                pass
                             # ── Dedup: skip memories already injected earlier in this session.
                             # Key by content hash (not name) because mempalace often returns
                             # generic names like "palace" for every hit in a wing — name-based

{dulus-3.13.4 → dulus-3.13.6}/dulus_tools/background_tasks.py

@@ -513,13 +513,21 @@ class BackgroundTaskManager:
         env["DULUS_BG_TASK"] = "1"
         env["DULUS_BG_TIMEOUT"] = str(timeout_s)
 
-        # Escape single quotes in the command to avoid breaking the wrapper
-        safe_command = command.replace("'", "'\"'\"'")
-        script = f"cd '{cwd}' && {safe_command}"
+        # Write a tiny runner script so cwd/command never pass through shell
+        # quoting (bash `'"'"'` tricks + Python -c single quotes break hard on
+        # Windows paths like C:\Users\... and on echo 'HELLO').
+        runner = task_dir / "_worker.py"
+        runner.write_text(
+            "import os, subprocess, sys\n"
+            f"os.chdir({cwd!r})\n"
+            f"raise SystemExit(subprocess.call({command!r}, shell=True))\n",
+            encoding="utf-8",
+        )
 
+        log_fh = open(task_dir / "output.log", "w", encoding="utf-8")
         kwargs: dict[str, Any] = {
             "stdin": subprocess.DEVNULL,
-            "stdout": open(task_dir / "output.log", "w", encoding="utf-8"),
+            "stdout": log_fh,
             "stderr": subprocess.STDOUT,
             "cwd": cwd,
             "env": env,
@@ -527,13 +535,13 @@ class BackgroundTaskManager:
 
         if os.name != "nt":
             kwargs["start_new_session"] = True
+        else:
+            # Detach from the console so the parent can exit cleanly on CI.
+            create_new = getattr(subprocess, "CREATE_NEW_PROCESS_GROUP", 0)
+            kwargs["creationflags"] = create_new
 
         process = subprocess.Popen(
-            [
-                sys.executable,
-                "-c",
-                f"import subprocess, sys; sys.exit(subprocess.call('{script}', shell=True))",
-            ],
+            [sys.executable, str(runner)],
             **kwargs,
         )
         return process.pid

{dulus-3.13.4 → dulus-3.13.6}/lookback.py

@@ -155,6 +155,25 @@ def find_lookback_start(messages: list, turns: int) -> int:
     return start
 
 
+
+def _strip_baseline_display(messages: list) -> list:
+    """Drop soul/gold/welcome GUI display blobs from an API window.
+
+    Those ride in the system prompt now (see memory.gold_system_fragment /
+    soul_system_fragment). Keeping them as role:assistant in the API payload
+    made web-history consolidate treat gold as "last assistant reply".
+    """
+    if not messages:
+        return messages
+    try:
+        from memory import is_baseline_display_message
+    except Exception:
+        return messages
+    out = [m for m in messages if not is_baseline_display_message(m)]
+    # Preserve identity when nothing was stripped (callers/tests rely on it).
+    return messages if len(out) == len(messages) else out
+
+
 def apply_lookback_window(
     messages: list,
     config: dict | None = None,
@@ -166,6 +185,9 @@ def apply_lookback_window(
 
     Full ``messages`` is never mutated. When disabled or small enough, the
     original list is returned (same object) with meta.truncated=False.
+
+    Baseline display blobs (soul/gold/welcome) are always stripped from the
+    returned API window — they live in the system prompt, not chat turns.
     """
     msgs = messages or []
     on = lookback_enabled(config) if enabled is None else bool(enabled)
@@ -186,9 +208,20 @@ def apply_lookback_window(
         "start_index": 0,
         "hidden_messages": 0,
     }
+    def _api_window(window: list, meta: dict[str, Any]) -> tuple[list, dict[str, Any]]:
+        """Strip baseline display blobs and refresh window counts."""
+        cleaned = _strip_baseline_display(window)
+        if cleaned is window:
+            return window, meta
+        meta = dict(meta)
+        meta["window_messages"] = len(cleaned)
+        meta["window_user_turns"] = count_user_turns(cleaned)
+        meta["baseline_stripped"] = len(window) - len(cleaned)
+        return cleaned, meta
+
     if not on or total == 0:
         _clear_anchor(config)
-        return msgs, meta
+        return _api_window(msgs, meta)
 
     # Hysteresis: reuse the previous start (anchor) while its window still
     # holds n..n+slack user turns. The API prefix then stays append-only
@@ -211,7 +244,7 @@ def apply_lookback_window(
 
     if start <= 0:
         _clear_anchor(config)
-        return msgs, meta
+        return _api_window(msgs, meta)
 
     # Cache-aware gate: only truncate when the head we'd hide is meaningfully
     # bigger than the window we'd keep. Otherwise dropping the front busts the
@@ -242,7 +275,7 @@ def apply_lookback_window(
         "window_user_turns": count_user_turns(window),
         "hidden_messages": start,
     })
-    return window, meta
+    return _api_window(window, meta)
 
 
 def lookback_system_note(meta: dict[str, Any]) -> str:

{dulus-3.13.4 → dulus-3.13.6}/memory/__init__.py

@@ -57,7 +57,18 @@ from .types import (  # noqa: F401
     WHAT_NOT_TO_SAVE,
 )
 from .consolidator import consolidate_session, mine_files, snapshot_memory_files, new_memory_files  # noqa: F401
-from .palace import ensure_memory_palace, ensure_short_memory  # noqa: F401
+from .palace import (  # noqa: F401
+    ensure_memory_palace,
+    ensure_short_memory,
+    gold_context_messages,
+    gold_system_fragment,
+    soul_system_fragment,
+    is_baseline_display_message,
+    is_baseline_memory_name,
+    GOLD_MARKER,
+    SOUL_MARKER,
+    BASELINE_DISPLAY_MARKERS,
+)
 from .mempalace_bridge import (  # noqa: F401
     schedule_mempalace_mine,
     wait_pending_mines,

{dulus-3.13.4 → dulus-3.13.6}/memory/palace.py

@@ -13,6 +13,7 @@ from pathlib import Path
 
 from .store import (
     MemoryEntry,
+    USER_MEMORY_DIR,
     get_memory_dir,
     has_stacked_frontmatter,
     parse_frontmatter,
@@ -267,6 +268,158 @@ def seed_insight_memories() -> bool:
     return changed
 
 
+
+# ── Baseline display markers (GUI/REPL transcript only) ─────────────────────
+# These role:assistant blobs are for the human to see in the chat UI. The model
+# source of truth is gold_system_fragment() / soul_system_fragment() in the
+# system prompt. Agent + lookback strip these markers from the API payload.
+GOLD_MARKER = "[Golden Memory Loaded:"
+SOUL_MARKER = "[Identity Essence Loaded:"
+SOUL_RELOAD_MARKER = "[Identity Essence Reloaded:"
+WELCOME_MARKER = "<!-- dulus:welcome -->"
+BASELINE_DISPLAY_MARKERS = (
+    GOLD_MARKER,
+    SOUL_MARKER,
+    SOUL_RELOAD_MARKER,
+    WELCOME_MARKER,
+)
+
+
+def is_baseline_display_message(msg: dict | None) -> bool:
+    """True if *msg* is a GUI/REPL display blob for soul/gold/welcome."""
+    if not isinstance(msg, dict):
+        return False
+    content = msg.get("content") or ""
+    if not isinstance(content, str):
+        return False
+    s = content.lstrip()
+    return any(s.startswith(m) for m in BASELINE_DISPLAY_MARKERS)
+
+
+def is_baseline_memory_name(name: str | None) -> bool:
+    """True for memories that already ride in the system-prompt baseline.
+
+    MemPalace per-turn inject must skip these — re-injecting a truncated
+    ``short_memory`` on top of the full system copy is pure noise.
+    """
+    if not name:
+        return False
+    key = str(name).strip().lower().replace("-", "_").replace(" ", "_")
+    key = key.rsplit("/", 1)[-1].rsplit("\\", 1)[-1].rsplit(".", 1)[0]
+    if key in {"short_memory", "shortmemory", "soul"}:
+        return True
+    if key.startswith("golden_memory") or "short_memory" in key:
+        return True
+    return False
+
+
+def _clamp_body(body: str, max_chars: int) -> str:
+    body = (body or "").strip()
+    if not body or len(body) <= max_chars:
+        return body
+    head = max_chars * 3 // 4
+    return (
+        body[:head]
+        + "\n\n[... gold memory clipped — file is oversized; "
+        "re-curate it with MemorySave ...]\n\n"
+        + body[-(max_chars - head):]
+    )
+
+
+def _iter_gold_entries(max_chars: int = 8000):
+    """Yield (name, body) for every gold memory, short_memory first."""
+    try:
+        ensure_short_memory(force_gold=True)
+    except Exception:
+        pass
+    try:
+        from .store import load_index
+        entries = [e for e in load_index("all") if getattr(e, "gold", False)]
+    except Exception:
+        return
+    def _sort_key(e):
+        name = (getattr(e, "name", "") or "").lower()
+        return (0 if name == "short_memory" else 1, name)
+
+    for entry in sorted(entries, key=_sort_key):
+        body = _clamp_body(getattr(entry, "content", "") or "", max_chars)
+        if not body:
+            continue
+        yield (getattr(entry, "name", "gold") or "gold", body)
+
+
+def gold_system_fragment(max_chars: int = 8000, max_total: int = 12000) -> str:
+    """Gold memories as a stable system-prompt block (model source of truth).
+
+    This is how the model actually *receives* short_memory and other gold
+    entries — not as ``role:assistant`` chat turns (those break web-history
+    consolidate, Anthropic role alternation, and lookback).
+
+    Deliberately NOT gated by ``mem_palace``. Called every turn from
+    ``build_system_prompt`` so edits to short_memory.md show up immediately.
+    """
+    parts: list[str] = []
+    total = 0
+    for name, body in _iter_gold_entries(max_chars=max_chars):
+        block = f"[Golden Memory Loaded: {name}]\n\n{body}"
+        if total and total + len(block) > max_total:
+            break
+        parts.append(block)
+        total += len(block) + 2
+    if not parts:
+        return ""
+    return (
+        "# ── Golden Memory (always-on baseline — NOT gated by /mem_palace) ──\n"
+        "These are curated essentials. Treat short_memory as the live scratchpad "
+        "of where we left off; do not ask the user to re-explain it.\n\n"
+        + "\n\n".join(parts)
+    )
+
+
+def soul_system_fragment(max_chars: int = 8000) -> str:
+    """Soul identity as a system-prompt block (same rationale as gold)."""
+    try:
+        path = USER_MEMORY_DIR / "soul.md"
+        if not path.exists():
+            return ""
+        raw = path.read_text(encoding="utf-8", errors="replace")
+        body = raw
+        if raw.lstrip().startswith("---"):
+            try:
+                from .store import parse_frontmatter
+                _, body = parse_frontmatter(raw)
+            except Exception:
+                body = raw
+        body = _clamp_body(body, max_chars)
+        if not body:
+            return ""
+        return (
+            "# ── Identity Essence (soul) ──\n"
+            f"[Identity Essence Loaded: soul]\n\n{body}"
+        )
+    except Exception:
+        return ""
+
+
+def gold_context_messages(max_chars: int = 8000) -> list[dict[str, str]]:
+    """GUI/REPL *display* copies of gold memories (NOT the model source of truth).
+
+    Kept as ``role:assistant`` so `/api/chat/history` and the desktop GUI can
+    render "🏆 Gold memory loaded" in the transcript. The agent loop strips
+    these markers before the provider call; the real baseline rides in the
+    system prompt via ``gold_system_fragment()``.
+
+    Deliberately NOT gated by the ``mem_palace`` config toggle.
+    """
+    messages: list[dict[str, str]] = []
+    for name, body in _iter_gold_entries(max_chars=max_chars):
+        messages.append({
+            "role": "assistant",
+            "content": f"[Golden Memory Loaded: {name}]\n\n{body}",
+        })
+    return messages
+
+
 def ensure_memory_palace() -> bool:
     """Initialize missing core buckets + always ensure gold short_memory.
 

{dulus-3.13.4 → dulus-3.13.6}/pyproject.toml

@@ -10,7 +10,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dulus"
-version = "3.13.4"
+version = "3.13.6"
 description = "Provider-independent agent runtime for the terminal — cloud and local models, real tools, MCP, plugins, memory, sub-agents, and Dulus OS."
 readme = "README.md"
 requires-python = ">=3.10"

{dulus-3.13.4 → dulus-3.13.6}/tests/test_background_tasks.py

@@ -513,27 +513,44 @@ class TestBackgroundTaskManager:
         assert path.exists()
 
     def test_launch_worker_creates_subprocess(self, tmp_manager: BackgroundTaskManager) -> None:
-        # Actually test subprocess creation (will create a real process)
-        view = tmp_manager.create_bash_task("echo 'HELLO_FROM_TEST'", "test echo")
+        # Actually test subprocess creation (will create a real process).
+        # No single quotes — Windows cmd treats them literally; the worker
+        # runner now uses repr()-safe Python, but keep the command portable.
+        view = tmp_manager.create_bash_task("echo HELLO_FROM_TEST", "test echo")
         assert view.runtime.worker_pid is not None
         assert view.runtime.worker_pid > 0
 
-        # Wait a bit for the process to complete
-        time.sleep(0.5)
-
-        # Check output
-        chunk = tmp_manager.read_output(view.spec.id)
-        assert "HELLO_FROM_TEST" in chunk.text
+        # Poll — CI Windows runners are slower than a fixed 0.5s sleep.
+        deadline = time.time() + 10.0
+        text = ""
+        while time.time() < deadline:
+            chunk = tmp_manager.read_output(view.spec.id)
+            text = chunk.text or ""
+            if "HELLO_FROM_TEST" in text:
+                break
+            time.sleep(0.1)
+        assert "HELLO_FROM_TEST" in text, f"worker output empty/missing marker: {text!r}"
 
     def test_launch_worker_with_cwd(self, tmp_manager: BackgroundTaskManager, tmp_path: Path) -> None:
         subdir = tmp_path / "subdir"
         subdir.mkdir()
 
-        view = tmp_manager.create_bash_task("pwd", "test cwd", cwd=str(subdir))
-        time.sleep(0.5)
-
-        chunk = tmp_manager.read_output(view.spec.id)
-        assert str(subdir) in chunk.text
+        # Portable cwd probe: Python prints the path on every OS (pwd is Unix-only).
+        view = tmp_manager.create_bash_task(
+            f'"{sys.executable}" -c "import os; print(os.getcwd())"',
+            "test cwd",
+            cwd=str(subdir),
+        )
+        deadline = time.time() + 10.0
+        text = ""
+        while time.time() < deadline:
+            chunk = tmp_manager.read_output(view.spec.id)
+            text = chunk.text or ""
+            if str(subdir) in text or subdir.name in text:
+                break
+            time.sleep(0.1)
+        # Normalize separators so Win paths still match.
+        assert str(subdir) in text or str(subdir).replace("\\", "/") in text.replace("\\", "/")
 
     def test_recovery_marks_stale_tasks(self, tmp_manager: BackgroundTaskManager) -> None:
         with patch.object(tmp_manager, "_launch_worker", return_value=12345):