Release: staging → main (123 commits)

Dockerfile

@@ -1,6 +1,6 @@
 # minds-anton-scratchpad: the sandbox pod image (anton + scratchpad boot + cloud_turn entrypoint).
 # Consumed by scratchpad-controller (SCRATCHPAD_CONTROLLER__SCRATCHPAD_IMAGE) and Minds.
-# The controller execs `python -m anton.cloud_turn` (whole turn) or
+# The controller execs `python -m anton.cloud_turn` or `/usr/local/bin/cloud-turn` (whole turn) or
 # `/usr/local/bin/scratchpad-boot.sh` (single cell) inside a gVisor pod running as UID 1000.
 FROM python:3.12-slim
 
@@ -69,6 +69,18 @@ RUN printf '#!/bin/sh\nexec python -m anton.core.backends.scratchpad_boot\n' \
       > /usr/local/bin/scratchpad-boot.sh \
     && chmod 0755 /usr/local/bin/scratchpad-boot.sh
 
+# cloud-turn-resident: the pod's main process when the controller enables it; it
+# preloads the turn and forks one process per turn. cloud-turn: what the
+# controller then execs for a turn, handing it to the resident or running it
+# directly when there is none. The launcher is standard library only, so it runs
+# isolated and without site-packages, by the path of the installed module.
+RUN printf '#!/bin/sh\nexec python -m anton.cloud_turn.resident\n' \
+      > /usr/local/bin/cloud-turn-resident \
+    && printf '#!/bin/sh\nexec %s -I -S %s "$@"\n' "$VIRTUAL_ENV/bin/python" \
+      "$(python -c 'import anton.cloud_turn.launcher as m; print(m.__file__)')" \
+      > /usr/local/bin/cloud-turn \
+    && chmod 0755 /usr/local/bin/cloud-turn-resident /usr/local/bin/cloud-turn
+
 # Non-root, matching the pod securityContext (drop ALL caps, no service-account token, fs_group 1000, gVisor).
 RUN useradd -u 1000 -m -s /bin/sh scratchpad
 USER 1000

README.md

@@ -235,6 +235,14 @@ ANTON_LANGFUSE_HEADERS=1
 
 ---
 
+## Self-hosted product identity
+
+A host can supply `ChatSessionConfig.deployment_identity` using `DeploymentIdentity(kind="self-hosted", product_name="Acme Cowork")` from `anton.core.llm.identity`. Anton uses that name, identifies MindsHub as the maker, and explains that users access an operator-managed deployment in the browser. The prompt opens with a neutral identity, leaving the configured name in its authoritative PRODUCT block. These facts take precedence over the default product skill. When such a session recalls the `cowork-product` skill, the deployment's precedence rules come ahead of the skill's default facts; without a deployment identity, the skill is recalled unchanged. The product name is 1 to 64 characters, with no leading or trailing whitespace, control or format characters, unpaired surrogates, or line separators. The host must read it from trusted deployment configuration, never from a chat message or a user's preferences.
+
+The same host supplies `learned_memory_scope` as `personal`, `shared`, `off` or `unavailable`. With a deployment identity, Anton explains the saved-memory state and distinguishes product instructions and operator rules from learned user preferences. It checks saved content before retrieval filters and reports unreadable stores as unverified. Off and unavailable turns skip learned-store reads during prompt assembly and tool-context construction; the host must also supply the appropriate stores and learning policy when constructing Cortex. Without a deployment identity, both identity and memory prompts keep their existing defaults.
+
+These are in-process session inputs. The cloud-turn wire does not transport deployment identity or learned-memory scope.
+
 ## Model-call deadline
 A model call that sends nothing for 10 minutes is stopped, and the turn ends with "The model sent no output for 10 minutes, so the call was stopped." Every piece of text, thinking or tool-call arguments anton reads from the model restarts the 10 minutes, so a slow model that keeps writing is never cut. A non-streamed call gets the 10 minutes for the whole call, including the SDK's own retries. After one call in a turn runs out, every later model call in that turn fails at once. The one exception is the completion check after an answer: when it runs out, the turn ends on the answer that already streamed, marked unverified.
 

anton/analytics.py

@@ -179,7 +179,11 @@
 #                    error_type, grace_granted + grace_tokens ("", "round",
 #                    "ceiling", or "ceiling,round" — the one-time round-cap /
 #                    spend-ceiling extensions granted this turn, and the
-#                    ceiling one's size), verifier_failure + verifier_error_type
+#                    ceiling one's size), limit_continues (times the user
+#                    answered "Keep going" at the spend ceiling or round
+#                    cap), limit_message_continues (times the turn's own
+#                    message carried it past one of those limits without
+#                    asking), verifier_failure + verifier_error_type
 #                    (WHY the completion verifier produced no verdict — the
 #                    loop's truncated/transient/hard/denied class, or
 #                    latched_{hard,truncated,denied,mixed} for a turn that made

anton/chat.py

