dulus 3.12.0__tar.gz → 3.13.0__tar.gz

{dulus-3.12.0/dulus.egg-info → dulus-3.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: dulus
-Version: 3.12.0
+Version: 3.13.0
 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>
@@ -99,7 +99,11 @@ Requires-Dist: pytesseract>=0.3.10; extra == "full"
 # Dulus
 
 <p align="center">
-  <img src="https://raw.githubusercontent.com/KevRojo/Dulus/main/docs/readme/hero.png" alt="Dulus — Hunt. Patch. Ship." width="100%">
+  <img width="1382" height="938" alt="image" src="https://github.com/user-attachments/assets/a2b297e3-53f8-4fce-a91a-6123274c4fc4" />
+</p>
+
+<p align="center">
+  <img width="1179" height="761" alt="image" src="https://github.com/user-attachments/assets/95c8a306-88e6-4f9d-a1aa-009ac38ebeaf" />
 </p>
 
 <p align="center">
@@ -110,6 +114,10 @@ Requires-Dist: pytesseract>=0.3.10; extra == "full"
   Dulus is an open-source agent runtime that hands you a real AI agent the moment you install it —<br>
   talking to Gemini, Claude and GPT through their own web sessions, so you owe no one a key or a cent.<br>
   One runtime. Every model. Your machine. The whole world invited.
+
+  For a better version get the binaries from https://dulus.ai/ there are free models on my /dulus/dulus-* providers, love you guys!
+
+  God bless you! ♥
 </p>
 
 <p align="center">
@@ -222,6 +230,21 @@ Try it and hit me with feedback — it's the token trick I'm proudest of.
 
 ---
 
+## New — Signed binaries, maintained by me
+
+> 📢 The fastest way to run Dulus is the prebuilt app — I keep it updated myself.
+
+The public `pip install dulus` gives you the full open-source runtime. But if you want the **smoothest experience** — auto-updating, code-signed, zero Python setup — grab the **prebuilt binaries** for Windows, macOS and Linux. I maintain those builds personally so they always ship the latest fixes first.
+
+<p align="center">
+  <a href="https://dulus.ai/"><strong>⬇️ Download the binaries → dulus.ai</strong></a> ·
+  <a href="https://github.com/Dulus-Ai/dulus-updates/releases/latest"><strong>GitHub Releases ↗</strong></a>
+</p>
+
+The **premium/desktop core is closed-source on purpose** — that code stays private so it can't be leaked, cloned, or stripped of its license gate. This public repo is the real runtime you can read, fork and build on; the signed binaries are the same runtime plus the private polish, kept safe on my side. Best of both: **open where it counts, protected where it matters.**
+
+---
+
 ## A note from the builder
 
 I'm one developer. No team, no funding, no VC deck — just me, a laptop, and a stubborn little bird from the Dominican Republic. 🇩🇴
@@ -694,7 +717,9 @@ Frames use the OpenCode event-stream dialect, so a consumer that already parses
 | `step_finish` | `part.tokens.input` · `.output` · `.cache.read` · `.cache.write` · `part.cost` |
 | `error` | `message` |
 
-Exit code is `0` on success, `130` on Ctrl+C, and non-zero on any failure — a missing credential, a provider error, an unhandled exception — always alongside an `error` frame. Pass the prompt after `--`: it is a positional argument, so without the terminator a prompt starting with a hyphen is parsed as a flag.
+Exit code is `0` on success, `130` on Ctrl+C, and non-zero on any failure — a missing credential, a provider error, an unhandled exception, or a turn that produced no answer at all — always alongside an `error` frame. A run that streams partial text and then fails is a failure, not a partial success. Pass the prompt after `--`: it is a positional argument, so without the terminator a prompt starting with a hyphen is parsed as a flag.
+
+`--version` and `--help` always answer on stdout, in every mode.
 
 ### Development setup
 

{dulus-3.12.0 → dulus-3.13.0}/README.md

@@ -1,7 +1,11 @@
 # Dulus
 
 <p align="center">
-  <img src="https://raw.githubusercontent.com/KevRojo/Dulus/main/docs/readme/hero.png" alt="Dulus — Hunt. Patch. Ship." width="100%">
+  <img width="1382" height="938" alt="image" src="https://github.com/user-attachments/assets/a2b297e3-53f8-4fce-a91a-6123274c4fc4" />
+</p>
+
+<p align="center">
+  <img width="1179" height="761" alt="image" src="https://github.com/user-attachments/assets/95c8a306-88e6-4f9d-a1aa-009ac38ebeaf" />
 </p>
 
 <p align="center">
@@ -12,6 +16,10 @@
   Dulus is an open-source agent runtime that hands you a real AI agent the moment you install it —<br>
   talking to Gemini, Claude and GPT through their own web sessions, so you owe no one a key or a cent.<br>
   One runtime. Every model. Your machine. The whole world invited.
+
+  For a better version get the binaries from https://dulus.ai/ there are free models on my /dulus/dulus-* providers, love you guys!
+
+  God bless you! ♥
 </p>
 
 <p align="center">
@@ -124,6 +132,21 @@ Try it and hit me with feedback — it's the token trick I'm proudest of.
 
 ---
 
+## New — Signed binaries, maintained by me
+
+> 📢 The fastest way to run Dulus is the prebuilt app — I keep it updated myself.
+
+The public `pip install dulus` gives you the full open-source runtime. But if you want the **smoothest experience** — auto-updating, code-signed, zero Python setup — grab the **prebuilt binaries** for Windows, macOS and Linux. I maintain those builds personally so they always ship the latest fixes first.
+
+<p align="center">
+  <a href="https://dulus.ai/"><strong>⬇️ Download the binaries → dulus.ai</strong></a> ·
+  <a href="https://github.com/Dulus-Ai/dulus-updates/releases/latest"><strong>GitHub Releases ↗</strong></a>
+</p>
+
+The **premium/desktop core is closed-source on purpose** — that code stays private so it can't be leaked, cloned, or stripped of its license gate. This public repo is the real runtime you can read, fork and build on; the signed binaries are the same runtime plus the private polish, kept safe on my side. Best of both: **open where it counts, protected where it matters.**
+
+---
+
 ## A note from the builder
 
 I'm one developer. No team, no funding, no VC deck — just me, a laptop, and a stubborn little bird from the Dominican Republic. 🇩🇴
@@ -596,7 +619,9 @@ Frames use the OpenCode event-stream dialect, so a consumer that already parses
 | `step_finish` | `part.tokens.input` · `.output` · `.cache.read` · `.cache.write` · `part.cost` |
 | `error` | `message` |
 
-Exit code is `0` on success, `130` on Ctrl+C, and non-zero on any failure — a missing credential, a provider error, an unhandled exception — always alongside an `error` frame. Pass the prompt after `--`: it is a positional argument, so without the terminator a prompt starting with a hyphen is parsed as a flag.
+Exit code is `0` on success, `130` on Ctrl+C, and non-zero on any failure — a missing credential, a provider error, an unhandled exception, or a turn that produced no answer at all — always alongside an `error` frame. A run that streams partial text and then fails is a failure, not a partial success. Pass the prompt after `--`: it is a positional argument, so without the terminator a prompt starting with a hyphen is parsed as a flag.
+
+`--version` and `--help` always answer on stdout, in every mode.
 
 ### Development setup
 

{dulus-3.12.0 → dulus-3.13.0}/agent.py

@@ -66,6 +66,18 @@ class AgentState:
     total_cache_creation_tokens: int = 0
     turn_count: int = 0
     _short_mem_counter: int = 0  # +1 per tool turn; nudges short_memory at 10
+    # Why the last turn failed, or "" when it didn't. A provider can end a turn
+    # with error=True (missing web-auth file, exhausted quota) — run() rolls the
+    # history back and breaks, so the caller sees no new assistant message, no
+    # TurnDone and no exception. Without this the failure is unobservable and a
+    # non-interactive run reports success with whatever message was already last.
+    last_error: str = ""
+    # This turn's assistant text, or None when the turn never produced one.
+    # Read by non-interactive callers that must report exactly what this turn
+    # answered. Unlike scanning `messages` it survives mid-run auto-compaction
+    # (which rebinds the list and invalidates any index) and cannot pick up the
+    # Soul or gold-memory messages that are injected as role="assistant" at boot.
+    last_reply: str | None = None
 
 
 @dataclass
@@ -147,6 +159,15 @@ def run(
         user_msg["videos"] = [pending_vid]
     
     initial_msg_count = len(state.messages)
+    state.last_error = ""     # this turn's verdict starts clean
+    state.last_reply = None
+    # Same for the shared err() record: without this a stale reason from an
+    # earlier turn could be blamed for this turn's outcome.
+    try:
+        import common as _common
+        _common.clear_last_error()
+    except Exception:
+        pass
     state.messages.append(user_msg)
 
     # Inject runtime metadata into config so tools (e.g. Agent, Loopback) can access it.
@@ -248,18 +269,23 @@ def run(
             break
 
         if assistant_turn.error:
+            # The turn's text IS the failure reason (provider layer puts it
+            # there); record it before the rollback throws away the evidence.
+            state.last_error = sanitize_text(assistant_turn.text or "").strip()
             # Rollback: remove anything added during this turn sequence to prevent corrupted history
             while len(state.messages) > initial_msg_count:
                 state.messages.pop()
             break
 
         # Record assistant turn in neutral format
+        _reply_text = sanitize_text(assistant_turn.text)
         state.messages.append({
             "role":       "assistant",
-            "content":    sanitize_text(assistant_turn.text),
+            "content":    _reply_text,
             "thinking":   sanitize_text(assistant_turn.thinking) if assistant_turn.thinking else "",
             "tool_calls": assistant_turn.tool_calls,
         })
+        state.last_reply = _reply_text
 
         # Token accounting. Most providers only emit the usage chunk on the
         # FINAL (text) response — on intermediate tool-call responses they send

{dulus-3.12.0 → dulus-3.13.0}/common.py

@@ -164,7 +164,30 @@ def warn(msg: str):
     print(clr(f"Warning: {msg}", "yellow"))
 
 
+# Set by err(); read via last_error(). See the note in err() for why.
+_LAST_ERROR: str = ""
+
+
+def last_error() -> str:
+    """Return the most recent message passed to err(), or "" if there is none."""
+    return _LAST_ERROR
+
+
+def clear_last_error() -> None:
+    """Forget the recorded error so a later read can't attribute a stale one."""
+    global _LAST_ERROR
+    _LAST_ERROR = ""
+
+
 def err(msg: str):
+    # Last message passed to err(), from any module. A caller that has to report
+    # a failure machine-readably (dulus.py's `--output json` protocol mode) needs
+    # the reason, but almost every failure in an interactive agent is *handled*
+    # and surfaced only as human text right here — there is no exception left to
+    # inspect by the time the run ends. Recording it at this layer catches every
+    # call site regardless of how the module imported err.
+    global _LAST_ERROR
+    _LAST_ERROR = str(msg).strip()
     # Sentry auto-captures only UNCAUGHT exceptions (via the excepthook). Almost
     # every failure in an interactive agent is caught and surfaced right here
     # through err(), so those never reach Sentry — which is why the dashboard

{dulus-3.12.0 → dulus-3.13.0}/docs/CHANGELOG.md

@@ -7,6 +7,39 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [3.12.1] - 2026-08-28
+
+Follow-up to 3.12.0: the channel split and the frame vocabulary were correct,
+but a failed run could still report success. Found by running the 3.12.0 wheel
+against an unauthenticated provider.
+
+### Fixed
+- A one-shot `--output json` run against a provider that fails to authenticate
+  exited `0` with a `text` frame containing the **gold-memory dump** as the
+  assistant's answer. Two defects combined:
+  - The failure was unobservable. Most provider failures do not raise: the
+    provider ends the turn with `AssistantTurn(error=True)` and `agent.run()`
+    rolls the turn's messages back and breaks — no exception, no `TurnDone`,
+    no new assistant message. Neither of 3.12.0's guards (`friendly_api_error`,
+    missing API key) could see it. `AgentState` now carries `last_error` /
+    `last_reply`, recorded by the agent loop for the turn it actually ran, and
+    `common.err()` records the last message reported to the human channel — at
+    that layer, so it catches every module rather than only `dulus.py`.
+  - The answer was not scoped to the turn. Gold memories are appended as
+    `role: "assistant"` at boot, so reading a bare `messages[-1]` after a
+    rolled-back turn returned a memory file. The answer is now resolved from
+    the agent loop's own record of the turn (immune to mid-run auto-compaction,
+    which rebinds `state.messages`), falling back to a scan bounded by the
+    pre-turn message count.
+- A turn that produces no answer is now always `error` + exit `1`, whatever the
+  cause. This is the net for failure modes that are not individually
+  enumerated: they all surface as an empty turn, and an empty turn is never a
+  success. A turn that streams partial text and *then* fails is also a failure
+  — partial text is not an answer.
+- `--version` and `--help` are answered before the channel swap. They emit no
+  frames, so under `--output json` their output landed on stderr and stdout
+  came back empty.
+
 ## [3.12.0] - 2026-08-28
 
 ### Added

{dulus-3.12.0 → dulus-3.13.0}/docs/news.md

@@ -2,6 +2,8 @@
  
 ## 🔥🔥🔥 News (Pacific Time)
 
+- August 28, 2026 (**v3.12.1**): **🚨 A failed run was still reporting success — and answering with your gold memory.** Caught by actually running yesterday's wheel against a provider that wasn't logged in. `--output json` split the channels correctly and the frames were right, but the *verdict* was wrong: `dulus --print --output json -- "di hola"` exited **0** and emitted a `text` frame whose contents were the dump of your golden memory. Two defects stacked. **First, the failure was invisible.** Almost no provider failure raises — the provider ends the turn with `error=True`, the agent loop rolls the turn's messages back and breaks, and there is no exception, no `TurnDone` and no new assistant message left behind. Both of 3.12.0's guards were watching for things that never happened. The agent loop now records *why* the turn it just ran failed, and `err()` records the last thing reported to you — at the shared layer, so it catches every module instead of just the CLI. **Second, the answer wasn't scoped to the turn.** Gold memories are injected as `role: "assistant"` at boot, so reading "the last assistant message" after a rolled-back turn returned a memory file and called it the reply. The answer now comes from the loop's own record of the turn (which also survives mid-run auto-compaction), bounded by the message count from before the turn started. And the floor under all of it: **a turn that produced no answer is always `error` + exit 1**, whatever the cause — including causes we haven't thought of yet, and including a turn that streams half a sentence and then dies. Also fixed: `--version` and `--help` now answer on stdout in every mode instead of vanishing into stderr under `--output json`. If you're embedding Dulus, upgrade past 3.12.0 — this is the difference between "the run failed" and "the run succeeded and said something strange". `pip install --upgrade dulus`. 🦅🇩🇴
+
 - August 28, 2026 (**v3.12.0**): **🔌 Dulus is now embeddable — `--output json`.** Dulus already ran fine as a one-shot (`dulus -p "…"`), but it was impossible to *drive* from another program. Three things were in the way, and all three are fixed. **(1) Channels.** Every human-facing byte — the boot banner, spinners, tool status lines, warnings, Rich's cursor repaints — went to stdout, mixed in with the answer, so a parent process parsing stdout got `🦅 Dulus — [FREE] …` as line one and gave up. `--output json` now reserves stdout for a clean **JSONL protocol stream** and sends *everything else* to stderr — one swap, before the first print can fire. **(2) Frames.** stdout carries four frame types: `step_start` (with the session id), `text` (the assistant's answer), `step_finish` (input/output/cache tokens plus estimated cost, accounted exactly like `/cost` so the two can't disagree), and `error`. We deliberately speak the **OpenCode event-stream dialect** instead of inventing our own, so a tool that already parses that format needs **zero new code** to run Dulus. **(3) Exit codes.** A one-shot run used to exit **0 no matter what** — an expired key, a quota wall, a missing credential, all indistinguishable from success. Now every failure path emits an `error` frame *and* exits non-zero (`130` on Ctrl+C), so a parent can tell a finished run from a dead one. Protocol mode also refuses to hand your prompt to an already-running Dulus over IPC — that would answer in the *other* process's directory and emit no frames at all. Try it: `dulus -p --accept-all --output json -- "explain this repo"`. If the first line of stdout isn't a JSON object, that's a bug — report it. `pip install --upgrade dulus`. 🦅🇩🇴
 
 - August 28, 2026 (**Business update**): **💰 How Dulus makes money — and what stays free.** Worth saying plainly, because "free" is doing a lot of work in this README and you deserve to know which parts are load-bearing.

{dulus-3.12.0 → dulus-3.13.0/dulus.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: dulus
-Version: 3.12.0
+Version: 3.13.0
 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>
@@ -99,7 +99,11 @@ Requires-Dist: pytesseract>=0.3.10; extra == "full"
 # Dulus
 
 <p align="center">
-  <img src="https://raw.githubusercontent.com/KevRojo/Dulus/main/docs/readme/hero.png" alt="Dulus — Hunt. Patch. Ship." width="100%">
+  <img width="1382" height="938" alt="image" src="https://github.com/user-attachments/assets/a2b297e3-53f8-4fce-a91a-6123274c4fc4" />
+</p>
+
+<p align="center">
+  <img width="1179" height="761" alt="image" src="https://github.com/user-attachments/assets/95c8a306-88e6-4f9d-a1aa-009ac38ebeaf" />
 </p>
 
 <p align="center">
@@ -110,6 +114,10 @@ Requires-Dist: pytesseract>=0.3.10; extra == "full"
   Dulus is an open-source agent runtime that hands you a real AI agent the moment you install it —<br>
   talking to Gemini, Claude and GPT through their own web sessions, so you owe no one a key or a cent.<br>
   One runtime. Every model. Your machine. The whole world invited.
+
+  For a better version get the binaries from https://dulus.ai/ there are free models on my /dulus/dulus-* providers, love you guys!
+
+  God bless you! ♥
 </p>
 
 <p align="center">
@@ -222,6 +230,21 @@ Try it and hit me with feedback — it's the token trick I'm proudest of.
 
 ---
 
+## New — Signed binaries, maintained by me
+
+> 📢 The fastest way to run Dulus is the prebuilt app — I keep it updated myself.
+
+The public `pip install dulus` gives you the full open-source runtime. But if you want the **smoothest experience** — auto-updating, code-signed, zero Python setup — grab the **prebuilt binaries** for Windows, macOS and Linux. I maintain those builds personally so they always ship the latest fixes first.
+
+<p align="center">
+  <a href="https://dulus.ai/"><strong>⬇️ Download the binaries → dulus.ai</strong></a> ·
+  <a href="https://github.com/Dulus-Ai/dulus-updates/releases/latest"><strong>GitHub Releases ↗</strong></a>
+</p>
+
+The **premium/desktop core is closed-source on purpose** — that code stays private so it can't be leaked, cloned, or stripped of its license gate. This public repo is the real runtime you can read, fork and build on; the signed binaries are the same runtime plus the private polish, kept safe on my side. Best of both: **open where it counts, protected where it matters.**
+
+---
+
 ## A note from the builder
 
 I'm one developer. No team, no funding, no VC deck — just me, a laptop, and a stubborn little bird from the Dominican Republic. 🇩🇴
@@ -694,7 +717,9 @@ Frames use the OpenCode event-stream dialect, so a consumer that already parses
 | `step_finish` | `part.tokens.input` · `.output` · `.cache.read` · `.cache.write` · `part.cost` |
 | `error` | `message` |
 
-Exit code is `0` on success, `130` on Ctrl+C, and non-zero on any failure — a missing credential, a provider error, an unhandled exception — always alongside an `error` frame. Pass the prompt after `--`: it is a positional argument, so without the terminator a prompt starting with a hyphen is parsed as a flag.
+Exit code is `0` on success, `130` on Ctrl+C, and non-zero on any failure — a missing credential, a provider error, an unhandled exception, or a turn that produced no answer at all — always alongside an `error` frame. A run that streams partial text and then fails is a failure, not a partial success. Pass the prompt after `--`: it is a positional argument, so without the terminator a prompt starting with a hyphen is parsed as a flag.
+
+`--version` and `--help` always answer on stdout, in every mode.
 
 ### Development setup
 

{dulus-3.12.0 → dulus-3.13.0}/dulus.egg-info/SOURCES.txt

@@ -232,18 +232,7 @@ plugin/store.py
 plugin/types.py
 sandbox/README.md
 sandbox/__init__.py
-sandbox/components.json
-sandbox/eslint.config.js
-sandbox/index.html
 sandbox/info.md
-sandbox/package-lock.json
-sandbox/package.json
-sandbox/postcss.config.js
-sandbox/tailwind.config.js
-sandbox/tsconfig.app.json
-sandbox/tsconfig.json
-sandbox/tsconfig.node.json
-sandbox/vite.config.ts
 sandbox/dist/index.html
 sandbox/dist/wallpaper-default.jpg
 sandbox/dist/assets/index-DE51D6wI.css

{dulus-3.12.0 → dulus-3.13.0}/dulus.egg-info/top_level.txt

@@ -35,7 +35,6 @@ multi_agent
 paste_placeholders
 personality_config
 plugin
-plugins
 profiles
 providers
 pyconsole

{dulus-3.12.0 → dulus-3.13.0}/dulus.py

@@ -393,7 +393,7 @@ try:
     from importlib.metadata import version as _pkg_version
     VERSION = _pkg_version("dulus")
 except Exception:
-    VERSION = "3.12.0"  # dev fallback — keep in sync with pyproject.toml
+    VERSION = "3.12.1"  # 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
@@ -439,25 +439,92 @@ def _emit_error(message: str | BaseException) -> None:
     _emit({"type": "error", "message": str(message)})
 
 
-def _final_assistant_text(state: Any) -> str:
-    """Flatten the last assistant message to plain text.
+def _final_assistant_text(state: Any, since: int = 0) -> str:
+    """Flatten this turn's assistant answer to plain text.
+
+    `since` is the message count captured *before* the turn ran. Everything
+    below it — the injected Soul, gold memories (which are appended as
+    `role: "assistant"` at boot), a previous turn's reply — is not this turn's
+    output and must never be reported as it. Reading a bare `messages[-1]`
+    made a failed run look like a success whose answer was the gold memory
+    dump, because a failed turn rolls its own messages back and leaves the
+    boot-time injections on top.
 
     Message content is either a string or a list of blocks — the block form is
     what arrives once thinking is on, where only `type == "text"` blocks are
     the answer.
     """
     msgs = getattr(state, "messages", None) or []
-    last = msgs[-1] if msgs else {}
-    if not isinstance(last, dict) or last.get("role") != "assistant":
-        return ""
-    content = last.get("content", "")
-    if isinstance(content, list):
-        return "\n".join(
-            b["text"] if isinstance(b, dict) else str(b)
-            for b in content
-            if (isinstance(b, dict) and b.get("type") == "text") or isinstance(b, str)
-        )
-    return content if isinstance(content, str) else str(content)
+    for msg in reversed(msgs[since:]):
+        if not isinstance(msg, dict) or msg.get("role") != "assistant":
+            continue
+        content = msg.get("content", "")
+        if isinstance(content, list):
+            return "\n".join(
+                b["text"] if isinstance(b, dict) else str(b)
+                for b in content
+                if (isinstance(b, dict) and b.get("type") == "text") or isinstance(b, str)
+            )
+        return content if isinstance(content, str) else str(content)
+    return ""
+
+
+def _turn_reply_text(state: Any, since: int = 0) -> str:
+    """This turn's assistant answer, or "" when the turn produced none.
+
+    `state.last_reply` is set by the agent loop for the turn it just ran, so it
+    is exact: immune to the boot-time injections and to mid-run auto-compaction,
+    which rebinds `state.messages` and invalidates any index into it. The
+    message scan is the fallback for callers that don't go through
+    `agent.run()`.
+    """
+    reply = getattr(state, "last_reply", None)
+    if reply is not None:
+        return str(reply)
+    return _final_assistant_text(state, since=since)
+
+
+def _emit_turn_result(state: Any, config: dict, since: int = 0) -> int:
+    """Emit this turn's outcome as frames. Returns the intended exit code.
+
+    Order matters: a turn can stream partial text and *then* fail, and partial
+    text is not an answer, so the failure verdict is read first. The emptiness
+    check behind it is the net for every failure mode the callers do not
+    enumerate — including any added later. Provider failures overwhelmingly
+    neither raise nor yield anything the caller can see; what they all have in
+    common is that the turn produced no answer, and that is never a success.
+    """
+    fail = str(getattr(state, "last_error", "") or "").strip()
+    reply = "" if fail else _turn_reply_text(state, since=since)
+    if fail or not reply.strip():
+        _emit_error(_turn_error_message(state))
+        return 1
+    _emit({"type": "text", "part": {"text": reply}})
+    _emit({"type": "step_finish", "part": _usage_part(state, config)})
+    return 0
+
+
+def _turn_error_message(state: Any) -> str:
+    """Best available reason the turn produced no answer.
+
+    Failures reach us three ways, in descending specificity. The agent loop
+    records `state.last_error` when a provider ends a turn with `error=True`
+    (a missing web-auth file, an exhausted quota) — that path raises nothing,
+    yields no `TurnDone` and rolls its own messages back, so it is otherwise
+    completely unobservable. `common.err()` records whatever was last reported
+    to the human channel, which covers the handled-and-printed failures. And
+    if neither fired we still have to fail: an empty run is not a success, so
+    say so plainly rather than exit 0.
+    """
+    reason = str(getattr(state, "last_error", "") or "").strip()
+    if reason:
+        return reason
+    try:
+        import common as _cm
+        reason = (_cm.last_error() or "").strip()
+    except Exception:
+        reason = ""
+    return reason or "model produced no assistant reply"
 
 
 def _usage_part(state: Any, config: dict) -> dict:
@@ -12941,6 +13008,11 @@ def repl(config: dict, initial_prompt: str | None = None):
         # usage, and a non-zero exit on failure. Before this existed a one-shot
         # run always exited 0, so a parent could not tell a completed run from
         # an auth failure.
+        #
+        # The baseline is the message count before the turn: it is what makes
+        # "this turn's answer" a well-defined thing, and therefore what makes
+        # "this turn produced nothing" detectable. See _emit_turn_result.
+        _baseline = len(getattr(state, "messages", []) or [])
         _emit({"type": "step_start", "sessionID": session_id})
         try:
             run_query(initial_prompt)
@@ -12957,8 +13029,9 @@ def repl(config: dict, initial_prompt: str | None = None):
                 sys.exit(1)
             raise
         if _protocol_enabled():
-            _emit({"type": "text", "part": {"text": _final_assistant_text(state)}})
-            _emit({"type": "step_finish", "part": _usage_part(state, config)})
+            _code = _emit_turn_result(state, config, since=_baseline)
+            if _code:
+                sys.exit(_code)
         return
 
     # ── Bracketed paste mode ──────────────────────────────────────────────
@@ -14025,6 +14098,17 @@ def main():
 
     args = parser.parse_args()
 
+    # `--version` and `--help` answer on stdout in every mode. They are
+    # queries, not runs: they emit no frames, so swapping the channel first
+    # would leave stdout empty and hide the answer on stderr.
+    if args.version:
+        print(f"dulus v{VERSION}")
+        sys.exit(0)
+
+    if args.help:
+        print(__doc__)
+        sys.exit(0)
+
     # ── Protocol mode: split the channels before anything can print ────────
     # This must happen before the first print in main() (the license gate is
     # ~90 lines below) or the parent's first stdout line is our banner, not a
@@ -14037,14 +14121,6 @@ def main():
         # human channel is a pipe — without this stderr fills with \033[2K\r.
         os.environ["DULUS_NO_ANIMATIONS"] = "1"
 
-    if args.version:
-        print(f"dulus v{VERSION}")
-        sys.exit(0)
-
-    if args.help:
-        print(__doc__)
-        sys.exit(0)
-
     from config import load_config, save_config, has_api_key
     from providers import detect_provider, PROVIDERS
 

{dulus-3.12.0 → dulus-3.13.0}/pyproject.toml

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