polyrob 1.0.1__tar.gz → 1.0.2__tar.gz

{polyrob-1.0.1/polyrob.egg-info → polyrob-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyrob
-Version: 1.0.1
+Version: 1.0.2
 Summary: POLYROB — autonomous AI agent framework
 Author: The POLYROB Authors
 License-Expression: MIT

{polyrob-1.0.1 → polyrob-1.0.2}/agents/task/agent/core/llm_runner.py

@@ -129,8 +129,12 @@ class LLMRunnerMixin:
 			return False
 
 		if not model_output.action:
-			self.logger.error("Model output has empty action list - this violates the agent contract")
-			self.logger.error("The LLM must ALWAYS provide at least one action. Empty actions are never valid.")
+			# The CALLER decides what an empty list means: the first one is the
+			# bounded planning turn ALLOWED_REASONING_TURNS grants, and it logs
+			# the warning either way. Shouting "violates the contract" at ERROR
+			# here painted two red lines on the REPL for every allowed
+			# reasoning turn (2026-09-17).
+			self.logger.debug("Model output has empty action list")
 			return False
 
 		# Check each action is valid

{polyrob-1.0.1 → polyrob-1.0.2}/agents/task/agent/core/step.py

@@ -260,6 +260,20 @@ class StepMixin:
 
 			raise
 
+	def _browser_rail_usable(self) -> bool:
+		"""False when a custody process has no usable remote browser; warns ONCE."""
+		try:
+			from core.security.browser_rail import browser_rail_status
+			status = browser_rail_status()
+		except Exception:
+			return True  # fail open: let the real launch decide
+		if status.usable:
+			return True
+		if not getattr(self, "_browser_rail_warned", False):
+			self._browser_rail_warned = True
+			self.logger.warning(f"Browser rail unavailable this session: {status.line()}")
+		return False
+
 	async def _prepare_step(self, step_info: Optional[AgentStepInfo] = None):
 		"""Phase 1: pre-LLM setup — refresh context, build the state message, return (state, input_messages)."""
 		# Check cancellation before starting step execution
@@ -385,7 +399,13 @@ class StepMixin:
 			# Get fresh browser context from orchestrator
 			browser_context = await self.get_browser_context()
 
-			# Only get browser state if we have a browser context
+			# Only get browser state if we have a browser context — and only if
+			# the rail can actually open one. In a custody process with no (or an
+			# unreachable) remote browser, get_state() would try to launch, refuse,
+			# and log three ERRORs on EVERY step (prod 2026-09-17: ~200/h). Say it
+			# once per agent and observe nothing.
+			if browser_context and not self._browser_rail_usable():
+				browser_context = None
 			if browser_context:
 				try:
 					# FIX (Dec 2025): Only capture screenshots when vision is enabled

{polyrob-1.0.1 → polyrob-1.0.2}/agents/task/agent/prompts.py

@@ -475,7 +475,8 @@ whose text the user reads. Everything you want them to know goes here.
 - wait_for_response=False: they read it and you continue immediately.
 
 done(text) ENDS the task. Its text is your internal completion record — what you
-finished, for the run log. It is not a second message to the user.
+finished, for the run log. The user NEVER sees it: it is not delivered on any
+surface, so an answer written only into done(text) is an answer nobody receives.
 - Never restate a message you already sent. If you already answered with
   send_message, done(text) is bookkeeping, not a repeat of the answer.
 - Never write done(text) in the third person about yourself ("Answered the owner's
@@ -701,8 +702,9 @@ Paths relative to workspace root (NO 'workspace/' prefix):
 - Bad: 'workspace/report.md'
 
 Task Completion:
-- done(text="...") - Ends the task. The text is your internal completion record.
-- Speak to the user with send_message; done is not a second message to them."""
+- done(text="...") - Ends the task. The text is your internal completion record;
+  the user never sees it.
+- Speak to the user with send_message; done is not a message to them."""
 		else:
 			return """Respond with JSON containing brain state and actions:
 ```json
@@ -804,11 +806,10 @@ Task Completion:
 				"config, goals, owner facts or any owner-only state here; the owner "
 				"can ask you privately. If nothing needs an answer, reply exactly "
 				"[SILENT].")
-			# 2026-09-16: `done` does NOT publish in a room (see
-			# core/surfaces/outbound_mirror.py::build_completion_publish). Saying
-			# so is load-bearing, not a courtesy: a `done()`-only turn — the
-			# majority shape in a DM — would otherwise leave the room with
-			# NOTHING. And `done`'s summary is an internal completion record; the
+			# 2026-09-16: `done` does NOT publish in a room (and since 2026-09-17
+			# nowhere else either — it has no delivery path). Saying so is
+			# load-bearing, not a courtesy: a `done()`-only turn — the majority
+			# shape in a DM — would otherwise leave the room with NOTHING. And `done`'s summary is an internal completion record; the
 			# turn it was published into a live room it read as a status report
 			# to nobody present, quoting the owner's private question back at it.
 			lines.append(

{polyrob-1.0.1 → polyrob-1.0.2}/agents/task/goals/autonomy_marker.py

@@ -23,15 +23,28 @@ _MAX = 512
 #: has no goal row). Membership is what `is_autonomous` answers; the value is
 #: only ever a hint for re-arming, never an authority check.
 _SESSIONS: "OrderedDict[str, Optional[str]]" = OrderedDict()
+#: session_id -> the cron job id it is running (2026-09-18). The approval queue
+#: needs it for the same reason it needs the goal id: an owner-queue ask raised
+#: by a cron run must name its job so an approval re-arms THAT job to run on
+#: the next tick. Without it the approval woke the finished run's session as a
+#: self-wake — a forged turn the money guard refuses — and the agent told the
+#: owner to "trigger it from your seat" for a trade the owner had just approved.
+_CRON_JOBS: "OrderedDict[str, str]" = OrderedDict()
 
 
-def mark_autonomous(session_id: str, goal_id: Optional[str] = None) -> None:
+def mark_autonomous(session_id: str, goal_id: Optional[str] = None,
+                    *, cron_job_id: Optional[str] = None) -> None:
     if not session_id:
         return
     _SESSIONS[session_id] = goal_id
     _SESSIONS.move_to_end(session_id)
     while len(_SESSIONS) > _MAX:
         _SESSIONS.popitem(last=False)
+    if cron_job_id:
+        _CRON_JOBS[session_id] = cron_job_id
+        _CRON_JOBS.move_to_end(session_id)
+        while len(_CRON_JOBS) > _MAX:
+            _CRON_JOBS.popitem(last=False)
 
 
 def is_autonomous(session_id: Optional[str]) -> bool:
@@ -47,3 +60,11 @@ def goal_for_session(session_id: Optional[str]) -> Optional[str]:
     if not session_id:
         return None
     return _SESSIONS.get(session_id)
+
+
+def cron_job_for_session(session_id: Optional[str]) -> Optional[str]:
+    """The cron job this autonomous session is running, or None (a goal or
+    planner run, or an interactive session). None is a real answer."""
+    if not session_id:
+        return None
+    return _CRON_JOBS.get(session_id)

{polyrob-1.0.1 → polyrob-1.0.2}/agents/task/runtime/run_as_session.py

@@ -104,6 +104,7 @@ async def run_task_to_outcome(
     autonomous: bool = False,
     goal_id: str | None = None,
     creator: str | None = None,
+    cron_job_id: str | None = None,
 ):
     """The primary run entry (§2): create_session → run_session → RunOutcome.
 
@@ -121,6 +122,11 @@ async def run_task_to_outcome(
     goal that raised it — otherwise the owner presses /approve and nothing
     happens (039).
 
+    *cron_job_id* (2026-09-18) is the cron twin of *goal_id*: the approval queue
+    stamps it on an owner-queue ask so approving the ask re-arms the JOB to run
+    on the next tick — the run that redeems the grant is a genuine cron turn,
+    where a self-wake into the finished session could never spend.
+
     *creator* (043 A17): the session-creator display label. This helper is
     shared by BOTH the goal dispatcher and cron runner, which resolve to
     different labels ("goal" vs "cron") — so the CALLER must pass it
@@ -175,7 +181,7 @@ async def run_task_to_outcome(
             pre_sid = None
     if autonomous and pre_sid:
         from agents.task.goals.autonomy_marker import mark_autonomous
-        mark_autonomous(pre_sid, goal_id)
+        mark_autonomous(pre_sid, goal_id, cron_job_id=cron_job_id)
 
     kwargs = {"session_id": pre_sid} if pre_sid else {}
     if creator is not None and create_session_accepts(task_agent.create_session, "creator"):
@@ -188,7 +194,7 @@ async def run_task_to_outcome(
         return RunOutcome(session_id=None)
     if autonomous:
         from agents.task.goals.autonomy_marker import mark_autonomous
-        mark_autonomous(session_id, goal_id)
+        mark_autonomous(session_id, goal_id, cron_job_id=cron_job_id)
     status = await task_agent.run_session(user_id, session_id)
     outcome = await build_run_outcome(task_agent, session_id, status)
     if autonomous:

{polyrob-1.0.1 → polyrob-1.0.2}/agents/task/session/feed.py

@@ -9,7 +9,7 @@ _logger = logging.getLogger(__name__)
 
 
 def build_stream_publish(
-    router: Any, session_key: Optional[str], orchestrator: Any = None,
+    router: Any, session_key: Optional[str],
 ) -> Callable[..., Awaitable[None]]:
     """Return an async ``(chunk, step) -> None`` that mirrors a streamed chunk into
     the unified outbound seam (``MessageRouter.publish``) as a partial OutboundMessage.
@@ -29,7 +29,7 @@ def build_stream_publish(
         try:
             from core.surfaces.envelopes import OutboundMessage
 
-            delivered_live = await router.publish(OutboundMessage(
+            await router.publish(OutboundMessage(
                 session_key=session_key,
                 text=chunk,
                 partial=True,
@@ -40,14 +40,6 @@ def build_stream_publish(
                 # and never finalize. `step` is retained for callers but no longer keys.
                 stream_id=session_key,
             ))
-            # A live stream is already the agent's visible reply.  Claim the
-            # same per-turn latch as send_message so a following done() cannot
-            # publish its internal completion recap as a second chat bubble.
-            # Buffered streams deliberately return False: their text still
-            # needs the final discrete message to reach the user.
-            if delivered_live is True and orchestrator is not None:
-                from core.surfaces.turn_reply import mark_reply_published
-                mark_reply_published(orchestrator)
         except Exception as e:  # fail-open: streaming mirror is non-critical
             _logger.debug("stream publish mirror failed: %s", e)
 
@@ -171,7 +163,6 @@ class FeedMixin:
         _mirror = build_stream_publish(
             getattr(self, "_message_router", None),
             getattr(self, "_chat_session_key", None),
-            self,
         )
         if callback is None:
             # Even with no legacy callback, the unified mirror may be active.

{polyrob-1.0.1 → polyrob-1.0.2}/agents/task/task_agent_delivery.py

@@ -420,12 +420,11 @@ class TaskAgentDeliveryMixin:
             #     the previous turn would make this turn's `send_message` look
             #     like a SECOND reply. `reset_turn` is the same call
             #     `_drain_user_messages` makes for a drained batch.
-            # ⚠️ 2026-09-16: this reset no longer re-arms `done()` as a room
-            # fallback — `build_completion_publish` refuses a room session key
-            # outright, because the text it was falling back to is an internal
-            # completion record and publishing it leaked an owner question into a
-            # public group. A room turn that says nothing is now CORRECT (and is
-            # logged by the mirror), not a hole to be plugged with `done`.
+            # ⚠️ 2026-09-16/17: this reset does not re-arm `done()` as a room
+            # fallback — `done` has no delivery path any more, because the text
+            # it was falling back to is an internal completion record and
+            # publishing it leaked an owner question into a public group. A room
+            # turn that says nothing is CORRECT, not a hole to be plugged.
             # Safe: the push above already succeeded, so neither can be left
             # stale behind a rejected submission (the hazard the
             # `set_turn_reply_to` docstring warns about).