@@ -1525,7 +1525,7 @@ async def _chat_loop(
     cortex = Cortex(
         global_hc=Hippocampus(global_memory_dir),
         project_hc=Hippocampus(project_memory_dir),
-        mode=settings.memory_mode,
+        mode=settings.effective_memory_mode,
         llm_client=state["llm_client"],
         episodic=episodic if episodic.enabled else None,
     )
@@ -1584,6 +1584,8 @@ async def _chat_loop(
         surface=SURFACE_CLI,
         # The CLI footer shows a streaming tool's live tail (`tool_peek`).
         live_tool_peek=True,
+        # The CLI prints a tool's message to the user as markdown.
+        tool_messages=True,
         proactive_dashboards=settings.proactive_dashboards,
         act_first=settings.act_first,
         output_dir=settings.artifacts_dir,
@@ -1635,7 +1637,7 @@ async def _chat_loop(
     _query_count = 0
     _total_questions = 0  # tracks first 10 questions for time estimates
 
-    from anton.chat_ui import StreamDisplay, EscapeWatcher, ClosingSpinner, QuestionRenderTracker
+    from anton.chat_ui import StreamDisplay, EscapeWatcher, ClosingSpinner, QuestionRenderTracker, is_displayed_tool_result
 
     toolbar = {"stats": "", "status": ""}
     display = StreamDisplay(console, toolbar=toolbar)
@@ -2114,7 +2116,7 @@ def _bottom_toolbar():
                                 ttft = time.monotonic() - t0
                             display.append_text(event.text)
                         elif isinstance(event, StreamToolResult):
-                            if event.name == "scratchpad" and event.action == "dump":
+                            if is_displayed_tool_result(event):
                                 display.show_tool_result(event.content)
                         elif isinstance(event, StreamToolUseStart):
                             display.on_tool_use_start(event.id, event.name)

anton/chat_session.py

@@ -83,7 +83,7 @@ async def rebuild_session(
     # Update cortex with new LLM client and memory mode
     if cortex is not None:
         cortex._llm = state["llm_client"]
-        cortex.mode = settings.memory_mode
+        cortex.mode = settings.effective_memory_mode
 
     # Refresh mind knowledge from remote server
     refresh_knowledge(settings, cortex)
@@ -116,6 +116,8 @@ async def rebuild_session(
         harness=HARNESS_ANTON,
         # WHERE it ran — the other axis, and now the only place "cli" appears.
         surface=SURFACE_CLI,
+        # Same host as chat.py's fresh session: it prints a tool's message.
+        tool_messages=True,
         proactive_dashboards=settings.proactive_dashboards,
         act_first=settings.act_first,
         output_dir=settings.artifacts_dir,

anton/chat_ui.py

@@ -221,6 +221,18 @@ async def wait_for_render(self, question_id: str, *, timeout: float = 1.0) -> No
             self._rendered.pop(question_id, None)
 
 
+def is_displayed_tool_result(event) -> bool:
+    """Whether the CLI prints this `StreamToolResult` permanently.
+
+    A scratchpad dump is the user's own request to see the cells; a tool's
+    `message` is written for the user. Every other result is the agent's
+    input and stays off the screen.
+    """
+    if event.action == "message":
+        return True
+    return event.name == "scratchpad" and event.action == "dump"
+
+
 class StreamDisplay:
     """Manages streaming LLM output with permanent prints and a tiny Live spinner.
 

anton/cloud_turn/__main__.py

@@ -64,6 +64,8 @@
 #: Matches cowork's SSE-side PROGRESS_THROTTLE.
 PROGRESS_WIRE_INTERVAL = 0.25
 
+#: cowork-server's figure sources split a cut cell result at this marker
+#: (cowork/harnesses/anton_harness/figure_sources.py).
 _TRUNCATION_MARKER = "\n[… truncated …]\n"
 
 
@@ -291,14 +293,6 @@ async def _heartbeat() -> None:
         # the event loop thread so the heartbeat ticker above keeps firing
         # instead of the controller seeing the turn go silent and stall it.
         session = await asyncio.get_running_loop().run_in_executor(None, build)
-        # Length of the seeded history — everything anton appends past this
-        # index belongs to this turn. Captured BEFORE turn_stream, so the
-        # current turn's user input lands inside the slice and is trimmed off
-        # below. Guarded: a session double without `.history` skips capture and
-        # the turn degrades to text-only replay (mirrors cowork-server's
-        # in-process harness).
-        seed_len = len(session.history) if hasattr(session, "history") else None
-        compacted = False  # set if anton summarizes history mid-turn
         # Fold in any attachments cowork-server staged into the workspace (read
         # off the mount, so image bytes never crossed the stdin wire). Plain
         # string when there are none. Never fail the turn over this — degrade to
@@ -387,7 +381,6 @@ async def _heartbeat() -> None:
                       "content": _clip_result_content(event.content or "")})
             elif isinstance(event, StreamContextCompacted):
                 logger.info("context compacted: %s", event.message)
-                compacted = True
                 wire({"kind": "compacted", "message": event.message})
             elif isinstance(event, StreamAskUser):
                 logger.info("ask_user question: %s", event.id)
@@ -434,14 +427,14 @@ async def _heartbeat() -> None:
         # Pre-terminal for the same reason as memory and skills: cowork stops
         # reading the stream at the terminal event.
         #
-        # Skipped after a mid-turn compaction: session.history was reassigned,
-        # so seed_len no longer marks this turn's start and slicing could drop
-        # rows or surface an orphan tool_result whose tool_use was summarized
-        # away — an invalid replay. Text-only replay stays valid, so degrade to
-        # it. The failure paths below never reach this line, so a failed or
-        # torn-down turn degrades the same way.
-        if seed_len is not None and not compacted:
-            turn_slice = session.history[seed_len:]
+        # `turn_messages` reads every list the turn wrote to, so a turn that
+        # compacted or hard-truncated mid-turn sends its rows too, beside the
+        # compaction frame above. The failure paths below never reach this
+        # line, so a failed or torn-down turn degrades to text-only replay.
+        # Guarded: a session double without `turn_messages` skips capture and
+        # the turn degrades the same way.
+        if hasattr(session, "turn_messages"):
+            turn_slice = session.turn_messages()
             # Drop this turn's user input (and anything before the first
             # assistant message) so the slice starts where the model replied.
             while turn_slice and (

anton/cloud_turn/contract.py

@@ -48,17 +48,25 @@
       surfaces a card and the user saves it, so nothing reaches the skill store.
   {"kind": "history", "rows": [...]}  - pre-terminal; this turn's tool
       block-rows as [{"role", "content"}], where content holds only tool_use
-      (assistant) or tool_result (user) blocks. cowork persists them as their
-      own hidden `messages` rows so the NEXT turn's history replays a valid
-      tool_use -> tool_result sequence. Omitted after a mid-turn compaction or
-      on failure, in which case that turn replays text-only.
+      (assistant) or tool_result (user) blocks. For a turn that did not
+      compact, cowork persists them as their own hidden `messages` rows so the
+      NEXT turn's history replays a valid tool_use -> tool_result sequence.
+      Sent after a mid-turn compaction or hard truncation too: the rows come
+      from `ChatSession.turn_messages()`, which still holds the messages the
+      swap folded out of history. For such a turn, cowork-server since
+      mindsdb/cowork-server#712 reads the rows for figure sources and stores
+      none, so the next turn replays that turn text-only; older servers store
+      them. Omitted when the turn used no tools, and on failure, in which case
+      that turn replays text-only.
   {"kind": "compaction", "summary": "...", "covered_through": N}  - pre-terminal;
       this turn folded the first N messages of the REQUEST's `history` into
       `summary`. cowork saves both and seeds `summary` + the uncovered tail next
       turn, instead of resending (and re-summarizing) the whole conversation.
-      Mutually exclusive with `history` above, which the same compaction
-      suppresses. Omitted on failure too: the next turn re-seeds the same
-      history and compacts it again.
+      Sent before `history` above when both apply. `covered_through` counts
+      only seeded messages, never this turn's own. The summary text may still
+      describe rows this turn also sends in full under `history`. Omitted on
+      failure too: the next turn re-seeds the same history and compacts it
+      again.
   {"kind": "ask_user", "id", "prompt", "options": [{"value", "label",
       "detail"}], "select", "allow_custom", "timeout_s"}  - interactive turns
       only: a question the turn is now blocked on. Never rate limited.
@@ -81,6 +89,9 @@
 `round_end`, and `turn_ended` ({"ended_by": "..."}, sent before the terminal
 event when a turn handed back early). A `heartbeat` only resets the
 controller's stall timer.
+A `tool_result` with `action: "message"` is a tool's message to the user,
+rendered as an agent message; the pod sends it only when the request set
+`tool_messages`.
 
 Answer lines on stdin (interactive turns only), one JSON object per line,
 at most 64 KB:
@@ -214,6 +225,12 @@ class TurnRequestV1:
     #: answer lines from stdin. Anything but a JSON `true` reads as False, so a
     #: controller that does not know the field leaves every turn non-interactive.
     interactive: bool = False
+    #: Whether the client watching this turn renders a tool's message to the
+    #: user (a `tool_result` with `action: "message"`) as an agent message —
+    #: the cowork UI does, channel bots do not. Without it the pod drops those
+    #: messages and the tool hands the content to the agent instead. Anything
+    #: but a JSON `true` reads as False.
+    tool_messages: bool = False
     #: Per-engine connector data cowork-server resolved for this turn:
     #: {engine: {"usage_notes": str}}. Rendered only for engines the turn's
     #: vault connects. Absent when no connected engine has notes.
@@ -248,6 +265,7 @@ def from_json(raw: str) -> "TurnRequestV1":
                 d.get("started_at") if isinstance(d.get("started_at"), str) else None
             ),
             interactive=d.get("interactive") is True,
+            tool_messages=d.get("tool_messages") is True,
             # Same defensive isinstance check as oauth/trace.
             connectors=(
                 d.get("connectors") if isinstance(d.get("connectors"), dict) else None