@agentsdock/server 1.0.11 → 1.0.12-beta.1

package/server/codex_app_server.py

@@ -2369,17 +2369,20 @@ class CodexAppServerClient:
         validated["turn"] = _protocol_turn(method, result.get("turn"))
         return validated
 
-    async def run_thread_shell_command(self, thread_id: str, command: str) -> None:
+    async def run_thread_shell_command(
+        self, thread_id: str, command: str, *,
+        before_send: Callable[[], bool] | None = None,
+    ) -> None:
         thread_id = _require_nonempty_string(thread_id, "thread_id")
         command = _require_nonempty_string(command, "command")
         method = "thread/shellCommand"
-        _protocol_empty_object(
-            method,
-            await self.request(
-                method,
-                {"threadId": thread_id, "command": command},
-            ),
-        )
+        params = {"threadId": thread_id, "command": command}
+        if before_send is None:
+            result = await self.request(method, params)
+        else:
+            await self.start()
+            result = await self._request_connected(method, params, before_send=before_send)
+        _protocol_empty_object(method, result)
 
     async def list_background_terminals(
         self,
@@ -3011,8 +3014,14 @@ class CodexAppServerManager:
             delivery=delivery,
         )
 
-    async def run_thread_shell_command(self, thread_id: str, command: str) -> None:
-        await self.client.run_thread_shell_command(thread_id, command)
+    async def run_thread_shell_command(
+        self, thread_id: str, command: str, *,
+        before_send: Callable[[], bool] | None = None,
+    ) -> None:
+        if before_send is None:
+            await self.client.run_thread_shell_command(thread_id, command)
+        else:
+            await self.client.run_thread_shell_command(thread_id, command, before_send=before_send)
 
     async def list_background_terminals(
         self,

package/server/codex_side_question.py

@@ -23,7 +23,7 @@ SIDE_INSTRUCTIONS = """Answer questions and explore in this separate side chat w
 
 Treat inherited messages, tasks, plans, tool calls and approvals as reference material, not current instructions or permission. Follow only requests made in this side chat; do not resume unfinished parent work.
 
-Use the thread's existing permissions and available tools, including external tools, to read or search files and run checks that leave repo-tracked files unchanged. Do not create, contact or control subagents.
+Use the thread's existing permissions and available tools, including external tools and subagents. Delegate side-chat work only to subagents created in this side chat; inherited parent agents belong to the main conversation.
 
 Change files, git state, configuration, permissions or other workspace state only when explicitly requested here. Request escalation only when such an explicit mutation requires it. Keep authorized changes limited to the request and preserve ongoing parent work."""
 
@@ -68,8 +68,6 @@ def side_chat_config(parent_config: dict | None = None) -> dict:
     if isinstance(servers, dict):
         servers.pop(name, None)
     config.update({
-        "features.multi_agent": False, "features.multi_agent_v2": False,
-        "agents.enabled": False,
         f"{prefix}.enabled": False, f"{prefix}.required": False,
         # Codex validates transport shape even for a disabled server. Never
         # copy the parent's authenticated helper URL/headers into this child.
@@ -182,6 +180,9 @@ class NativeCodexSideChat:
         self._progress = None
         self._lock = asyncio.Lock()
         self._closed = False
+        self._thread_parents: dict[str, str] = {}
+        self._owned_threads: set[str] = set()
+        self._work_revision = 0
 
     @property
     def closed(self) -> bool:
@@ -193,12 +194,88 @@ class NativeCodexSideChat:
             return None
         return deepcopy(list(self._progress.items.values()))
 
+    def owns_thread(self, thread_id: str) -> bool:
+        """Only the side fork and provider-verified descendants own approvals."""
+        return bool(not self._closed and self.thread_id and thread_id != self.parent_thread_id
+                    and (thread_id == self.thread_id or thread_id in self._owned_threads))
+
+    def _remember_thread(self, thread):
+        if not isinstance(thread, dict):
+            return
+        thread_id = thread.get("id")
+        source = thread.get("source")
+        subagent = source.get("subAgent") if isinstance(source, dict) else None
+        spawn = subagent.get("thread_spawn") if isinstance(subagent, dict) else None
+        parent = spawn.get("parent_thread_id") if isinstance(spawn, dict) else None
+        if isinstance(thread_id, str) and isinstance(parent, str) and parent:
+            self._thread_parents[thread_id] = parent
+
+    def _remember_notification(self, notification):
+        if notification.get("method") in {"thread/started", "thread/closed", "thread/status/changed", "turn/started", "turn/completed"}:
+            self._work_revision += 1
+        if notification.get("method") == "thread/started":
+            self._remember_thread((notification.get("params") or {}).get("thread"))
+
+    def background_work_scope(self):
+        client = self._client
+        if self._closed or client is None or not client.ready or not self.thread_id:
+            return None
+        return (self, client, client.generation, self.thread_id, self._work_revision)
+
+    async def has_background_work(self):
+        scope = self.background_work_scope()
+        if scope is None:
+            return False
+        _owner, client, _generation, thread_id, _revision = scope
+        descendants = await client.list_descendant_threads(thread_id)
+        if self.background_work_scope() != scope:
+            raise SideQuestionError(409, "Side chat changed during background inspection")
+        # This native relationship-filtered API sees descendants even when
+        # app-server omitted their thread/started notification.
+        for child in descendants:
+            child_id = child.get("id")
+            status = child.get("status")
+            kind = status.get("type") if isinstance(status, dict) else None
+            if child_id in {thread_id, self.parent_thread_id} or not isinstance(child_id, str):
+                raise SideQuestionError(502, "Codex returned an invalid side descendant")
+            if kind == "active":
+                return True
+            if kind not in {"idle", "notLoaded"}:
+                raise SideQuestionError(502, "Codex side descendant activity is unknown")
+        return False
+
+    async def _verify_owned_thread(self, thread_id: str) -> bool:
+        if self.owns_thread(thread_id):
+            return True
+        if not self.thread_id or self._client is None or self._closed:
+            return False
+        path: set[str] = set()
+        current = thread_id
+        while current and current not in path and current != self.parent_thread_id:
+            if self.owns_thread(current):
+                self._owned_threads.update(path)
+                return True
+            path.add(current)
+            if current not in self._thread_parents:
+                try:
+                    thread = await self._client.read_thread(current, include_turns=False)
+                except CodexAppServerError:
+                    return False
+                if self._closed or not isinstance(thread, dict) or thread.get("id") != current:
+                    return False
+                self._remember_thread(thread)
+            current = self._thread_parents.get(current, "")
+        return False
+
     async def _handle_server_request(self, request_id, method, params):
-        # The callback can present approvals through the existing UI, but only
-        # for this exact child. Never route a parent's inherited tool request.
+        # Provider lineage permits side-chat descendants without granting a
+        # parent's inherited tool request or unrelated thread any authority.
         if (self.server_request_handler is not None and not self._closed
-                and self._active is not None and self.thread_id is not None
-                and params.get("threadId") == self.thread_id):
+                and self.thread_id is not None
+                and isinstance(params.get("threadId"), str)
+                and await self._verify_owned_thread(params["threadId"])
+                and not self._closed
+                and (self._active is not None or params["threadId"] != self.thread_id)):
             return await self.server_request_handler(request_id, method, params)
         return await decline_server_request(request_id, method, params)
 
@@ -241,6 +318,7 @@ class NativeCodexSideChat:
             on_process_started=lambda _pid, _group: self._process_started.set(),
             **client_options,
         )
+        self._client.add_notification_handler(self._remember_notification)
         await self._client.start()
         if self._closed:
             raise SideQuestionError(409, "Side chat was closed; open a new side chat")

package/server/cursor_agent_client.py

@@ -18,6 +18,7 @@ draining; this module deliberately contains no process lifecycle state.
 
 from __future__ import annotations
 
+import hashlib
 import json
 import re
 from typing import Any, Iterator
@@ -31,6 +32,13 @@ CURSOR_SESSION_IDENTIFIER_RE = re.compile(
     r"^[A-Za-z0-9][A-Za-z0-9._:-]{0,255}$"
 )
 CURSOR_CALL_ID_MAX_CHARS = 240
+# Cursor 2026.10.22 emits this compound correlation key even for a normal
+# file-read tool. LF is part of the opaque ID, not a second stream event.
+_CURSOR_UUID_PATTERN = r"[0-9a-fA-F]{8}(?:-[0-9a-fA-F]{4}){3}-[0-9a-fA-F]{12}"
+_CURSOR_COMPOSITE_CALL_ID_RE = re.compile(
+    rf"call-{_CURSOR_UUID_PATTERN}-[0-9]+\nfc_{_CURSOR_UUID_PATTERN}_[0-9]+"
+)
+_CURSOR_ENCODED_CALL_ID_PREFIX = "cursor-call-sha256:"
 CURSOR_LIFECYCLE_VALUE_MAX = 2_147_483_647
 CURSOR_ANSI_ESCAPE_RE = re.compile(r"\x1b(?:\[[0-?]*[ -/]*[@-~]|\][^\x07]*(?:\x07|\x1b\\))")
 CURSOR_TOOL_SUCCESS_OUTCOMES = (
@@ -90,7 +98,13 @@ def canonical_cursor_session_id(value: Any) -> str | None:
 
 
 def canonical_cursor_call_id(value: Any) -> str:
-    """Validate the opaque correlation key used by Cursor tool events."""
+    """Bound an opaque tool key and encode the observed compound CLI format.
+
+    Keep the complete key in the digest: stripping LF, keeping only one half,
+    or assigning a fresh ID per event could merge distinct tools or orphan a
+    completion. The encoded namespace is reserved so literal provider IDs
+    cannot collide with it. Arbitrary control characters remain invalid.
+    """
 
     if not isinstance(value, str):
         raise CursorEventParseError("tool_call call_id must be a string")
@@ -98,11 +112,17 @@ def canonical_cursor_call_id(value: Any) -> str:
         not value
         or value != value.strip()
         or len(value) > CURSOR_CALL_ID_MAX_CHARS
-        or any(ord(character) < 32 or ord(character) == 127 for character in value)
     ):
         raise CursorEventParseError(
             "tool_call call_id must be a bounded nonempty identifier"
         )
+    composite = _CURSOR_COMPOSITE_CALL_ID_RE.fullmatch(value) is not None
+    if not composite and any(ord(character) < 32 or ord(character) == 127 for character in value):
+        raise CursorEventParseError(
+            "tool_call call_id must be a bounded nonempty identifier"
+        )
+    if composite or value.startswith(_CURSOR_ENCODED_CALL_ID_PREFIX):
+        return _CURSOR_ENCODED_CALL_ID_PREFIX + hashlib.sha256(value.encode("utf-8", "surrogatepass")).hexdigest()
     return value
 
 

package/server/install.sh

@@ -1846,7 +1846,7 @@ if [[ "$TEAM_HUB_MODE" == "host" && "$TEAM_HUB_OPERATION_PENDING" != "true" \
   fi
 fi
 
-RELEASE_FILES=(activation_transaction.py execution_activation.py execution_legacy_runner.py execution_preparation.py update_preparation.py update_handoff.py update_recovery.py execution_update_status.py execution_uninstall.py execution_recovery.py execution_recovery_status.py execution_http.py execution_durability.py execution_control.py execution_install.py execution_maintenance.py execution_manage.py execution_ownership.py execution_service.py execution_transport.py agent_server.py local_session_ownership.py cursor_history.py workspace_git.py team_hub_host.py secure_peer_runtime.py team_mail_runtime.py team_mail_websocket.py team_mail_grants.py secure_peer_delivery.py agentsdock_jobs.py agentsdock_chats.py chat_mailbox.py agentsdock_emergency.py agentsdock_publish.py agentsdock_mail.py agentsdock_team.py provider_commands.py provider_usage.py claude_sdk_client.py claude_model_catalog.py claude_goals.py claude_background_reconciliation.py codex_app_server.py codex_auth.py codex_provider.py codex_response_stream.py provider_connections.py cursor_api_key.py side_questions.py title_generation.py codex_side_question.py codex_side_chat_progress.py claude_side_question.py cursor_agent_client.py cursor_provider_mcp.py opencode_agent_client.py gemini_acp_client.py gemini_history.py gemini_content.py gemini_import.py gemini_runtime.py gemini_runner.py gemini_permissions.py gemini_api.py cursor_process_guard.py transcript_reader.py claude_history_repair.py claude_history_provenance.py codex_history_repair.py public_chat_shares.py public_chat_transcript.py public_chat_share_routes.py interactive_chat_shares.py interactive_chat_share_routes.py interactive_chat_share_web.py interactive_chat_projection.py interactive_chat_runtime.py interactive_chat_native.py shared_chat_videos.py shared_chat_analytics_web.py shared_chat_video_stream.py interactive_chat_controls.py install.sh uninstall.sh instances.sh server_instances.py npm/agentsdock/pair.cjs npm/agentsdock/qr-renderer.cjs npm/agentsdock/QR-NOTICES.txt update_runner.py pyproject.toml uv.lock VERSION release-public-key.pem LICENSE NOTICE)
+RELEASE_FILES=(activation_transaction.py execution_activation.py execution_legacy_runner.py execution_preparation.py update_preparation.py update_handoff.py update_recovery.py execution_update_status.py execution_uninstall.py execution_recovery.py execution_recovery_status.py execution_http.py execution_durability.py execution_control.py execution_install.py execution_maintenance.py execution_manage.py execution_ownership.py execution_service.py execution_transport.py agent_server.py local_session_ownership.py cursor_history.py workspace_git.py team_hub_host.py secure_peer_runtime.py team_mail_runtime.py team_mail_websocket.py team_mail_grants.py secure_peer_delivery.py agentsdock_jobs.py agentsdock_chats.py chat_mailbox.py agentsdock_emergency.py agentsdock_notify.py agentsdock_publish.py agentsdock_mail.py agentsdock_team.py provider_commands.py provider_usage.py session_unread.py claude_sdk_client.py claude_model_catalog.py claude_goals.py claude_background_reconciliation.py codex_app_server.py codex_auth.py codex_provider.py codex_response_stream.py provider_connections.py cursor_api_key.py side_questions.py title_generation.py codex_side_question.py codex_side_chat_progress.py claude_side_question.py cursor_agent_client.py cursor_provider_mcp.py opencode_agent_client.py gemini_acp_client.py gemini_history.py gemini_content.py gemini_import.py gemini_runtime.py gemini_runner.py gemini_permissions.py gemini_api.py cursor_process_guard.py transcript_reader.py claude_history_repair.py claude_history_provenance.py codex_history_repair.py public_chat_shares.py public_chat_transcript.py public_chat_share_routes.py interactive_chat_shares.py interactive_chat_share_routes.py interactive_chat_share_web.py interactive_chat_projection.py interactive_chat_runtime.py interactive_chat_native.py shared_chat_videos.py shared_chat_analytics_web.py shared_chat_video_stream.py interactive_chat_controls.py install.sh uninstall.sh instances.sh server_instances.py npm/agentsdock/pair.cjs npm/agentsdock/qr-renderer.cjs npm/agentsdock/QR-NOTICES.txt update_runner.py pyproject.toml uv.lock VERSION release-public-key.pem LICENSE NOTICE)
 RELEASE_DIRECTORIES=(agentsdock_team_hub)
 TEAM_HUB_RELEASE_FILES=(
   __init__.py
@@ -3753,11 +3753,13 @@ validate_staged_release_runtime() (
     "$STAGE_DIR/agentsdock_chats.py" \
     "$STAGE_DIR/chat_mailbox.py" \
     "$STAGE_DIR/agentsdock_emergency.py" \
+    "$STAGE_DIR/agentsdock_notify.py" \
     "$STAGE_DIR/agentsdock_publish.py" \
     "$STAGE_DIR/agentsdock_mail.py" \
     "$STAGE_DIR/agentsdock_team.py" \
     "$STAGE_DIR/provider_commands.py" \
     "$STAGE_DIR/provider_usage.py" \
+    "$STAGE_DIR/session_unread.py" \
     "$STAGE_DIR/claude_sdk_client.py" \
     "$STAGE_DIR/claude_model_catalog.py" \
     "$STAGE_DIR/claude_goals.py" \
@@ -4132,7 +4134,7 @@ for name in "${TEAM_HUB_RELEASE_FILES[@]}"; do
     "$SOURCE_DIR/agentsdock_team_hub/$name" \
     "$STAGE_DIR/agentsdock_team_hub/$name"
 done
-chmod 755 "$STAGE_DIR/agent_server.py" "$STAGE_DIR/agentsdock_jobs.py" "$STAGE_DIR/agentsdock_chats.py" "$STAGE_DIR/agentsdock_emergency.py" "$STAGE_DIR/agentsdock_publish.py" "$STAGE_DIR/agentsdock_mail.py" "$STAGE_DIR/agentsdock_team.py" "$STAGE_DIR/install.sh" "$STAGE_DIR/uninstall.sh" "$STAGE_DIR/update_runner.py"
+chmod 755 "$STAGE_DIR/agent_server.py" "$STAGE_DIR/agentsdock_jobs.py" "$STAGE_DIR/agentsdock_chats.py" "$STAGE_DIR/agentsdock_emergency.py" "$STAGE_DIR/agentsdock_notify.py" "$STAGE_DIR/agentsdock_publish.py" "$STAGE_DIR/agentsdock_mail.py" "$STAGE_DIR/agentsdock_team.py" "$STAGE_DIR/install.sh" "$STAGE_DIR/uninstall.sh" "$STAGE_DIR/update_runner.py"
 chmod 755 "$STAGE_DIR/instances.sh"
 
 if [[ "$PREPARE_ONLY" == "true" ]]; then

package/server/public_chat_transcript.py

@@ -28,11 +28,19 @@ class PublicTranscriptError(ValueError):
 def _is_goal_followup(event: dict) -> bool:
     return bool(
         event.get("type") == "turn_steered"
-        and event.get("native_goal_steer") is True
         and event.get("native_steer") is True
         and event.get("provider_user_authored") is True
-        and event.get("backend") == "codex"
-        and event.get("purpose") == "codex_goal_resume"
+        and (
+            (event.get("native_goal_steer") is True
+             and event.get("backend") == "codex"
+             and event.get("purpose") == "codex_goal_resume")
+            or (event.get("native_followup") is True
+                and event.get("backend") == "claude"
+                and event.get("purpose") is None
+                and event.get("provider_generated") is not True
+                and isinstance(event.get("provider_message_id"), str)
+                and event["provider_message_id"].strip())
+        )
         and isinstance(event.get("run_id"), str)
         and event["run_id"].strip()
     )

package/server/session_unread.py

@@ -0,0 +1,184 @@
+"""Incremental unread provenance; journal recovery runs off the event loop."""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Callable, Iterable
+from transcript_reader import jsonl_records
+
+
+COUNTER = "latest_non_job_agent_event_seq"
+CHECKPOINT = "_non_job_agent_event_checkpoint_seq"
+PENDING_COUNTER = "_non_job_agent_event_pending_seq"
+LAST_RUN = "_non_job_agent_last_run"
+JOURNAL = "_non_job_agent_event_journal"
+
+
+def imported_event(event: dict[str, Any]) -> bool:
+    return event.get("imported") is True or str(event.get("run_id") or "").startswith("import_")
+
+
+def scheduled_event(event: dict[str, Any]) -> bool:
+    job = event.get("job")
+    return bool(
+        event.get("purpose") == "scheduled_job"
+        or str(event.get("job_id") or "").strip()
+        or isinstance(job, dict) and str(job.get("id") or "").strip()
+        or str(event.get("type") or "").startswith("job_")
+    )
+
+
+def project_event(
+    session: dict[str, Any], event: dict[str, Any], *,
+    visible: bool, run_metadata: dict[str, Any],
+) -> None:
+    """Apply an appended event without I/O or changing the ordinary read cursor."""
+    seq = int(event.get("seq") or 0)
+    if seq <= 0:
+        return
+    # Only a new journal can establish an empty baseline without recovery.
+    if seq == 1 and not int(session.get("latest_event_seq") or 0):
+        session.setdefault(COUNTER, 0)
+        session.setdefault(CHECKPOINT, 0)
+    known = isinstance(session.get(COUNTER), int) and CHECKPOINT in session
+    run_id = str(event.get("run_id") or "")
+    contexts: list[dict[str, Any]] = []
+    if event.get("type") == "turn_started" and run_id:
+        context = {"run_id": run_id, "scheduled_job": scheduled_event(event) or scheduled_event(run_metadata)}
+        session[LAST_RUN] = context
+        contexts.append(context)
+    else:
+        for candidate in (session.get("active_run"), session.get(LAST_RUN)):
+            if isinstance(candidate, dict) and run_id and candidate.get("run_id") == run_id:
+                contexts.append(candidate)
+    scheduled = scheduled_event(event) or scheduled_event(run_metadata) or any(
+        scheduled_event(context) or context.get("scheduled_job") is True for context in contexts
+    )
+    if scheduled and run_id and (session.get(LAST_RUN) or {}).get("run_id") == run_id:
+        session[LAST_RUN] = {"run_id": run_id, "scheduled_job": True}
+    if visible and not scheduled and not imported_event(event):
+        field = COUNTER if known else PENDING_COUNTER
+        session[field] = max(int(session.get(field) or 0), seq)
+    if known:
+        session[CHECKPOINT] = max(int(session.get(CHECKPOINT) or 0), seq)
+
+
+def recover_projection(
+    path: Path, snapshot: dict[str, Any], *,
+    visible: Callable[[str, dict[str, Any]], bool],
+    resume_offset: Callable[[Path, int], int],
+    prior_events: Callable[[], Iterable[dict[str, Any]]],
+    cancelled: Callable[[], bool],
+) -> dict[str, Any]:
+    """Project one fixed journal extent, then resolve missing run provenance once.
+
+    Legacy chats need one forward pass. A durable checkpoint resumes through the
+    existing sparse index; only an untagged tail run whose start precedes that
+    checkpoint requires a backwards provenance pass. No history is read by the
+    session-list endpoint or the live event projection.
+    """
+    known = isinstance(snapshot.get(COUNTER), int) and CHECKPOINT in snapshot
+    after = int(snapshot.get(CHECKPOINT) or 0) if known else 0
+    latest = int(snapshot.get(COUNTER) or 0) if known else 0
+    through = after
+    last_run = dict(snapshot.get(LAST_RUN) or {})
+    runs: dict[str, dict[str, Any]] = {}
+    unresolved: dict[str, list[dict[str, Any]]] = {}
+
+    def finish(run_id: str, run: dict[str, Any]) -> None:
+        nonlocal latest
+        if run["scheduled"] or not run["visible_seq"]:
+            return
+        if run["origin"]:
+            latest = max(latest, run["visible_seq"])
+        else:
+            unresolved.setdefault(run_id, []).append(run)
+
+    try:
+        source = path.open("rb")
+    except FileNotFoundError:
+        if after or int(snapshot.get("latest_event_seq") or 0):
+            raise
+        return {COUNTER: 0, CHECKPOINT: 0, LAST_RUN: {}}
+    with source:
+        extent = source.seek(0, 2)
+        inode = path.stat().st_ino
+        journal = snapshot.get(JOURNAL) or {}
+        if known and journal and (journal.get("inode") != inode or int(journal.get("offset") or 0) > extent):
+            after = latest = through = 0
+            last_run = {}
+        offset = int(journal.get("offset") or 0) if after and journal.get("inode") == inode else 0
+        source.seek(offset or (resume_offset(path, after) if after else 0))
+        complete_offset = source.tell()
+        for event, ending, raw in jsonl_records(
+            source, end=extent, project=False, require_newline=False, deadline=float("inf"), cancelled=cancelled,
+            max_records=float("inf"), max_nodes=None, max_depth=512,
+            retained_fields=frozenset({"seq", "type", "run_id", "purpose", "job_id", "job", "text", "result_text", "goal", "imported"}),
+        ):
+            if not raw.complete:
+                break  # Leave a concurrently written/crash fragment unclaimed.
+            complete_offset = ending
+            if not isinstance(event, dict):
+                continue
+            seq = int(event.get("seq") or 0)
+            if seq <= after:
+                continue
+            through = max(through, seq)
+            event_type = str(event.get("type") or "")
+            is_visible = visible(event_type, event) and not imported_event(event)
+            run_id = str(event.get("run_id") or "")
+            scheduled = scheduled_event(event)
+            if not run_id:
+                if is_visible and not scheduled:
+                    latest = max(latest, seq)
+                continue
+            if event_type == "turn_started" and run_id in runs:
+                finish(run_id, runs.pop(run_id))
+            run = runs.setdefault(run_id, {"first_seq": seq, "visible_seq": 0, "scheduled": False, "origin": False})
+            run["scheduled"] = run["scheduled"] or scheduled
+            if event_type == "turn_started":
+                run["origin"] = True
+                last_run = {"run_id": run_id, "scheduled_job": scheduled}
+            elif scheduled and last_run.get("run_id") == run_id:
+                last_run["scheduled_job"] = True
+            if is_visible:
+                run["visible_seq"] = max(run["visible_seq"], seq)
+            if event_type in {"turn_finished", "turn_stopped"} and (run["scheduled"] or not run["visible_seq"]):
+                # Completed cron runs do not accumulate with the schedule's
+                # history. A later untagged event is resolved by the single
+                # backwards provenance pass, just like a restart tail.
+                runs.pop(run_id, None)
+        for run_id, run in runs.items():
+            finish(run_id, run)
+    # One reverse pass resolves all tail runs together, including stripped raw
+    # provider events and a job_ran marker emitted after the provider's start.
+    if unresolved:
+        for event in prior_events():
+            if cancelled():
+                raise InterruptedError("unread projection cancelled")
+            run_id = str(event.get("run_id") or "")
+            candidates = unresolved.get(run_id)
+            if not candidates:
+                continue
+            seq = int(event.get("seq") or 0)
+            scheduled = scheduled_event(event)
+            if not scheduled and event.get("type") != "turn_started":
+                continue
+            remaining = []
+            for run in candidates:
+                if seq >= run["first_seq"]:
+                    remaining.append(run)
+                elif not scheduled:
+                    latest = max(latest, run["visible_seq"])
+            if remaining:
+                unresolved[run_id] = remaining
+            else:
+                unresolved.pop(run_id)
+            if not unresolved:
+                break
+        # Legacy output with no recorded job provenance remains ordinary;
+        # merely owning a schedule never suppresses a human conversation.
+        for candidates in unresolved.values():
+            for run in candidates:
+                latest = max(latest, run["visible_seq"])
+    return {COUNTER: latest, CHECKPOINT: through, LAST_RUN: last_run,
+            JOURNAL: {"inode": inode, "offset": complete_offset}}

package/server/side_questions.py

@@ -27,10 +27,11 @@ from fastapi import APIRouter, HTTPException, Request
 from fastapi.responses import JSONResponse
 
 
-MAX_QUESTION_CHARS = 8000
 MAX_HISTORY_ITEMS = 32
 MAX_HISTORY_CHARS = 60000
 MAX_REQUEST_BYTES = 512 * 1024
+# The streamed body limit bounds input; avoid a second, smaller model-text cap.
+MAX_QUESTION_CHARS = MAX_REQUEST_BYTES
 MAX_CONTEXT_CHARS = 60000
 MAX_LOG_BYTES = 4 * 1024 * 1024
 MAX_OUTPUT_BYTES = 1024 * 1024
@@ -369,11 +370,6 @@ class _NativeConversation:
     closed: bool = False
     timer: object = None
     close_task: asyncio.Task | None = None
-
-
-NATIVE_IDLE_SECONDS = 30 * 60
-
-
 class SideQuestions:
     def __init__(self, answer=None, *, native_factory=None, storage_path=None, notify=None, admission_check=None, runtime_settings_for_session=None):
         self.answer = answer
@@ -396,6 +392,43 @@ class SideQuestions:
     def active_work_labels(self):
         return [f"Side chat in {session_id}" for session_id in sorted(self.active_session_ids())]
 
+    def background_work_scopes(self):
+        handles = [(key[1], conversation.handle) for key, conversation in self.conversations.items()
+                   if not conversation.closed and conversation.handle is not None]
+        if self.synced is not None:
+            handles.extend((key[1], handle) for key, handle in self.synced.handles.items())
+        scopes = []
+        for session_id, handle in handles:
+            inspect = getattr(handle, "background_work_scope", None)
+            scope = inspect() if callable(inspect) else None
+            if scope is not None:
+                scopes.append((session_id, handle, scope))
+        return tuple(scopes)
+
+    async def prepare_background_work_snapshot(self, *, timeout_seconds=5.0):
+        scopes = self.background_work_scopes()
+
+        async def inspect(session_id, handle, _scope):
+            try:
+                active = await handle.has_background_work()
+            except Exception:
+                return f"Side chat provider state unknown in {session_id}"
+            return f"Side chat background work in {session_id}" if active else None
+
+        try:
+            values = await asyncio.wait_for(asyncio.gather(*(inspect(*scope) for scope in scopes)),
+                                            timeout=timeout_seconds)
+            labels = tuple(sorted(set(value for value in values if value)))
+        except asyncio.TimeoutError:
+            labels = tuple(f"Side chat provider state unknown in {session_id}" for session_id, _, _ in scopes)
+        return {"scopes": scopes, "labels": labels}
+
+    def background_work_labels_from_snapshot(self, snapshot):
+        scopes = self.background_work_scopes()
+        if snapshot.get("scopes", ()) != scopes:
+            return ["Side chat provider state changed during inspection"]
+        return list(snapshot.get("labels", ()))
+
     async def _close_conversation(self, conversation):
         conversation.closed = True
         if conversation.timer is not None:
@@ -415,7 +448,7 @@ class SideQuestions:
             await asyncio.shield(conversation.close_task)
 
     def _expire_conversation(self, key, conversation):
-        if self.conversations.get(key) is not conversation or conversation.busy:
+        if self.conversations.get(key) is not conversation or conversation.busy or not conversation.closed:
             return
         self.conversations.pop(key, None)
         task = asyncio.create_task(self._close_conversation(conversation), name="side-chat-expiry")
@@ -461,8 +494,9 @@ class SideQuestions:
             raise
         finally:
             conversation.busy = False
-            conversation.timer = asyncio.get_running_loop().call_later(
-                NATIVE_IDLE_SECONDS, self._expire_conversation, key, conversation)
+            if conversation.closed:
+                conversation.timer = asyncio.get_running_loop().call_later(
+                    RECEIPT_TTL_SECONDS, self._expire_conversation, key, conversation)
 
     async def close_conversation(self, owner, session_id, side_chat_id):
         key = (owner, session_id, side_chat_id)
@@ -473,7 +507,7 @@ class SideQuestions:
                 await self.cancel(*receipt_key)
         await self._close_conversation(conversation)
         conversation.timer = asyncio.get_running_loop().call_later(
-            NATIVE_IDLE_SECONDS, self._expire_conversation, key, conversation)
+            RECEIPT_TTL_SECONDS, self._expire_conversation, key, conversation)
 
     def _prune(self):
         now = time.monotonic()
@@ -874,8 +908,6 @@ class SyncedSideChats:
                     self.cleanup_tasks.discard(cleanup)
             if self.tasks.get(key) is asyncio.current_task():
                 self.tasks.pop(key, None)
-                if not self.stopping:
-                    self.timers[key] = asyncio.get_running_loop().call_later(NATIVE_IDLE_SECONDS, self._expire, key)
 
     async def _finish(self, key, side_chat_id, request_id, status, **result):
         async with self._lock(key):
@@ -1053,7 +1085,7 @@ def create_side_question_router(*, authorize, session_exists, runtime: SideQuest
         if not isinstance(request_id, str) or not IDENTIFIER.fullmatch(request_id):
             raise HTTPException(400, "Invalid side question request ID")
         if not isinstance(question, str) or not question.strip() or len(question) > MAX_QUESTION_CHARS:
-            raise HTTPException(400, "Question must contain 1 to 8000 characters")
+            raise HTTPException(400, f"Question must contain 1 to {MAX_QUESTION_CHARS} characters")
         try:
             question.encode("utf-8")
         except UnicodeEncodeError:
@@ -1152,7 +1184,7 @@ def create_side_question_router(*, authorize, session_exists, runtime: SideQuest
                 raise HTTPException(400, "Invalid side conversation ID")
         question = value["question"]
         if not isinstance(question, str) or not question.strip() or len(question) > MAX_QUESTION_CHARS:
-            raise HTTPException(400, "Question must contain 1 to 8000 characters")
+            raise HTTPException(400, f"Question must contain 1 to {MAX_QUESTION_CHARS} characters")
         try:
             question.encode("utf-8")
         except UnicodeEncodeError: