Make your computer a home for your AI partner. Avibe is the local-first Agent OS: Vibey, its built-in AI partner, works out of the box, and Claude Code, Codex & OpenCode run unchanged beside it — reach them from your browser, phone, or any chat app.
Python agentagent-osaiai-agentsai-partnerchatopsclaudeclaude-codecodexdevtoolsdiscord-botlark-botllmlocal-firstlong-term-memoryopencodeslack-botvibe-codingvibeywechat
fix(runtime): raise agent task budget and reclaim disposable runs (#2145)
Call Whiteebebb64d3ca5
diff --git a/core/controller.py b/core/controller.pyindex bd98891f4..42d7edb38 100644--- a/core/controller.py+++ b/core/controller.py@@ -1880,7 +1880,7 @@ class Controller:await self._stop_model_hub_snapshot_reconciliation()- service_stops: list[asyncio.Task[None]] = []+ service_stops: list[tuple[str, asyncio.Task[None]]] = []for service_name in ("model_hub_service","scheduled_task_service",@@ -1890,13 +1890,33 @@ class Controller:stop = getattr(service, "stop", None)if callable(stop):service_stops.append(- asyncio.create_task(- stop(),- name=f"controller-{service_name}-stop",+ (+ service_name,+ asyncio.create_task(+ stop(),+ name=f"controller-{service_name}-stop",+ ),))- results = await asyncio.gather(*service_stops, return_exceptions=True)+ results = await asyncio.gather(+ *(task for _, task in service_stops), return_exceptions=True+ )errors = [result for result in results if isinstance(result, BaseException)]+ # Stopping the task service settles its in-flight Runs. Disposable+ # runtimes waiting on those rows must then finish before the loop exits,+ # especially adopted OpenCode servers that survive normal shutdown. If+ # that settlement owner failed, the waiting tasks cannot safely finish.+ task_service_failed = any(+ service_name == "scheduled_task_service"+ and isinstance(result, BaseException)+ for (service_name, _), result in zip(service_stops, results)+ )+ drain_close_after = getattr(dispatcher, "drain_close_after_runtime", None)+ if callable(drain_close_after) and not task_service_failed:+ try:+ await drain_close_after()+ except BaseException as exc: # noqa: BLE001+ errors.append(exc)stop_supervisor = getattr(supervisor, "stop", None)if callable(stop_supervisor):try:diff --git a/core/handlers/session_handler.py b/core/handlers/session_handler.pyindex a4781da49..82c40aca0 100644--- a/core/handlers/session_handler.py+++ b/core/handlers/session_handler.py@@ -47,7 +47,11 @@ from core.managed_skills import (managed_skill_project_base,)from core.message_context import build_thread_session_anchor, resolve_context_thread_id-from core.resource_governance import governor_from_controller+from core.resource_governance import (+ observe_agent_resource_pressure,+ governor_from_controller,+ pids_failure_labels,+)from core.runtime_activation import RuntimeActivationIdentityfrom core.services.session_fork import pending_native_fork_sourcefrom core.system_prompt_injection import (@@ -2757,7 +2761,11 @@ class SessionHandler(BaseHandler):if returncode is not None:reason_key, reason_values = claude_process_exit_reason_i18n(returncode)reason = self._t(reason_key, **reason_values)- diagnostic = self.claude_error_diagnostic(composite_key, error)+ diagnostic = self.claude_error_diagnostic(+ composite_key,+ error,+ client=client,+ )logger.error("Claude process for session %s terminated (%s): %s",composite_key,@@ -2774,11 +2782,20 @@ class SessionHandler(BaseHandler):expected_client=client,reason="process_terminated",)+ message = self._t("error.claudeProcessTerminated", reason=reason)+ resource_failure = getattr(client, "_vibe_resource_failure", None)+ if resource_failure is not None:+ if resource_failure.kind == "pids":+ language = str(getattr(self.controller.config, "language", "en") or "en")+ message = (+ f"{message} "+ f"{self._t('error.agentPidsLimit', **pids_failure_labels(resource_failure, language))}"+ )+ elif resource_failure.kind == "memory":+ message = f"{message} {self._t('error.agentMemoryLimit')}"await self._get_im_client(context).send_message(context,- self._get_formatter(context).format_error(- self._t("error.claudeProcessTerminated", reason=reason)- ),+ self._get_formatter(context).format_error(message),)return Falseif "read() called while another coroutine" in error_msg:@@ -2823,13 +2840,34 @@ class SessionHandler(BaseHandler):)return False- def claude_error_diagnostic(self, composite_key: str, error: Exception) -> str:+ def claude_error_diagnostic(+ self,+ composite_key: str,+ error: Exception,+ *,+ client=None,+ ) -> str:"""Add process state and captured stderr to a Claude failure diagnostic."""diagnostic = str(error)- client = self.claude_sessions.get(composite_key)+ # Callers that observe a concrete failed generation pass it through so a+ # replacement registered under the same composite key cannot steal the+ # diagnosis. The optional fallback preserves older direct callers.+ if client is None:+ client = self.claude_sessions.get(composite_key)returncode = get_claude_client_returncode(client)if returncode is not None:diagnostic = f"{diagnostic}\nClaude process terminated: {claude_process_exit_reason(returncode)}"+ resource_failure = getattr(client, "_vibe_resource_failure", None)+ if not getattr(client, "_vibe_resource_failure_checked", False):+ if resource_failure is None and not self.claude_teardown_is_intentional(+ composite_key, error, client=client+ ):+ resource_failure = observe_agent_resource_pressure(self.controller)+ if resource_failure is not None:+ setattr(client, "_vibe_resource_failure", resource_failure)+ setattr(client, "_vibe_resource_failure_checked", True)+ if resource_failure is not None:+ diagnostic = f"{diagnostic}\nResource diagnosis: {resource_failure.message}"stderr_tail = get_claude_client_stderr_tail(client)if stderr_tail:diagnostic = f"{diagnostic}\nClaude stderr tail:\n{stderr_tail}"diff --git a/core/message_dispatcher.py b/core/message_dispatcher.pyindex a07af7029..143987034 100644--- a/core/message_dispatcher.py+++ b/core/message_dispatcher.py@@ -57,7 +57,11 @@ from core.run_settlement import ()from core.session_activities import SessionActivityfrom core.session_turns import emit_matches_active_turn-from storage.background import SQLiteBackgroundTaskStore+from storage.background import (+ SQLiteBackgroundTaskStore,+ TERMINAL_RUN_STATUSES,+ normalize_run_status,+)from vibe.i18n import t as i18n_tlogger = logging.getLogger(__name__)@@ -324,6 +328,8 @@ class ConsolidatedMessageDispatcher:# progress signal. Heartbeat re-renders do NOT go through the emit path,# so they never inflate it. Dropped per turn in ``_drop_status_keys``.self._status_step_count: dict[str, int] = {}+ self._close_after_runtime_tasks: set[asyncio.Task] = set()+ self._close_after_session_ids: set[str] = set()# Current context-window occupancy (keyed by SESSION key, not turn-key) so# the footer can show "{n} tok" of context the session is using. Backends# report the latest snapshot via ``note_session_tokens(total=…)`` (Claude:@@ -441,11 +447,47 @@ class ConsolidatedMessageDispatcher:else SETTLED_BY_TURN_ONLY_RESULT)- def _release_runtime_turn(self, context: MessageContext) -> None:+ def _release_runtime_turn(+ self, context: MessageContext, output_semantics: MessageOutput+ ) -> None:service = getattr(self.controller, "agent_service", None)release = getattr(service, "release_runtime_turn", None)- if callable(release):- release(context)+ payload = getattr(context, "platform_specific", None) or {}+ settlement = self._turn_release_settlement(output_semantics)+ # Turn-only Activity delivery failure leaves its Run with the retry+ # owner. A stopped/refresh result is resultless but has a separate+ # Run-settlement writer, so it still qualifies for close-after.+ # Terminal results arm close-after only after their Run write succeeds.+ # Resultless settlements have a separate writer before this release.+ run_terminal = settlement in SETTLEMENTS_WITHOUT_RESULT+ wait_for_run_ids = tuple(payload.pop("_close_after_wait_for_run_ids", ()))+ if run_terminal and payload.get("close_after"):+ # The Turn writer can fail after the resultless output is delivered.+ # Do not reserve or dispose the runtime until its Runs are terminal.+ wait_for_run_ids = tuple(+ dict.fromkeys(+ (*wait_for_run_ids, *self._terminal_agent_run_ids(context, output_semantics))+ )+ )+ should_close = bool(payload.pop("_close_after_runtime_pending", False)) or bool(+ payload.get("close_after") and run_terminal+ )+ lease = None+ try:+ reserve = getattr(service, "reserve_close_after_teardown", None)+ if should_close and not wait_for_run_ids and callable(reserve):+ lease = reserve(context)+ elif callable(release):+ release(context)+ finally:+ if should_close and lease is not False:+ self._schedule_close_after_runtime(+ context, lease=lease, wait_for_run_ids=wait_for_run_ids+ )+ elif wait_for_run_ids:+ self._schedule_close_after_runtime(+ context, wait_for_run_ids=wait_for_run_ids+ )async def _finish_processing_indicator_turn(self, context: MessageContext) -> None:service = getattr(self.controller, "processing_indicator", None)@@ -1241,7 +1283,7 @@ class ConsolidatedMessageDispatcher:terminal_error: str | None,output_semantics: MessageOutput,provenance: dict[str, Any],- ) -> None:+ ) -> list[str]:normalized_run_ids = list(dict.fromkeys(run_id@@ -1279,7 +1321,7 @@ class ConsolidatedMessageDispatcher:error=terminal_error,deferred_run_ids=deferred_run_ids,)- return+ return deferred_run_idsget_run = getattr(store, "get_run", None)eligible_run_ids = ([@@ -1304,11 +1346,13 @@ class ConsolidatedMessageDispatcher:):notification["fallback_run_id"] = min(eligible_run_ids)terminal_provenance["turn_failure_notification"] = notification+ deferred_run_ids: list[str] = []for run_id in normalized_run_ids:if callable(get_run) and _run_is_cancelled(get_run(run_id)):continuerun_terminal_status = terminal_statusif run_terminal_status and self._run_has_blocking_activity(run_id):+ deferred_run_ids.append(run_id)defer_terminal = getattr(store, "defer_run_terminal", None)if callable(defer_terminal):defer_kwargs = {@@ -1356,6 +1400,7 @@ class ConsolidatedMessageDispatcher:run_id,**record_kwargs,)+ return deferred_run_idsdef _terminal_agent_run_ids(self,@@ -1627,7 +1672,7 @@ class ConsolidatedMessageDispatcher:store = Nonetry:store = SQLiteBackgroundTaskStore()- self._record_agent_run_terminal_for_ids(+ deferred_run_ids = self._record_agent_run_terminal_for_ids(store=store,run_ids=run_ids,text=text,@@ -1641,9 +1686,253 @@ class ConsolidatedMessageDispatcher:logger.warning("Failed to record %s for %s: %s", log_label, ",".join(run_ids), err)if require_confirmation:raise+ returnfinally:if store is not None:store.close()+ if semantics.settles_run:+ payload = getattr(context, "platform_specific", None) or {}+ defer_close_after = bool(+ payload.get("close_after")+ and semantics.completes_turn+ and not semantics.detached+ and self._is_current_runtime_turn(context)+ )+ if deferred_run_ids:+ if defer_close_after:+ payload["_close_after_wait_for_run_ids"] = tuple(deferred_run_ids)+ else:+ self._schedule_close_after_runtime(+ context, wait_for_run_ids=tuple(deferred_run_ids)+ )+ elif defer_close_after:+ payload["_close_after_runtime_pending"] = True+ else:+ self._schedule_close_after_runtime(context)++ async def _wait_for_close_after_runs(self, run_ids: tuple[str, ...]) -> bool:+ """Wait for the Run writer, not a Turn output, to finish disposal ownership."""++ from core.inbox_events import RUNS_UPDATED_EVENT, bus++ request_store = getattr(+ getattr(self.controller, "scheduled_task_service", None),+ "request_store",+ None,+ )+ own_store = request_store is None+ if own_store:+ request_store = SQLiteBackgroundTaskStore()+ get_run = getattr(request_store, "get_run", None)+ if not callable(get_run):+ if own_store:+ request_store.close()+ return False+ subscription_id, queue = bus.subscribe()+ try:+ while True:+ runs = [get_run(run_id) for run_id in run_ids]+ if any(not isinstance(run, dict) for run in runs):+ logger.warning(+ "Skipping close-after: a Run is missing for %s",+ ",".join(run_ids),+ )+ return False+ if all(+ normalize_run_status(run["status"]) in TERMINAL_RUN_STATUSES+ for run in runs+ ) and not any(self._run_has_blocking_activity(run_id) for run_id in run_ids):+ return True+ if getattr(self, "_close_after_settlement_closed", False):+ logger.warning(+ "Skipping close-after teardown: Run settlement did not finish for %s",+ ",".join(run_ids),+ )+ return False+ try:+ event_type, payload = await asyncio.wait_for(queue.get(), timeout=5)+ except TimeoutError:+ continue+ if (+ event_type != RUNS_UPDATED_EVENT+ or not isinstance(payload, dict)+ or str(payload.get("run_id") or "") not in run_ids+ ):+ continue+ finally:+ bus.unsubscribe(subscription_id)+ if own_store:+ request_store.close()++ def defer_close_after_until_run_terminal(self, context: MessageContext) -> None:+ """Pre-native Stop has no terminal emit; its Run writer owns close-after."""++ payload = getattr(context, "platform_specific", None) or {}+ if not payload.get("close_after"):+ return+ run_id = str(payload.get("task_execution_id") or "").strip()+ if run_id:+ self._schedule_close_after_runtime(+ context, wait_for_run_ids=(run_id,)+ )++ def _schedule_close_after_runtime(+ self,+ context: MessageContext,+ *,+ lease: tuple[str, str, asyncio.Task | None] | None = None,+ wait_for_run_ids: tuple[str, ...] = (),+ ) -> None:+ """Release a runtime explicitly marked disposable after its Run settles."""++ payload = getattr(context, "platform_specific", None) or {}+ if not bool(payload.get("close_after")):+ return+ session_id = str(payload.get("agent_session_id") or "").strip()+ target = payload.get("agent_session_target")+ target = target if isinstance(target, dict) else {}+ backend = str(+ payload.get("agent_backend")+ or target.get("agent_backend")+ or ""+ ).strip()+ base_session_id = str(+ target.get("session_anchor")+ or payload.get("backend_base_session_id")+ or ""+ ).strip()+ if (+ not session_id+ or not base_session_id+ or backend not in {"claude", "codex", "opencode"}+ ):+ if lease is not None:+ release_lease = getattr(+ getattr(self.controller, "agent_service", None),+ "release_runtime_turn_key",+ None,+ )+ if callable(release_lease):+ release_lease(lease[0], lease[1])+ logger.warning(+ "close-after requested without a disposable runtime target: session_id=%s base_session_id=%s backend=%s",+ session_id,+ base_session_id,+ backend,+ )+ return+ if session_id in self._close_after_session_ids:+ if lease is not None:+ release_lease = getattr(+ getattr(self.controller, "agent_service", None),+ "release_runtime_turn_key",+ None,+ )+ if callable(release_lease):+ release_lease(lease[0], lease[1])+ return+ self._close_after_session_ids.add(session_id)+ backend_cleanup = payload.get("_close_after_backend_cleanup")++ async def _close() -> None:+ # A backend may finish its own post-result cleanup after the shared+ # terminal boundary. Keep its gate reserved until that task exits.+ current_lease = lease+ try:+ if wait_for_run_ids and not await self._wait_for_close_after_runs(+ wait_for_run_ids+ ):+ return+ if isinstance(backend_cleanup, asyncio.Event):+ await backend_cleanup.wait()+ await asyncio.sleep(0)+ if current_lease is not None and current_lease[2] is not None:+ await asyncio.wait({current_lease[2]})+ runtime_key = str(+ payload.get("agent_runtime_turn_key") or ""+ ).strip()+ service = getattr(self.controller, "agent_service", None)+ if current_lease is None:+ reserve_idle = getattr(service, "reserve_idle_close_after_teardown", None)+ current_lease = (+ await reserve_idle(runtime_key)+ if runtime_key and callable(reserve_idle)+ else False+ )+ if current_lease is False:+ logger.info(+ "Skipping close-after teardown for Agent Session %s: "+ "runtime %s is busy or its gate identity is unavailable",+ session_id,+ runtime_key,+ )+ return+ manager = getattr(self.controller, "session_turns", None)+ has_successor = getattr(manager, "has_close_after_successor", None)+ if callable(has_successor):+ try:+ if has_successor(+ session_id,+ str(payload.get("turn_token") or "").strip(),+ ):+ logger.info(+ "Skipping close-after teardown for Agent Session %s: "+ "a durable successor owns the runtime",+ session_id,+ )+ return+ except Exception:+ logger.exception(+ "Skipping close-after teardown for Agent Session %s: "+ "durable successor check failed",+ session_id,+ )+ return+ from core.services.running_agents import end_running_agent++ result = await end_running_agent(+ self.controller,+ backend=backend,+ session_id=session_id,+ base_session_id=base_session_id or None,+ )+ if not result.get("ok") and result.get("error") != "session_not_live":+ logger.warning(+ "close-after failed for Agent Session %s: %s",+ session_id,+ result,+ )+ except Exception:+ logger.warning(+ "close-after runtime teardown failed for Agent Session %s",+ session_id,+ exc_info=True,+ )+ finally:+ if current_lease is not None and current_lease is not False:+ release_lease = getattr(+ getattr(self.controller, "agent_service", None),+ "release_runtime_turn_key",+ None,+ )+ if callable(release_lease):+ release_lease(current_lease[0], current_lease[1])+ self._close_after_session_ids.discard(session_id)++ task = asyncio.create_task(+ _close(),+ name=f"agent-runtime-close-after-{session_id}",+ )+ self._close_after_runtime_tasks.add(task)+ task.add_done_callback(self._close_after_runtime_tasks.discard)++ async def drain_close_after_runtime(self) -> None:+ """Join teardowns after the Run settlement owner has stopped."""++ self._close_after_settlement_closed = True+ while self._close_after_runtime_tasks:+ tasks = tuple(self._close_after_runtime_tasks)+ await asyncio.gather(*(asyncio.shield(task) for task in tasks))def _schedule_agent_run_activity(self,@@ -2528,7 +2817,7 @@ class ConsolidatedMessageDispatcher:finally:if mutates_turn_lifecycle:await self._finish_processing_indicator_turn(context)- self._release_runtime_turn(context)+ self._release_runtime_turn(context, output_semantics)# Resolve the delivery target once. Routed / post_to / thread replies# land in a different channel than the source context, and the persisted@@ -2666,7 +2955,7 @@ class ConsolidatedMessageDispatcher:finally:if mutates_turn_lifecycle:await self._finish_processing_indicator_turn(context)- self._release_runtime_turn(context)+ self._release_runtime_turn(context, accepted_output_semantics)if activity_batch_incomplete:raise ActivityOutputDeliveryError(@@ -2803,7 +3092,7 @@ class ConsolidatedMessageDispatcher:finally:if mutates_turn_lifecycle:await self._finish_processing_indicator_turn(context)- self._release_runtime_turn(context)+ self._release_runtime_turn(context, output_semantics)if canonical_type == "notify":# Three steps, three error scopes — deliberately NOT one blanket ``try``.@@ -3300,7 +3589,7 @@ class ConsolidatedMessageDispatcher:finally:if mutates_turn_lifecycle:await self._finish_processing_indicator_turn(context)- self._release_runtime_turn(context)+ self._release_runtime_turn(context, output_semantics)if canonical_type not in {"system", "assistant", "toolcall"}:canonical_type = "assistant"diff --git a/core/resource_governance.py b/core/resource_governance.pyindex 76379f41f..230cbf57e 100644--- a/core/resource_governance.py+++ b/core/resource_governance.py@@ -4,11 +4,12 @@ from __future__ import annotationsimport loggingimport os-from dataclasses import dataclass+from dataclasses import dataclass, replacefrom pathlib import Pathfrom typing import Anyfrom config import paths as config_paths+from vibe.i18n import t as i18n_tlogger = logging.getLogger(__name__)@@ -17,7 +18,7 @@ DEFAULT_GROUP_NAME = "avibe-agents"DEFAULT_RUNTIME_GROUP_NAME = "avibe-runtime"DEFAULT_AGENT_CPU_WEIGHT = 50DEFAULT_AGENT_IO_WEIGHT = 50-DEFAULT_AGENT_PIDS_MAX = 512+DEFAULT_AGENT_PIDS_MAX = 4096DEFAULT_AGENT_OOM_SCORE_ADJ = 500MIN_AGENT_MEMORY_MAX_BYTES = 512 * 1024 * 1024MIB = 1024 * 1024@@ -39,6 +40,43 @@ class AgentResourceLimits:oom_score_adj: int = DEFAULT_AGENT_OOM_SCORE_ADJ+@dataclass(frozen=True)+class AgentResourceSnapshot:+ pids_current: int | None+ pids_max: int | None+ pids_events: dict[str, int]+ memory_events: dict[str, int]+++@dataclass(frozen=True)+class AgentResourceFailure:+ kind: str+ message: str+ pids_current: int | None = None+ pids_max: int | None = None+ event_delta: int | None = None+++def pids_failure_labels(+ failure: AgentResourceFailure,+ language: str,+) -> dict[str, str]:+ """Preserve zero and distinguish unavailable cgroup counts in user copy."""++ return {+ "current": (+ str(failure.pids_current)+ if failure.pids_current is not None+ else i18n_t("error.agentPidsCurrentUnavailable", language)+ ),+ "limit": (+ str(failure.pids_max)+ if failure.pids_max is not None+ else i18n_t("error.agentPidsLimitUnavailable", language)+ ),+ }++def _read_text(path: Path) -> str | None:try:return path.read_text(encoding="utf-8").strip()@@ -66,6 +104,44 @@ def _parse_pid(value: str | None) -> int | None:return pid if pid > 0 else None+def _parse_non_negative_int(value: str | None) -> int | None:+ if not value:+ return None+ try:+ parsed = int(value.strip())+ except ValueError:+ return None+ return parsed if parsed >= 0 else None+++def _parse_counter_file(path: Path) -> dict[str, int]:+ text = _read_text(path)+ if not text:+ return {}+ counters: dict[str, int] = {}+ for line in text.splitlines():+ name, _, raw_value = line.partition(" ")+ if not name or not raw_value:+ continue+ try:+ value = int(raw_value.strip())+ except ValueError:+ continue+ if value >= 0:+ counters[name] = value+ return counters+++def _parse_pids_max(value: str | None) -> int | None:+ if not value or value == "max":+ return None+ try:+ parsed = int(value)+ except ValueError:+ return None+ return parsed if parsed > 0 else None++def _round_down_mib(value: int) -> int:return max(MIB, (int(value) // MIB) * MIB)@@ -129,9 +205,29 @@ def tenant_memory_limit_bytes(cgroup: Path | None = None, root: Path | None = Noreturn None+def tenant_pid_limit(cgroup: Path, root: Path) -> int | None:+ """The tightest PID cap from the tenant through its cgroup ancestors."""++ root = root.resolve()+ cursor = cgroup.resolve()+ if cursor != root and root not in cursor.parents:+ return None+ limits: list[int] = []+ while True:+ limit = _parse_pids_max(_read_text(cursor / "pids.max"))+ if limit is not None:+ limits.append(limit)+ if cursor == root:+ break+ cursor = cursor.parent+ return min(limits) if limits else None++def derive_agent_limits(tenant_memory_bytes: int | None,config: dict[str, Any] | None = None,+ *,+ tenant_pids_max: int | None = None,) -> AgentResourceLimits:config = config or {}@@ -148,6 +244,11 @@ def derive_agent_limits(cpu_weight = max(1, min(10_000, _int_config("agent_cpu_weight", DEFAULT_AGENT_CPU_WEIGHT)))io_weight = max(1, min(10_000, _int_config("agent_io_weight", DEFAULT_AGENT_IO_WEIGHT)))pids_max = max(32, _int_config("agent_pids_max", DEFAULT_AGENT_PIDS_MAX))+ if tenant_pids_max is not None:+ # The agent group is a sibling of avibe-runtime under this cap. Keep+ # explicit runtime headroom even when the configured agent cap is high.+ runtime_reserve = max(64, tenant_pids_max // 4)+ pids_max = min(pids_max, max(1, tenant_pids_max - runtime_reserve))oom_score_adj = max(-1000, min(1000, _int_config("agent_oom_score_adj", DEFAULT_AGENT_OOM_SCORE_ADJ)))explicit_max = _int_config("agent_memory_max_bytes", 0)@@ -367,13 +468,14 @@ class AgentResourceGovernor:root: Path | None = None,base_cgroup: Path | None = None,) -> None:- self.config = config or {}+ self.config = dict(config or {})self.root = rootself.base_cgroup = base_cgroupself._base: Path | None = Noneself._group: Path | None = Noneself._limits: AgentResourceLimits | None = Noneself._disabled_reason: str | None = None+ self._event_baseline: AgentResourceSnapshot | None = None@propertydef mode(self) -> str:@@ -389,11 +491,38 @@ class AgentResourceGovernor:return self._limitsdef update_config(self, config: dict[str, Any] | None) -> None:- self.config = config or {}+ updated = dict(config or {})+ if updated == self.config:+ return+ old_group_name = str(self.config.get("agent_group_name") or DEFAULT_GROUP_NAME).strip() or DEFAULT_GROUP_NAME+ new_group_name = str(updated.get("agent_group_name") or DEFAULT_GROUP_NAME).strip() or DEFAULT_GROUP_NAME+ same_group = self._group is not None and old_group_name == new_group_name+ self.config = updated+ if same_group:+ # Settings do not change the identity of processes already in this+ # cgroup. Keep their event baseline even when governance is disabled.+ if self.mode != "disabled":+ root = self.root or detect_cgroup_root()+ if root is not None and self._base is not None:+ limits = derive_agent_limits(+ tenant_memory_limit_bytes(self._base, root),+ self.config,+ tenant_pids_max=tenant_pid_limit(self._base, root),+ )+ try:+ self._configure_group(self._group, limits)+ except OSError as exc:+ self._disabled_reason = str(exc)+ logger.warning("Agent resource governance reconfiguration failed: %s", exc)+ else:+ self._limits = limits+ self._disabled_reason = None+ returnself._base = Noneself._group = Noneself._limits = Noneself._disabled_reason = None+ self._event_baseline = Nonedef apply_to_pid(self, pid: int | None, *, label: str = "agent") -> bool:if not isinstance(pid, int) or pid <= 0:@@ -403,11 +532,79 @@ class AgentResourceGovernor:group = self._ensure_group(known_agent_pids=known_agent_pids)if group is None:return False+ if self._event_baseline is None:+ self._event_baseline = self.snapshot()moved = self._move_pid(group, pid, label=label)for child_pid in descendant_pids:self._move_pid(group, child_pid, label=f"{label} child", warn=False)return moved+ def snapshot(self) -> AgentResourceSnapshot | None:+ """Read the current counters for the shared agent cgroup."""++ group = self._group+ if group is None:+ return None+ return self._snapshot_group(group)++ @staticmethod+ def _snapshot_group(group: Path) -> AgentResourceSnapshot:+ return AgentResourceSnapshot(+ pids_current=_parse_non_negative_int(_read_text(group / "pids.current")),+ pids_max=_parse_pids_max(_read_text(group / "pids.max")),+ pids_events=_parse_counter_file(group / "pids.events"),+ memory_events=_parse_counter_file(group / "memory.events"),+ )++ def observe_resource_pressure(self) -> AgentResourceFailure | None:+ """Observe a shared Agent cgroup limit event without process attribution."""++ current = self.snapshot()+ baseline = self._event_baseline+ if current is None or baseline is None:+ return None++ pids_max_delta = current.pids_events.get("max", 0) - baseline.pids_events.get("max", 0)+ if pids_max_delta > 0:+ # Leave simultaneous memory events pending for the next observer.+ self._event_baseline = replace(current, memory_events=baseline.memory_events)+ current_label = (+ str(current.pids_current)+ if current.pids_current is not None+ else "unknown"+ )+ limit_label = (+ str(current.pids_max)+ if current.pids_max is not None+ else "max"+ )+ return AgentResourceFailure(+ kind="pids",+ message=(+ "shared Agent cgroup recorded a pids limit event "+ f"(current={current_label}, max={limit_label}, events.max_delta={pids_max_delta}); "+ "concurrent Agent processes may be affected"+ ),+ pids_current=current.pids_current,+ pids_max=current.pids_max,+ event_delta=pids_max_delta,+ )++ for event_name in ("oom_kill", "oom", "max"):+ delta = current.memory_events.get(event_name, 0) - baseline.memory_events.get(event_name, 0)+ if delta > 0:+ self._event_baseline = replace(current, pids_events=baseline.pids_events)+ return AgentResourceFailure(+ kind="memory",+ message=(+ "shared Agent cgroup recorded a memory limit event "+ f"(event={event_name}, events_delta={delta}); "+ "concurrent Agent processes may be affected"+ ),+ event_delta=delta,+ )+ return None+def _move_pid(self, group: Path, pid: int, *, label: str, warn: bool = True) -> bool:try:_write_cgroup_value(group / "cgroup.procs", str(pid))@@ -419,11 +616,11 @@ class AgentResourceGovernor:return Falsedef _ensure_group(self, *, known_agent_pids: set[int] | None = None) -> Path | None:- if self._group is not None:- return self._groupif self.mode == "disabled":self._disabled_reason = "disabled"return None+ if self._group is not None:+ return self._grouproot = self.root or detect_cgroup_root()if root is None:self._disabled_reason = "no-cgroup-v2"@@ -444,10 +641,20 @@ class AgentResourceGovernor:group = base / group_nameruntime_group = base / runtime_group_nametry:+ # An existing constrained group may receive known agent PIDs during+ # base migration, before the newly discovered PID is adopted.+ if self._event_baseline is None and group.exists():+ self._event_baseline = self._snapshot_group(group)self._prepare_base_cgroup(base, runtime_group, group, root, known_agent_pids=known_agent_pids)self._enable_subtree_controllers(base)group.mkdir(exist_ok=True)- limits = derive_agent_limits(tenant_memory_limit_bytes(base, root), self.config)+ if self._event_baseline is None:+ self._event_baseline = self._snapshot_group(group)+ limits = derive_agent_limits(+ tenant_memory_limit_bytes(base, root),+ self.config,+ tenant_pids_max=tenant_pid_limit(base, root),+ )self._configure_group(group, limits)except OSError as exc:self._disabled_reason = str(exc)@@ -546,6 +753,8 @@ class AgentResourceGovernor:if not (agent_group / "cgroup.procs").exists():raise OSError(f"agent cgroup.procs is unavailable in {agent_group}")agent_group_ready = True+ if self._event_baseline is None:+ self._event_baseline = self._snapshot_group(agent_group)target_group = agent_grouptarget_label = "known agent"try:@@ -648,3 +857,9 @@ def governor_from_controller(controller: Any) -> AgentResourceGovernor:mark_controller_resource_governor(governor)setattr(controller, "_agent_resource_governor", governor)return governor+++def observe_agent_resource_pressure(controller: Any) -> AgentResourceFailure | None:+ """Return a shared Agent cgroup resource observation."""++ return governor_from_controller(controller).observe_resource_pressure()diff --git a/core/scheduled_tasks.py b/core/scheduled_tasks.pyindex e3769daa3..42d396c13 100644--- a/core/scheduled_tasks.py+++ b/core/scheduled_tasks.py@@ -149,6 +149,7 @@ AGENT_RUN_DELIVERY_INTENTS = frozenset()AGENT_RUN_DELIVERY_INTENT_METADATA_KEY = "delivery_intent"AGENT_RUN_DELIVERY_OUTCOME_METADATA_KEY = "delivery_outcome"+AGENT_RUN_CLOSE_AFTER_METADATA_KEY = "close_after"FAILURE_CODE_SESSION_TURN_GATE_UNAVAILABLE = "session_turn_gate_unavailable"SESSION_TURN_GATE_UNAVAILABLE_I18N_KEY = "harness.run.sessionTurnGateUnavailable"@@ -10902,6 +10903,14 @@ class ScheduledTaskService:),"vibe_agent_name": agent_name,"vibe_agent_id": agent_id,+ "agent_backend": (+ target_info.agent_backend+ if target_info is not None+ else None+ ),+ "close_after": bool(+ (metadata or {}).get(AGENT_RUN_CLOSE_AFTER_METADATA_KEY)+ ),"source_kind": (metadata or {}).get("source_kind"),"source_actor": (metadata or {}).get("source_actor"),"source_session_id": (metadata or {}).get("source_session_id"),diff --git a/core/services/running_agents.py b/core/services/running_agents.pyindex f8aa8601b..617c130ac 100644--- a/core/services/running_agents.py+++ b/core/services/running_agents.py@@ -667,11 +667,6 @@ async def _end_codex(controller: "Controller", base_session_id: Optional[str]) -except Exception: # noqa: BLE001logger.debug("end: codex turn/interrupt failed for %s", base_session_id, exc_info=True)try:- # Fully remove the session's mappings (thread + cwd + session_key), not- # just ``invalidate_thread`` (which preserves cwd/session_key) — otherwise- # ``_collect_codex``'s ``all_base_sessions()`` still enumerates it and the- # row never disappears from the Running tab.- session_mgr.clear(base_session_id)turn_registry.clear_session(base_session_id)except Exception as exc: # noqa: BLE001logger.warning("end: codex clear failed for %s: %s", base_session_id, exc)@@ -680,22 +675,33 @@ async def _end_codex(controller: "Controller", base_session_id: Optional[str]) -# that cwd, stop it too so the codex process is actually freed (otherwise it# lingers with zero sessions); if other sessions still use it, leave it up.process_killed = False- if cwd and transport is not None:- remaining: list = []+ retire_idle = getattr(agent, "retire_unowned_session_transport", None)+ other_sessions = (+ set(session_mgr.sessions_for_cwd(cwd)) - {base_session_id}+ if cwd else set()+ )+ if cwd and transport is not None and not other_sessions and callable(retire_idle):try:- remaining = session_mgr.sessions_for_cwd(cwd)- except Exception: # noqa: BLE001- remaining = []- if not remaining:- try:- await transport.stop()- transports.pop(cwd, None)- last_activity = getattr(agent, "_transport_last_activity", None)- if isinstance(last_activity, dict):- last_activity.pop(cwd, None)- process_killed = True- except Exception: # noqa: BLE001- logger.debug("end: codex transport stop failed for %s", cwd, exc_info=True)+ process_killed = bool(+ await retire_idle(cwd, ending_session_id=base_session_id)+ )+ except Exception as exc: # noqa: BLE001+ logger.warning("end: codex transport stop failed for %s", cwd, exc_info=True)+ return {"ok": False, "error": "transport_retire_failed", "detail": str(exc)}+ if not process_killed:+ return {"ok": False, "error": "transport_retire_failed"}+ try:+ # Keep the cwd mapping until transport retirement succeeds, so a failed+ # close remains reachable by Session ID for a later End attempt.+ session_mgr.clear(base_session_id)+ getattr(agent, "_session_locks", {}).pop(base_session_id, None)+ getattr(agent, "_session_last_activity", {}).pop(base_session_id, None)+ clear_thread_cache = getattr(agent, "_clear_thread_developer_instructions", None)+ if callable(clear_thread_cache):+ clear_thread_cache(base_session_id)+ except Exception as exc: # noqa: BLE001+ logger.warning("end: codex clear failed for %s: %s", base_session_id, exc)+ return {"ok": False, "error": "clear_failed", "detail": str(exc)}# ``interrupted`` is False when there was no active turn to stop (idle/stale):# the session state is still cleared, but the caller can tell nothing was# actively interrupted.@@ -716,20 +722,46 @@ async def _end_opencode(controller: "Controller", base_session_id: Optional[str]return {"ok": False, "error": "opencode_unavailable"}active_requests = getattr(agent, "_active_requests", {}) or {}task = active_requests.get(base_session_id)- # Best-effort remote abort (so the OpenCode server stops the run too), then- # cancel the local polling task.session_mgr = getattr(agent, "_session_manager", None)- try:- get_req = getattr(session_mgr, "get_request_session", None)- req_info = get_req(base_session_id) if callable(get_req) else None- if req_info:- server = await agent._get_server()- await server.abort_session(req_info[0], req_info[1])- except Exception: # noqa: BLE001- logger.debug("end: opencode remote abort failed for %s", base_session_id, exc_info=True)+ get_req = getattr(session_mgr, "get_request_session", None)+ req_info = get_req(base_session_id) if callable(get_req) else Noneif task is not None and not task.done():+ # Active End has already gone through the canonical stop path. Finish+ # interrupting its native poll, but do not retire a shared server here.+ try:+ if req_info:+ server = await agent._get_server()+ await server.abort_session(req_info[0], req_info[1])+ except Exception: # noqa: BLE001+ logger.debug("end: opencode remote abort failed for %s", base_session_id, exc_info=True)task.cancel()- return {"ok": True, "action": "ended", "backend": "opencode"}+ return {"ok": True, "action": "ended", "backend": "opencode", "process_killed": False}++ retire_req = getattr(session_mgr, "retire_request_session", None)+ if callable(retire_req):+ retire_req(base_session_id)+ else:+ pop_req = getattr(session_mgr, "pop_request_session", None)+ if callable(pop_req):+ pop_req(base_session_id)+ getattr(agent, "_session_last_activity", {}).pop(base_session_id, None)+ list_all = getattr(session_mgr, "list_all", None)+ if not callable(list_all) or list_all():+ return {"ok": True, "action": "ended", "backend": "opencode", "process_killed": False}+ if any(not request.done() for request in active_requests.values()):+ return {"ok": True, "action": "ended", "backend": "opencode", "process_killed": False}++ # The serve process is shared across Sessions. Its existing strict idle+ # retirement checks native requests, durable ownership, and process proof.+ server = getattr(getattr(agent, "_client_manager", None), "_server_manager", None)+ if server is None:+ return {"ok": True, "action": "ended", "backend": "opencode", "process_killed": False}+ try:+ await server.retire_for_native_migration()+ except Exception as exc: # noqa: BLE001+ logger.warning("end: opencode idle server retirement failed for %s: %s", base_session_id, exc)+ return {"ok": False, "error": "runtime_retirement_failed", "detail": str(exc)}+ return {"ok": True, "action": "ended", "backend": "opencode", "process_killed": True}async def _settle_workbench_turn(@@ -1228,7 +1260,8 @@ async def end_running_agent(- claude → interrupt the turn + disconnect the SDK client + reap the subprocess.- codex → interrupt the turn + clear the session mappings (+ stop the sharedapp-server when this was its last session).- - opencode → abort the remote run + cancel the local polling task.+ - opencode → abort an active run; retire the shared serve process when idle+ and no other session owns it.For an ACTIVE turn, the stop goes through the canonical per-backend stop path(Workbench turns via ``SessionTurnManager.cancel``; IM / agent-run turns viadiff --git a/core/session_turns.py b/core/session_turns.pyindex 7b39c9b73..435f94a2d 100644--- a/core/session_turns.py+++ b/core/session_turns.py@@ -5636,6 +5636,36 @@ class SessionTurnManager:)return None+ def has_close_after_successor(self, session_id: str, completed_turn_id: str) -> bool:+ """Read durable successor ownership before disposing a completed runtime.++ Unlike the UI projection in ``turn_state``, a failed read must propagate:+ uncertainty is not permission to stop a possibly active successor.+ """+ if not self._durable_schema_available():+ return False+ with self._sqlite_engine().connect() as conn:+ queued = conn.execute(+ select(delivery_rows.c.id)+ .where(delivery_rows.c.session_id == session_id)+ .where(delivery_rows.c.state == "queued")+ .limit(1)+ ).first()+ if queued is not None:+ return True+ successor = conn.execute(+ select(session_turn_rows.c.id)+ .where(session_turn_rows.c.session_id == session_id)+ .where(session_turn_rows.c.id != completed_turn_id)+ .where(+ session_turn_rows.c.state.in_(+ ("waiting",) + delivery_store.TURN_OWNER_STATES+ )+ )+ .limit(1)+ ).first()+ return successor is not None+def scan_runtime_delivery_recovery(self,*,diff --git a/docs/CLI.md b/docs/CLI.mdindex d02edcdad..9daf90c34 100644--- a/docs/CLI.md+++ b/docs/CLI.md@@ -410,6 +410,7 @@ vibe agent run --session-id sesk8m4q2p7x --send-now --message 'Apply this correcvibe agent run --no-callback --fork-session sesk8m4q2p7x --message 'Explore this alternate fix from the current context.'vibe agent run --session-id sesworker123 --callback-session-id sescaller456 --message 'Run the delegated investigation.'vibe agent run --no-callback --create-session --scope-id slack::channel::C999 --agent release-reviewer --message 'Post the deployment summary.'+vibe agent run --close-after --no-callback --agent release-reviewer --message 'Run a disposable batch review.'```With an existing `--session-id`, the default admission is P1: Avibe steers the@@ -445,6 +446,11 @@ calls, and intermediate assistant updates are not included.`vibe hook send` is kept only as a deprecated compatibility entrypoint. Newautomation should use `vibe agent run`.+Use `--close-after` for a new or forked Session when the Agent runtime should be+released after the Run settles while the Session, transcript, and Run record stay+available. It is rejected for `--session-id`, which targets an existing Session+with its own runtime lifecycle.+### `vibe watch`Create, update, inspect, pause, resume, or remove a managed background watch. A watchdiff --git a/docs/CLI_ZH.md b/docs/CLI_ZH.mdindex f1d6e0d3d..bbda0c466 100644--- a/docs/CLI_ZH.md+++ b/docs/CLI_ZH.md@@ -367,6 +367,7 @@ vibe agent run --session-id sesk8m4q2p7x --send-now --message 'Apply this correcvibe agent run --no-callback --fork-session sesk8m4q2p7x --message 'Explore this alternate fix from the current context.'vibe agent run --session-id sesworker123 --callback-session-id sescaller456 --message 'Run the delegated investigation.'vibe agent run --no-callback --create-session --scope-id slack::channel::C999 --agent release-reviewer --message 'Post the deployment summary.'+vibe agent run --close-after --no-callback --agent release-reviewer --message 'Run a disposable batch review.'````--send-now` 只能和现有 `--session-id` 一起使用,它显式选择普通的带内容 P1@@ -392,6 +393,10 @@ P1 操作,只提升现有的精确 FIFO 队头,不新增消息。过期队`vibe hook send` 仅作为 deprecated 兼容入口保留。新的自动化入口应使用`vibe agent run`。+对于新建或 fork 的 Session,如果希望 Run 结束后释放 Agent runtime,同时保留+Session、transcript 和 Run 记录,可以使用 `--close-after`。它不能和+`--session-id` 一起使用,因为现有 Session 自己管理 runtime 生命周期。+### `vibe watch`创建、查看、更新、暂停、恢复或删除一个被管理的后台 watch。watch 会运行一个diff --git a/docs/COMMANDS.md b/docs/COMMANDS.mdindex 4fa207714..a86b880a7 100644--- a/docs/COMMANDS.md+++ b/docs/COMMANDS.md@@ -889,6 +889,7 @@ Important options:- `--scope-id`- `--model`- `--reasoning-effort`+- `--close-after`- `--sync`- `--message`- `--message-file`@@ -901,6 +902,10 @@ with `run_id` / `session_id`, and uses the callback policy to deliver the finalresult later. Use `--sync` only when the terminal should wait for completion.`--async` is still accepted for older scripts but is no longer required.+`--close-after` applies to a new or forked Session. It releases that Agent+runtime after the Run settles while keeping the Session, transcript, and Run+record. It cannot target an existing `--session-id`.+With an existing `--session-id`, the default is P1: steer the new Run into anactive native Turn, start it when idle, or move the same Delivery to P3 after adefinitive refusal/not-active receipt. `--queue` selects P3 without attempting adiff --git a/docs/COMMANDS_ZH.md b/docs/COMMANDS_ZH.mdindex 9ed2f7028..f7c6b4a97 100644--- a/docs/COMMANDS_ZH.md+++ b/docs/COMMANDS_ZH.md@@ -862,6 +862,7 @@ vibe agent run (--session-id <session_id> | --create-session | --fork-session <s- `--scope-id`- `--model`- `--reasoning-effort`+- `--close-after`- `--sync`- `--message`- `--message-file`@@ -873,6 +874,10 @@ Run 默认异步:命令会队列化 run,立即返回包含 `run_id` / `sessipayload,并按 callback 策略稍后投递最终结果。只有终端需要等待完成时才使用`--sync`。`--async` 仍兼容旧脚本,但不再需要显式传入。+`--close-after` 适用于新建或 fork 的 Session。Run 结束后它会释放该 Agent+runtime,同时保留 Session、transcript 和 Run 记录;不能和现有的+`--session-id` 一起使用。+对于现有 `--session-id`,默认投递是 P1:新消息会 steering 进活动 native Turn,Session 空闲时立即启动;明确拒绝后,同一个 Delivery 才回退到 P3。`--queue` 会直接选择 P3。`--send-now` 显式选择相同的带内容 P1 语义,只针对这条新消息,diff --git a/modules/agents/base.py b/modules/agents/base.pyindex 87629eaf9..9105e131a 100644--- a/modules/agents/base.py+++ b/modules/agents/base.py@@ -194,6 +194,14 @@ class BaseAgent(ABC):return lambda: self.backend_alive(context)+ def capture_backend_exit_failure(+ self,+ context: Any,+ ) -> Callable[[], tuple[str, str] | None] | None:+ """Optionally bind a visible diagnosis to the accepted runtime generation."""++ return None+def mark_runtime_turn_started(self,context: Any,diff --git a/modules/agents/claude_agent.py b/modules/agents/claude_agent.pyindex 25ca75003..7189fd327 100644--- a/modules/agents/claude_agent.py+++ b/modules/agents/claude_agent.py@@ -20,6 +20,7 @@ from core.message_output import (from core.native_dispatch_phase import mark_backend_dispatch_attempted, mark_prewrite_recovery_requiredfrom core.processing_indicator import STOPPED_REACTION_EMOJIfrom core.reply_enhancer import strip_silent_blocks+from core.resource_governance import pids_failure_labelsfrom core.runtime_activation import RuntimeActivationIdentityfrom core.runtime_work import RuntimeWorkLanefrom core.services.agent_steering import (@@ -123,10 +124,24 @@ class ClaudeAgent(BaseAgent):# )self._question_handler = None- def _claude_error_diagnostic(self, composite_key: str, error: Exception) -> str:+ def _claude_error_diagnostic(+ self,+ composite_key: str,+ error: Exception,+ *,+ client=None,+ ) -> str:diagnostic = getattr(self.session_handler, "claude_error_diagnostic", None)if callable(diagnostic):try:+ if client is not None:+ try:+ return diagnostic(composite_key, error, client=client)+ except TypeError:+ # Keep compatibility with lightweight test doubles and+ # older session handlers that still expose the two-arg+ # diagnostic hook.+ passreturn diagnostic(composite_key, error)except Exception:logger.debug("claude: failed to build error diagnostic", exc_info=True)@@ -142,7 +157,13 @@ class ClaudeAgent(BaseAgent):lang = getattr(getattr(self.controller, "config", None), "language", "en")return str(i18n_t(key, lang, **kwargs))- def _format_error_notify(self, error: Exception, *, composite_key: str | None = None) -> str:+ def _format_error_notify(+ self,+ error: Exception,+ *,+ composite_key: str | None = None,+ client=None,+ ) -> str:"""Return the durable notify text for Claude terminal errors."""if isinstance(error, ClaudeSessionNotFoundError):detail = self._translate_error(@@ -153,12 +174,27 @@ class ClaudeAgent(BaseAgent):return f"❌ {detail}"if is_claude_sdk_buffer_error(error):return f"❌ {self._translate_error('error.sessionConnectionLost')}"- client = self.claude_sessions.get(composite_key) if composite_key else None+ if client is None:+ client = self.claude_sessions.get(composite_key) if composite_key else Nonereturncode = get_claude_client_returncode(client)if returncode is not None:reason_key, reason_values = claude_process_exit_reason_i18n(returncode)reason = self._translate_error(reason_key, **reason_values)- return f"❌ {self._translate_error('error.claudeProcessTerminated', reason=reason)}"+ message = self._translate_error("error.claudeProcessTerminated", reason=reason)+ resource_failure = getattr(client, "_vibe_resource_failure", None)+ if resource_failure is not None:+ if getattr(resource_failure, "kind", None) == "pids":+ language = str(+ getattr(getattr(self.controller, "config", None), "language", "en")+ or "en"+ )+ message = (+ f"{message} "+ f"{self._translate_error('error.agentPidsLimit', **pids_failure_labels(resource_failure, language))}"+ )+ elif getattr(resource_failure, "kind", None) == "memory":+ message = f"{message} {self._translate_error('error.agentMemoryLimit')}"+ return f"❌ {message}"return f"❌ Claude error: {error}"async def handle_message(self, request: AgentRequest) -> None:@@ -267,7 +303,11 @@ class ClaudeAgent(BaseAgent):missing_session = isinstance(e, ClaudeSessionNotFoundError)if missing_session:mark_prewrite_recovery_required(context, "native_session_not_found")- diagnostic = self._claude_error_diagnostic(runtime_session_key, e)+ diagnostic = self._claude_error_diagnostic(+ runtime_session_key,+ e,+ client=client,+ )# Classify BEFORE recording: ``record_model_hub_native_failure``# turns the pending native/hub attempt into a failed one, so a# process the service killed on purpose would settle that source's@@ -282,7 +322,11 @@ class ClaudeAgent(BaseAgent):self._remove_pending_request(runtime_session_key, request)self._mark_session_idle_if_no_pending_requests(runtime_session_key)await self._remove_ack_reaction(request)- error_notify = self._format_error_notify(e, composite_key=runtime_session_key)+ error_notify = self._format_error_notify(+ e,+ composite_key=runtime_session_key,+ client=client,+ )try:# A typed local resume failure takes precedence over incidental# auth words in the working path or captured process diagnostic.@@ -2003,6 +2047,14 @@ class ClaudeAgent(BaseAgent):# the result to the live sink instead of rejecting it as a# stale straggler. No-op for fresh sessions / absent tokens.self._adopt_pending_turn_token(context, pending_request)+ close_after_payload = getattr(context, "platform_specific", None) or {}+ backend_cleanup = (+ asyncio.Event()+ if close_after_payload.get("close_after")+ else None+ )+ if backend_cleanup is not None:+ close_after_payload["_close_after_backend_cleanup"] = backend_cleanup# A terminal result consumes this Turn even when IM delivery# fails. A failed Activity delivery is requeued below, but its@@ -2087,29 +2139,35 @@ class ClaudeAgent(BaseAgent):exc_info=True,)finally:- await self._remove_result_pending_reaction(- composite_key,- context,- pending_request,- )- self._last_assistant_text.pop(composite_key, None)- self._foreground_tool_use_ids.pop(composite_key, None)- self._turns_with_foreground_tools.discard(composite_key)- is_idle = self._mark_session_idle_if_no_pending_requests(composite_key)try:- session = await self.session_manager.get_or_create_session(- context.user_id, context.channel_id- )- if session and is_idle:- session.session_active[composite_key] = False- except Exception:- logger.debug(- "claude: failed to update session_active after result for %s",+ await self._remove_result_pending_reaction(composite_key,- exc_info=True,+ context,+ pending_request,)- if emit_failed:- self._release_service_runtime_turn(context)+ self._last_assistant_text.pop(composite_key, None)+ self._foreground_tool_use_ids.pop(composite_key, None)+ self._turns_with_foreground_tools.discard(composite_key)+ is_idle = self._mark_session_idle_if_no_pending_requests(composite_key)+ try:+ session = await self.session_manager.get_or_create_session(+ context.user_id, context.channel_id+ )+ if session and is_idle:+ session.session_active[composite_key] = False+ except Exception:+ logger.debug(+ "claude: failed to update session_active after result for %s",+ composite_key,+ exc_info=True,+ )+ if emit_failed:+ self._release_service_runtime_turn(context)+ finally:+ if backend_cleanup is not None:+ backend_cleanup.set()+ if close_after_payload.get("_close_after_backend_cleanup") is backend_cleanup:+ close_after_payload.pop("_close_after_backend_cleanup", None)if settling_ambiguous_primary:returncontinue@@ -2245,8 +2303,16 @@ class ClaudeAgent(BaseAgent):contained = Falseif returncode is not None:eof_error = RuntimeError(terminal_error)- error_notify = self._format_error_notify(eof_error, composite_key=composite_key)- diagnostic = self._claude_error_diagnostic(composite_key, eof_error)+ diagnostic = self._claude_error_diagnostic(+ composite_key,+ eof_error,+ client=client,+ )+ error_notify = self._format_error_notify(+ eof_error,+ composite_key=composite_key,+ client=client,+ )failure_context = getattr(pending_request, "context", context)intentional_teardown = self._teardown_is_intentional(composite_key, eof_error, client=client@@ -2361,13 +2427,21 @@ class ClaudeAgent(BaseAgent):pending_request = pending[0] if pending else Noneself._adopt_pending_turn_token(context, pending_request)await self._clear_pending_reactions(composite_key, context)- diagnostic = self._claude_error_diagnostic(composite_key, error)- error_notify = self._format_error_notify(error, composite_key=composite_key)- failure_context = getattr(pending_request, "context", context)# Read the client once and reuse it for both the health gate and the# handler, so a replacement registering in between cannot make the# two disagree about which generation actually failed.errored_client = self.claude_sessions.get(composite_key)+ diagnostic = self._claude_error_diagnostic(+ composite_key,+ error,+ client=errored_client,+ )+ error_notify = self._format_error_notify(+ error,+ composite_key=composite_key,+ client=errored_client,+ )+ failure_context = getattr(pending_request, "context", context)intentional_teardown = self._teardown_is_intentional(composite_key, error, client=errored_client)@@ -2651,6 +2725,7 @@ class ClaudeAgent(BaseAgent):"task_trigger_kind","task_execution_id","accepted_agent_run_ids",+ "close_after",)current_payload = getattr(context, "platform_specific", None) or {}updates_attribution = any(diff --git a/modules/agents/codex/agent.py b/modules/agents/codex/agent.pyindex addb88fc5..21c93ec9a 100644--- a/modules/agents/codex/agent.py+++ b/modules/agents/codex/agent.py@@ -48,7 +48,11 @@ from core.system_prompt_injection import (build_system_prompt_injection,get_enabled_agents_for_prompt,)-from core.resource_governance import governor_from_controller+from core.resource_governance import (+ observe_agent_resource_pressure,+ governor_from_controller,+ pids_failure_labels,+)from core.runtime_activation import RuntimeActivationIdentityfrom core.runtime_ownership import (RuntimeResourceTarget,@@ -260,6 +264,60 @@ class CodexAgent(BaseAgent):return lambda: Nonereturn lambda: self._transport_alive(transport)+ def capture_backend_exit_failure(+ self,+ context: Any,+ ) -> Callable[[], tuple[str, str] | None] | None:+ """Bind resource diagnosis to the app-server generation owning this turn."""++ payload = getattr(context, "platform_specific", None) or {}+ base_session_id = str(payload.get("turn_base_session_id") or "").strip()+ cwd = self._session_mgr.get_cwd(base_session_id) if base_session_id else None+ transport = self._transports.get(cwd) if cwd else None+ if transport is None:+ return None++ cached_diagnosis: tuple[str, str] | None = None+ exit_checked = False++ def diagnose() -> tuple[str, str] | None:+ nonlocal cached_diagnosis, exit_checked+ if exit_checked:+ return cached_diagnosis+ process = getattr(transport, "_process", None)+ if process is None or getattr(process, "returncode", None) is None:+ # A liveness failure may precede a definitive process exit.+ return None+ failure = self._resource_failure_for_transport(transport)+ if failure is None:+ # Shared cgroup observations belong to this exit boundary only.+ # A later retry must not attach a newer event to an older death.+ exit_checked = True+ return None+ language = str(+ getattr(getattr(self.controller, "config", None), "language", "en")+ or "en"+ )+ if failure.kind == "pids":+ visible = i18n_t(+ "error.agentPidsLimit",+ language,+ **pids_failure_labels(failure, language),+ )+ elif failure.kind == "memory":+ visible = i18n_t("error.agentMemoryLimit", language)+ else:+ exit_checked = True+ return None+ cached_diagnosis = (+ f"backend_runtime_exited_before_terminal\nResource diagnosis: {failure.message}",+ f"❌ {visible}",+ )+ exit_checked = True+ return cached_diagnosis++ return diagnose+def can_reuse_direct_connection_probe(self, cwd: str) -> bool:"""Return whether a cached transport can test direct credentials."""@@ -596,7 +654,13 @@ class CodexAgent(BaseAgent):self._turn_registry.clear_pending_turn_start(request.base_session_id, request)logger.error("Error in Codex handle_message: %s", e, exc_info=True)await self._record_model_hub_native_failure(request.context, str(e))- error_text = self._error_display_text(e)+ # A successful replacement consumes no shared pressure evidence.+ # Diagnose only the transport whose failure is actually reported.+ resource_failure = self._resource_failure_for_transport(transport)+ error_text = self._error_display_text(+ e,+ resource_failure=resource_failure,+ )await emit_backend_failure(self.controller,request.context,@@ -1131,6 +1195,40 @@ class CodexAgent(BaseAgent):self._turn_registry.clear_session(base_session_id)self._clear_thread_developer_instructions(base_session_id)+ async def retire_unowned_session_transport(+ self, cwd: str, *, ending_session_id: str | None = None+ ) -> bool:+ """Reclaim the exact cwd generation while retaining the ending Session on failure."""++ async with self._transport_locks.setdefault(cwd, asyncio.Lock()):+ transport = self._transports.get(cwd)++ def has_other_sessions() -> bool:+ return any(+ session_id != ending_session_id+ for session_id in self._session_mgr.sessions_for_cwd(cwd)+ )++ if transport is None or has_other_sessions():+ return False++ async def still_unowned() -> bool:+ return (+ self._transports.get(cwd) is transport+ and not has_other_sessions()+ and not self._has_active_turns_for_cwd(cwd)+ )++ detached = await self._stop_and_detach_transport_generation(+ cwd,+ transport,+ final_predicate=still_unowned,+ require_process_exit=True,+ )+ if detached:+ self._retire_model_hub_process_scope(cwd)+ return detached+async def refresh_auth_state(self) -> None:"""Drop app-server runtime state so future turns pick up fresh auth."""if not hasattr(self, "_transport_last_activity"):@@ -1339,20 +1437,60 @@ class CodexAgent(BaseAgent):session_id = payload.get("agent_session_id") if isinstance(payload, dict) else Nonesetter(request.base_session_id, session_id)- def _error_display_text(self, error: BaseException) -> str:+ def _resource_failure_for_transport(self, transport: CodexTransport | None):+ process = getattr(transport, "_process", None)+ if process is None or getattr(process, "returncode", None) is None:+ return None+ if getattr(transport, "_vibe_resource_failure_checked", False):+ return getattr(transport, "_vibe_resource_failure", None)+ failure = observe_agent_resource_pressure(self.controller)+ setattr(transport, "_vibe_resource_failure", failure)+ setattr(transport, "_vibe_resource_failure_checked", True)+ if failure is not None:+ logger.error(+ "Codex app-server exited while the shared Agent cgroup reported resource pressure: %s",+ failure.message,+ )+ return failure++ def _error_display_text(+ self,+ error: BaseException,+ *,+ resource_failure=None,+ ) -> str:if isinstance(error, CodexResponseTooLargeError):language = str(getattr(getattr(self.controller, "config", None), "language", "en")or "en")- return f"❌ {i18n_t('error.codexResponseTooLarge', language, limitMiB=error.limit // (1024 * 1024))}"- if isinstance(error, CodexPromptRefreshUnavailableError):+ message = i18n_t(+ "error.codexResponseTooLarge",+ language,+ limitMiB=error.limit // (1024 * 1024),+ )+ elif isinstance(error, CodexPromptRefreshUnavailableError):+ language = str(+ getattr(getattr(self.controller, "config", None), "language", "en")+ or "en"+ )+ message = i18n_t("error.codexPromptRefreshUnavailable", language)+ else:+ message = f"Codex error: {error}"++ if resource_failure is not None:language = str(getattr(getattr(self.controller, "config", None), "language", "en")or "en")- return f"❌ {i18n_t('error.codexPromptRefreshUnavailable', language)}"- return f"❌ Codex error: {error}"+ if getattr(resource_failure, "kind", None) == "pids":+ message = (+ f"{message} "+ f"{i18n_t('error.agentPidsLimit', language, **pids_failure_labels(resource_failure, language))}"+ )+ elif getattr(resource_failure, "kind", None) == "memory":+ message = f"{message} {i18n_t('error.agentMemoryLimit', language)}"+ return f"❌ {message}"def _runtime_ownership_target_for_cwd(self,diff --git a/modules/agents/opencode/agent.py b/modules/agents/opencode/agent.pyindex e785ef272..321e51428 100644--- a/modules/agents/opencode/agent.py+++ b/modules/agents/opencode/agent.py@@ -40,7 +40,12 @@ from core.native_dispatch_phase import (mark_backend_dispatch_attempted,prewrite_user_stop_requested,)-from core.resource_governance import governor_from_controller+from core.resource_governance import (+ AgentResourceFailure,+ observe_agent_resource_pressure,+ governor_from_controller,+ pids_failure_labels,+)from core.runtime_activation import RuntimeActivationIdentityfrom core.runtime_ownership import (RuntimeResourceTarget,@@ -973,7 +978,82 @@ class OpenCodeAgent(OpenCodeMessageProcessorMixin, BaseAgent):variant=reasoning_effort or default_label,)- def _server_start_error_display_text(self, error: BaseException) -> str:+ def _resource_failure_for_server(+ self,+ server: OpenCodeServerManager | None,+ ) -> AgentResourceFailure | None:+ process = getattr(server, "_process", None)+ if process is not None:+ if getattr(process, "returncode", None) is None:+ return None+ pid = getattr(process, "pid", None)+ generation = ("process", process)+ else:+ pid = getattr(server, "_last_start_failure_pid", None)+ if pid is not None:+ generation = (+ "startup",+ getattr(server, "_start_attempt_generation", 0),+ pid,+ )+ else:+ observed_exit = getattr(server, "observed_runtime_exit_pid", None)+ if callable(observed_exit):+ pid = observed_exit()+ generation = (+ "adopted",+ getattr(server, "_runtime_generation_token", None),+ pid,+ )+ if not isinstance(pid, int) or pid <= 0:+ return None+ cached_generation = getattr(server, "_vibe_resource_failure_generation", None)+ same_generation = (+ cached_generation is not None+ and cached_generation[0] == generation[0]+ and (+ cached_generation[1] is process+ if generation[0] == "process"+ else cached_generation == generation+ )+ )+ if same_generation:+ return getattr(server, "_vibe_resource_failure", None)+ failure = observe_agent_resource_pressure(self.controller)+ if server is not None:+ setattr(server, "_vibe_resource_failure_generation", generation)+ setattr(server, "_vibe_resource_failure", failure)+ if failure is not None:+ logger.error(+ "OpenCode server exited while the shared Agent cgroup reported resource pressure: %s",+ failure.message,+ )+ return failure++ def _resource_failure_suffix(+ self,+ failure: AgentResourceFailure | None,+ ) -> str:+ if failure is None:+ return ""+ language = str(+ getattr(getattr(self.controller, "config", None), "language", "en")+ or "en"+ )+ if failure.kind == "pids":+ return (+ f" {i18n_t('error.agentPidsLimit', language, **pids_failure_labels(failure, language))}"+ )+ if failure.kind == "memory":+ return f" {i18n_t('error.agentMemoryLimit', language)}"+ return ""++ def _server_start_error_display_text(+ self,+ error: BaseException,+ *,+ resource_failure: AgentResourceFailure | None = None,+ ) -> str:localized_key = Noneif isinstance(error, OpenCodeModelHubOverlayRequiredError):localized_key = "error.opencodeModelHubOverlayRequired"@@ -986,8 +1066,10 @@ class OpenCodeAgent(OpenCodeMessageProcessorMixin, BaseAgent):getattr(getattr(self.controller, "config", None), "language", "en")or "en")- return f"❌ {i18n_t(localized_key, language)}"- return f"Failed to start OpenCode server: {error}"+ message = i18n_t(localized_key, language)+ else:+ message = f"Failed to start OpenCode server: {error}"+ return f"❌ {message}{self._resource_failure_suffix(resource_failure)}"async def prepare_runtime_restart(self) -> None:"""Adopt persisted server state before the shared drain snapshot."""@@ -1215,6 +1297,7 @@ class OpenCodeAgent(OpenCodeMessageProcessorMixin, BaseAgent):caller_context_binding_renewal: asyncio.Task[None] | None = Noneactive_poll_persisted = Falseactive_poll_removal_pending = False+ resource_failure: AgentResourceFailure | None = Nonedef remove_active_poll() -> None:nonlocal active_poll_persisted, active_poll_removal_pending@@ -1255,13 +1338,17 @@ class OpenCodeAgent(OpenCodeMessageProcessorMixin, BaseAgent):model_hub_overlay_reservation,)model_hub_overlay_reservation = None+ resource_failure = self._resource_failure_for_server(server)logger.error(f"Failed to start OpenCode server: {e}", exc_info=True)await emit_backend_failure(self.controller,request.context,self.name,str(e),- display_text=self._server_start_error_display_text(e),+ display_text=self._server_start_error_display_text(+ e,+ resource_failure=resource_failure,+ ),request=request,)await self._remove_ack_reaction(request)@@ -1300,6 +1387,7 @@ class OpenCodeAgent(OpenCodeMessageProcessorMixin, BaseAgent):model_hub_overlay_reservation,)model_hub_overlay_reservation = None+ resource_failure = resource_failure or self._resource_failure_for_server(server)# The previous session is gone server-side — surface it as a terminal# ERROR result (outbound chokepoint turns the dot red), don't silently# fork a fresh session and lose context.@@ -1308,7 +1396,7 @@ class OpenCodeAgent(OpenCodeMessageProcessorMixin, BaseAgent):request.context,self.name,str(e),- display_text=f"❌ {e}",+ display_text=f"❌ {e}{self._resource_failure_suffix(resource_failure)}",request=request,)await self._remove_ack_reaction(request)@@ -1319,6 +1407,7 @@ class OpenCodeAgent(OpenCodeMessageProcessorMixin, BaseAgent):model_hub_overlay_reservation,)model_hub_overlay_reservation = None+ resource_failure = resource_failure or self._resource_failure_for_server(server)# A transient/transport/auth failure while acquiring the session# (get_session now raises on non-404, Codex P2): surface it as a# terminal error result instead of letting it propagate unhandled or be@@ -1331,7 +1420,7 @@ class OpenCodeAgent(OpenCodeMessageProcessorMixin, BaseAgent):request.context,self.name,str(e),- display_text=message,+ display_text=f"{message}{self._resource_failure_suffix(resource_failure)}",request=request,)await self._remove_ack_reaction(request)@@ -1364,7 +1453,6 @@ class OpenCodeAgent(OpenCodeMessageProcessorMixin, BaseAgent):request.base_session_id,_target_agent_session_id(request),)- self._session_manager.mark_initialized(session_id)except BaseException as error:if isinstance(error, asyncio.CancelledError):await self._finish_prestart_cancellation(@@ -1487,7 +1575,6 @@ class OpenCodeAgent(OpenCodeMessageProcessorMixin, BaseAgent):request.working_path,request.session_key,)- self._session_manager.mark_initialized(session_id)baseline_messages = await server.list_messages(session_id=session_id,directory=request.working_path,@@ -1792,6 +1879,7 @@ class OpenCodeAgent(OpenCodeMessageProcessorMixin, BaseAgent):raiseexcept OpenCodePromptRejectedError as e:error_text = f"{type(e).__name__}: {e}"+ resource_failure = resource_failure or self._resource_failure_for_server(server)logger.error("OpenCode prompt was definitively rejected: %s", e)poll_can_be_removed = not (logical_turn_id and start_attempt_id)@@ -1843,7 +1931,10 @@ class OpenCodeAgent(OpenCodeMessageProcessorMixin, BaseAgent):request.context,self.name,error_text,- display_text=f"OpenCode request failed: {error_text}",+ display_text=(+ f"OpenCode request failed: {error_text}"+ f"{self._resource_failure_suffix(resource_failure)}"+ ),request=request,)except Exception as e:@@ -1851,6 +1942,7 @@ class OpenCodeAgent(OpenCodeMessageProcessorMixin, BaseAgent):error_details = str(e).strip()error_text = f"{error_name}: {error_details}" if error_details else error_name+ resource_failure = resource_failure or self._resource_failure_for_server(server)logger.error(f"OpenCode request failed: {error_text}", exc_info=True)await self.record_model_hub_native_failure(request.context, error_text)try:@@ -1876,7 +1968,7 @@ class OpenCodeAgent(OpenCodeMessageProcessorMixin, BaseAgent):request.context,self.name,error_text,- display_text=message,+ display_text=f"{message}{self._resource_failure_suffix(resource_failure)}",request=request,)finally:diff --git a/modules/agents/opencode/server.py b/modules/agents/opencode/server.pyindex d9feef321..6424ce09d 100644--- a/modules/agents/opencode/server.py+++ b/modules/agents/opencode/server.py@@ -246,6 +246,8 @@ class OpenCodeServerManager:self.resource_governor = resource_governorself.host = DEFAULT_OPENCODE_HOSTself._process: Optional[Process] = None+ self._last_start_failure_pid: int | None = None+ self._start_attempt_generation = 0# The event loop ``_process`` was created on. Subprocess transports# bind their internal Future / wait helpers to the creating loop;# ``process.wait()`` or ``terminate_process_tree(process)`` from a@@ -287,6 +289,7 @@ class OpenCodeServerManager:self._model_hub_overlay_drain_timeout_seconds = MODEL_HUB_OVERLAY_DRAIN_TIMEOUT_SECONDSself._runtime_activation_retire: Callable[[bool, bool], bool] | None = Noneself._runtime_generation_token: tuple[int, float | None] | None = None+ self._observed_runtime_process: tuple[int, float] | None = Nonedef set_runtime_activation_retire(self,@@ -324,6 +327,7 @@ class OpenCodeServerManager:"OpenCode runtime replacement could not retire its activation generation")self._runtime_generation_token = None+ self._observed_runtime_process = Nonedef _observe_runtime_generation(self,@@ -338,6 +342,47 @@ class OpenCodeServerManager:if previous is not None and previous != token:self._retire_runtime_generation_for_replacement()self._runtime_generation_token = token+ if previous != token:+ self._last_start_failure_pid = None+ if previous != token or self._observed_runtime_process is None:+ created_at = runtime.process_create_time(token[0])+ self._observed_runtime_process = (+ (token[0], created_at) if created_at is not None else None+ )++ def observed_runtime_exit_pid(self) -> int | None:+ """Return only an observed server generation that has since exited."""++ identity = self._observed_runtime_process+ if identity is None:+ return None+ pid, created_at = identity+ current_created_at = runtime.process_create_time(pid)+ if current_created_at == created_at or (+ current_created_at is None and self._pid_exists(pid)+ ):+ return None+ return pid++ def _pid_file_proves_owned_server(self, info: Optional[Dict[str, Any]]) -> bool:+ if not isinstance(info, dict):+ return False+ pid = info.get("pid")+ created_at = info.get("process_created_at")+ if not isinstance(pid, int) or not isinstance(created_at, (int, float)):+ return False+ if isinstance(created_at, bool) or created_at <= 0:+ return False+ if not self._pid_file_references_current_server(info):+ return False+ return runtime.process_create_time(pid) == float(created_at)++ def _terminate_owned_adopted_server_sync(+ self, pid: int, info: Dict[str, Any]+ ) -> bool:+ if not self._pid_file_proves_owned_server(info):+ raise RuntimeError("OpenCode server ownership cannot be proven")+ return self._terminate_pid_tree_sync(pid)def _caller_context_path(self) -> str:return server_environment()["AVIBE_OPENCODE_CALLER_CONTEXT_PATH"]@@ -494,16 +539,25 @@ class OpenCodeServerManager:async with self._get_lock():if self._active_requests or self._has_active_run_sessions():raise RuntimeError("OpenCode runtime is busy")- retire = self._runtime_activation_retire- if callable(retire) and not retire(False, True):- raise RuntimeError("OpenCode runtime retirement was refused")process = self._process- # A pid-file without a live child handle is not sufficient proof of- # ownership (PID reuse). Leave it for the external-process blocker.info = self._read_pid_file()recorded_pid = info.get("pid") if isinstance(info, dict) else Noneif process is None and isinstance(recorded_pid, int) and self._pid_exists(recorded_pid):- raise RuntimeError("OpenCode server ownership cannot be proven")+ # A command/port match alone can belong to a reused PID.+ if not self._pid_file_proves_owned_server(info):+ raise RuntimeError("OpenCode server ownership cannot be proven")+ retire = self._runtime_activation_retire+ if callable(retire) and not retire(False, True):+ raise RuntimeError("OpenCode runtime retirement was refused")+ if process is None and isinstance(recorded_pid, int) and self._pid_exists(recorded_pid):+ if not await finish_native_operation(+ asyncio.to_thread(+ self._terminate_owned_adopted_server_sync,+ recorded_pid,+ info,+ )+ ) or self._pid_exists(recorded_pid):+ raise RuntimeError("OpenCode server did not exit")if process is not None and process.returncode is None:if not await finish_native_operation(asyncio.to_thread(self._terminate_pid_tree_sync, process.pid)@@ -518,6 +572,7 @@ class OpenCodeServerManager:self._process_loop = Noneself._base_url = Noneself._runtime_generation_token = None+ self._observed_runtime_process = Noneself._auth_refresh_pending = Falseself._auth_refresh_pending_port = Noneself._apply_pending_runtime_config_locked()@@ -573,6 +628,7 @@ class OpenCodeServerManager:self._process_loop = Noneself._base_url = Noneself._runtime_generation_token = None+ self._observed_runtime_process = Noneself._auth_refresh_pending = Falseself._auth_refresh_pending_port = Noneself._apply_pending_runtime_config_locked()@@ -1013,6 +1069,7 @@ class OpenCodeServerManager:caller_context_path: object = _USE_CURRENT_CALLER_CONTEXT_PATH,owner_pid: Optional[int] = _CURRENT_OWNER_PID,runtime_policy_revision: Optional[str] = _MANAGED_RUNTIME_POLICY_REVISION,+ process_created_at: float | None = None,) -> None:try:self._pid_file.parent.mkdir(parents=True, exist_ok=True)@@ -1025,6 +1082,8 @@ class OpenCodeServerManager:}if owner_pid is not None:payload["owner_pid"] = owner_pid+ if process_created_at is not None:+ payload["process_created_at"] = process_created_atif runtime_policy_revision is not None:payload["runtime_policy_revision"] = runtime_policy_revisionif caller_context_path is _USE_CURRENT_CALLER_CONTEXT_PATH:@@ -1837,6 +1896,8 @@ class OpenCodeServerManager:# ``runtime.stop_pid``) is loop-agnostic and is the correct# cleanup path; just detach the dangling Python object first.current_loop = asyncio.get_running_loop()+ self._start_attempt_generation += 1+ self._last_start_failure_pid = Noneif (self._processand self._process.returncode is None@@ -1916,7 +1977,10 @@ class OpenCodeServerManager:# safely before issuing ``process.wait()``.self._process_loop = current_loopif self._process and self._process.pid:- self._write_pid_file(self._process.pid)+ self._write_pid_file(+ self._process.pid,+ process_created_at=runtime.process_create_time(self._process.pid),+ )self._apply_resource_governance(self._process.pid)except FileNotFoundError:raise RuntimeError(@@ -1934,12 +1998,18 @@ class OpenCodeServerManager:breakawait asyncio.sleep(0.5)- exit_code = self._process.returncode+ process = self._process+ exit_code = process.returncode+ # A live process below is terminated by Avibe for timeout. Only an+ # independently exited process may consume shared pressure evidence.+ self._last_start_failure_pid = (+ getattr(process, "pid", None) if exit_code is not None else None+ )if exit_code is None:# A late-starting process must not become a healthy but unmanaged# server after this call reports failure and clears its PID file.await terminate_process_tree(- self._process,+ process,logger,"OpenCode server after startup timeout",terminate_timeout=5,@@ -2012,6 +2082,8 @@ class OpenCodeServerManager:self._base_url = Noneself._process = Noneself._process_loop = None+ self._runtime_generation_token = None+ self._observed_runtime_process = None@classmethoddef terminate_instance_sync(cls) -> None:diff --git a/modules/agents/opencode/session.py b/modules/agents/opencode/session.pyindex cf9f8b78d..9195052da 100644--- a/modules/agents/opencode/session.py+++ b/modules/agents/opencode/session.py@@ -131,7 +131,6 @@ class OpenCodeSessionManager:self._request_sessions: Dict[str, RequestSessionTuple] = {}self._agent_session_ids: Dict[str, str] = {}self._session_locks: Dict[str, asyncio.Lock] = {}- self._initialized_sessions: set[str] = set()def get_request_session(self, base_session_id: str) -> Optional[RequestSessionTuple]:return self._request_sessions.get(base_session_id)@@ -153,6 +152,12 @@ class OpenCodeSessionManager:self._agent_session_ids.pop(base_session_id, None)return self._request_sessions.pop(base_session_id, None)+ def retire_request_session(self, base_session_id: str) -> None:+ """Release disposable Session state after its native turn has settled."""++ self.pop_request_session(base_session_id)+ self._session_locks.pop(base_session_id, None)+def set_agent_session_id(self,base_session_id: str,@@ -330,14 +335,6 @@ class OpenCodeSessionManager:)return agent_session_id- def mark_initialized(self, opencode_session_id: str) -> bool:- """Return True if this session was newly marked initialized."""-- if opencode_session_id in self._initialized_sessions:- return False- self._initialized_sessions.add(opencode_session_id)- return True-async def repair_message_order(self,request: AgentRequest,diff --git a/modules/agents/service.py b/modules/agents/service.pyindex 416f7927e..4d5745646 100644--- a/modules/agents/service.py+++ b/modules/agents/service.py@@ -409,6 +409,22 @@ class AgentService:else None)self.release_runtime_turn_key(runtime_key, gate.token)+ defer_close_after = getattr(+ dispatcher,+ "defer_close_after_until_run_terminal",+ None,+ )+ if (+ (request.context.platform_specific or {}).get("close_after")+ and callable(defer_close_after)+ ):+ try:+ defer_close_after(request.context)+ except Exception:+ logger.warning(+ "Failed to defer close-after after prewrite Stop",+ exc_info=True,+ )cleanup = getattr(dispatcher,"finish_prewrite_stop_surfaces",@@ -592,6 +608,7 @@ class AgentService:gate.runtime_started = Truegate.activation_identity = activation_identitygate.liveness_probe = self._capture_backend_liveness(gate, context)+ gate.exit_failure_probe = self._capture_backend_exit_failure(gate, context)self._start_runtime_liveness_monitor(runtime_key, gate, runtime_token)manager = getattr(self.controller, "session_turns", None)bind_native = getattr(manager, "on_native_start", None)@@ -661,6 +678,25 @@ class AgentService:)return lambda: self.backend_alive(context, use_captured=False)+ @staticmethod+ def _capture_backend_exit_failure(+ gate: "_RuntimeTurnGate",+ context: Any,+ ) -> Callable[[], tuple[str, str] | None] | None:+ capture = getattr(gate.agent, "capture_backend_exit_failure", None)+ if callable(capture):+ try:+ probe = capture(context)+ if callable(probe):+ return probe+ except Exception:+ logger.debug(+ "Failed to capture backend exit diagnosis for %s",+ gate.backend,+ exc_info=True,+ )+ return None+@staticmethoddef _probe_backend_liveness(probe: Callable[[], Optional[bool]] | None,@@ -763,15 +799,39 @@ class AgentService:if gate.request is not Noneelse terminal_turn_output())- await emit(- context,- "result",- "",- is_error=True,- level="silent",- output=output,- terminal_error=self._backend_exit_terminal_error,- )+ diagnosis = None+ if gate.exit_failure_probe is not None:+ try:+ diagnosis = gate.exit_failure_probe()+ except Exception:+ logger.exception(+ "Backend exit diagnosis failed for backend=%s runtime=%s",+ gate.backend,+ runtime_key,+ )+ if diagnosis is not None:+ from core.backend_failure import emit_backend_failure++ diagnostic, display_text = diagnosis+ await emit_backend_failure(+ self.controller,+ context,+ gate.backend,+ diagnostic,+ display_text=display_text,+ request=gate.request,+ output=output,+ )+ else:+ await emit(+ context,+ "result",+ "",+ is_error=True,+ level="silent",+ output=output,+ terminal_error=self._backend_exit_terminal_error,+ )except asyncio.CancelledError:raiseexcept Exception:@@ -883,6 +943,7 @@ class AgentService:context.platform_specific[AGENT_RUNTIME_TURN_KEY] = runtime_keycontext.platform_specific[AGENT_RUNTIME_TURN_TOKEN] = gate.tokengate.liveness_probe = self._capture_backend_liveness(gate, context)+ gate.exit_failure_probe = self._capture_backend_exit_failure(gate, context)self._start_runtime_liveness_monitor(runtime_key, gate, gate.token)context.platform_specific[AGENT_TURN_TOKEN] = gate.tokenmanager = getattr(self.controller, "session_turns", None)@@ -939,7 +1000,76 @@ class AgentService:finally:self.release_runtime_turn_key(runtime_key, runtime_token)- def release_runtime_turn_key(self, runtime_key: str, runtime_token: str | None = None) -> None:+ def reserve_close_after_teardown(+ self, context: Any+ ) -> tuple[str, str, asyncio.Task | None] | bool | None:+ """Hold the completed turn's gate while its disposable runtime is closed.++ An already queued successor takes priority and retains the runtime.+ Otherwise the reservation prevents a newly arriving successor from+ starting during asynchronous backend teardown.+ """+ payload = getattr(context, "platform_specific", None) or {}+ runtime_key = str(payload.get(AGENT_RUNTIME_TURN_KEY) or "").strip()+ runtime_token = str(payload.get(AGENT_RUNTIME_TURN_TOKEN) or "").strip()+ gate = self._turn_gates.get(runtime_key)+ if not runtime_key or not runtime_token or gate is None or gate.token != runtime_token:+ return None+ if self._lock_has_live_waiters(gate.lock):+ self.release_runtime_turn(context)+ return False+ manager = getattr(self.controller, "session_turns", None)+ bind_terminal = getattr(manager, "on_native_terminal", None)+ try:+ if callable(bind_terminal):+ bind_terminal(context, outcome="terminal")+ except Exception:+ logger.exception("native terminal ownership reconciliation failed before close-after")+ self.release_runtime_turn_key(runtime_key, runtime_token)+ return False+ has_successor = getattr(manager, "has_close_after_successor", None)+ if callable(has_successor):+ session_id = str(payload.get("agent_session_id") or "").strip()+ completed_turn_id = str(payload.get("turn_token") or "").strip()+ try:+ if has_successor(session_id, completed_turn_id):+ self.release_runtime_turn_key(runtime_key, runtime_token)+ return False+ except Exception:+ logger.exception("durable successor check failed before close-after")+ self.release_runtime_turn_key(runtime_key, runtime_token)+ return False+ reservation = f"close-after:{uuid.uuid4().hex}"+ turn_task = gate.task+ self.release_runtime_turn_key(runtime_key, runtime_token, reserve_token=reservation)+ return runtime_key, reservation, turn_task++ async def reserve_idle_close_after_teardown(+ self, runtime_key: str+ ) -> tuple[str, str, None] | bool:+ """Reserve an idle runtime before detached close-after teardown.++ The uncontended acquire completes without yielding. If a successor owns+ or is queued on the gate, leave it untouched rather than stop its runtime.+ """+ runtime_key = str(runtime_key or "").strip()+ if not runtime_key:+ return False+ gate = self._get_turn_gate(runtime_key)+ if gate.lock.locked() or self._lock_has_live_waiters(gate.lock) or gate.token:+ return False+ await gate.lock.acquire()+ reservation = f"close-after:{uuid.uuid4().hex}"+ gate.token = reservation+ return runtime_key, reservation, None++ def release_runtime_turn_key(+ self,+ runtime_key: str,+ runtime_token: str | None = None,+ *,+ reserve_token: str | None = None,+ ) -> None:runtime_key = str(runtime_key or "").strip()if not runtime_key:return@@ -950,7 +1080,7 @@ class AgentService:returnliveness_task = gate.liveness_taskgate.liveness_task = None- gate.token = ""+ gate.token = reserve_token or ""gate.backend = ""gate.runtime_started = Falsegate.runtime_progress_token = ""@@ -960,6 +1090,7 @@ class AgentService:gate.request = Nonegate.activation_identity = Nonegate.liveness_probe = None+ gate.exit_failure_probe = Noneif liveness_task is not None and not liveness_task.done():try:current = asyncio.current_task()@@ -967,7 +1098,7 @@ class AgentService:current = Noneif liveness_task is not current:liveness_task.cancel()- if gate.lock.locked():+ if gate.lock.locked() and reserve_token is None:gate.lock.release()async def force_cancel_backend_turns(self, backend: str) -> None:@@ -1211,5 +1342,6 @@ class _RuntimeTurnGate:request: AgentRequest | None = Noneactivation_identity: RuntimeActivationIdentity | None = Noneliveness_probe: Callable[[], Optional[bool]] | None = None+ exit_failure_probe: Callable[[], tuple[str, str] | None] | None = Nonecancel_tidy_task: asyncio.Task | None = Noneliveness_task: asyncio.Task | None = Nonediff --git a/skills/use-avibe/references/global-config.md b/skills/use-avibe/references/global-config.mdindex 2882bac2c..821c640cb 100644--- a/skills/use-avibe/references/global-config.md+++ b/skills/use-avibe/references/global-config.md@@ -67,7 +67,11 @@ Important config payload shape:},"runtime": {"default_cwd": "/path/to/workdir",- "log_level": "INFO"+ "log_level": "INFO",+ "resource_governance": {+ "mode": "auto",+ "agent_pids_max": 4096+ }},"agents": {"opencode": {diff --git a/tests/test_agent_backend_alive.py b/tests/test_agent_backend_alive.pyindex 678074f42..704db047e 100644--- a/tests/test_agent_backend_alive.py+++ b/tests/test_agent_backend_alive.py@@ -11,6 +11,7 @@ import sysimport typesimport unittestfrom pathlib import Path+from unittest.mock import patchsys.path.insert(0, str(Path(__file__).resolve().parents[1]))@@ -18,6 +19,9 @@ from modules.agents.base import AGENT_RUNTIME_TURN_KEYfrom modules.agents.service import AgentServicefrom modules.agents.claude_agent import ClaudeAgentfrom modules.agents.codex.agent import CodexAgent+from modules.agents.opencode.agent import OpenCodeAgent+from modules.agents.opencode.server import OpenCodeServerManager+from core.resource_governance import AgentResourceFailurefrom modules.im import MessageContext@@ -128,6 +132,120 @@ class CodexBackendAliveTests(unittest.TestCase):self.assertIs(agent.backend_alive(context), True)self.assertIs(probe(), False)+ def test_captured_exit_failure_uses_accepted_transport_after_replacement(self):+ process = types.SimpleNamespace(returncode=None)+ accepted = types.SimpleNamespace(is_alive=True, _process=process)+ agent = self._agent(+ cwd_for_session={"b1": "/repo"},+ transports={"/repo": accepted},+ )+ agent.controller = types.SimpleNamespace(+ config=types.SimpleNamespace(language="en")+ )+ diagnose = agent.capture_backend_exit_failure(self._ctx_base("b1"))+ self.assertIsNotNone(diagnose)+ process.returncode = 137+ agent._transports["/repo"] = types.SimpleNamespace(+ is_alive=True,+ _process=types.SimpleNamespace(returncode=None),+ )+ pressure = AgentResourceFailure(+ kind="pids",+ message="shared cgroup limit event",+ pids_current=0,+ pids_max=4096,+ )++ with patch(+ "modules.agents.codex.agent.observe_agent_resource_pressure",+ side_effect=[pressure, None],+ ) as observe:+ diagnostic, visible = diagnose()+ self.assertEqual(diagnose(), (diagnostic, visible))++ observe.assert_called_once_with(agent.controller)+ self.assertIn("Resource diagnosis: shared cgroup limit event", diagnostic)+ self.assertIn("(0/4096)", visible)++ def test_captured_exit_failure_caches_negative_pressure_check(self):+ process = types.SimpleNamespace(returncode=None)+ accepted = types.SimpleNamespace(is_alive=False, _process=process)+ agent = self._agent(+ cwd_for_session={"b1": "/repo"},+ transports={"/repo": accepted},+ )+ agent.controller = types.SimpleNamespace(+ config=types.SimpleNamespace(language="en")+ )+ diagnose = agent.capture_backend_exit_failure(self._ctx_base("b1"))+ self.assertIsNotNone(diagnose)+ later_pressure = AgentResourceFailure(+ kind="memory",+ message="pressure from a later process",+ )++ with patch(+ "modules.agents.codex.agent.observe_agent_resource_pressure",+ side_effect=[None, later_pressure],+ ) as observe:+ # The first liveness failure is not yet a confirmed process exit.+ self.assertIsNone(diagnose())+ observe.assert_not_called()+ process.returncode = 137+ self.assertIsNone(diagnose())+ self.assertIsNone(diagnose())++ observe.assert_called_once_with(agent.controller)+++class OpenCodeResourceExitTests(unittest.TestCase):+ def test_adopted_exit_consumes_pressure_only_after_original_generation_exits(self):+ agent = OpenCodeAgent.__new__(OpenCodeAgent)+ agent.controller = types.SimpleNamespace()+ server = OpenCodeServerManager(binary="opencode", port=4096)+ pressure = AgentResourceFailure(kind="pids", message="shared cgroup limit event")++ with patch(+ "modules.agents.opencode.server.runtime.process_create_time",+ side_effect=[1000.0, 1000.0, 2000.0],+ ), patch(+ "modules.agents.opencode.agent.observe_agent_resource_pressure",+ return_value=pressure,+ ) as observe:+ server._observe_runtime_generation({"pid": 654, "started_at": 1.0})+ self.assertIsNone(agent._resource_failure_for_server(server))+ observe.assert_not_called()+ self.assertIs(agent._resource_failure_for_server(server), pressure)+ observe.assert_called_once_with(agent.controller)++ def test_pressure_checks_are_cached_per_observed_server_generation(self):+ agent = OpenCodeAgent.__new__(OpenCodeAgent)+ agent.controller = types.SimpleNamespace()+ server = OpenCodeServerManager(binary="opencode", port=4096)+ server.observed_runtime_exit_pid = (+ lambda: server._runtime_generation_token[0]+ )+ pressure = AgentResourceFailure(kind="pids", message="first exit")+ later_pressure = AgentResourceFailure(kind="memory", message="third exit")++ with patch(+ "modules.agents.opencode.server.runtime.process_create_time",+ return_value=1000.0,+ ), patch(+ "modules.agents.opencode.agent.observe_agent_resource_pressure",+ side_effect=[pressure, None, later_pressure],+ ) as observe:+ server._observe_runtime_generation({"pid": 654, "started_at": 1.0})+ self.assertIs(agent._resource_failure_for_server(server), pressure)+ self.assertIs(agent._resource_failure_for_server(server), pressure)+ server._observe_runtime_generation({"pid": 655, "started_at": 2.0})+ self.assertIsNone(agent._resource_failure_for_server(server))+ self.assertIsNone(agent._resource_failure_for_server(server))+ server._observe_runtime_generation({"pid": 656, "started_at": 3.0})+ self.assertIs(agent._resource_failure_for_server(server), later_pressure)++ self.assertEqual(observe.call_count, 3)+class AgentServiceBackendAliveTests(unittest.TestCase):def _service(self, *, backend_name, gate_backend, probe_return):diff --git a/tests/test_agent_run_close_after.py b/tests/test_agent_run_close_after.pynew file mode 100644index 000000000..a6707b5de--- /dev/null+++ b/tests/test_agent_run_close_after.py@@ -0,0 +1,1004 @@+from __future__ import annotations++import asyncio+from types import SimpleNamespace+from unittest.mock import AsyncMock, Mock, patch++from core.inbox_events import RUNS_UPDATED_EVENT, bus+from modules.im import MessageContext+from core.message_dispatcher import ConsolidatedMessageDispatcher+from core.message_output import MessageOutput, stop_output_for+from modules.agents.service import AgentService+++def test_close_after_releases_the_owned_runtime_after_terminal_result() -> None:+ controller = SimpleNamespace()+ controller.agent_service = AgentService(controller)+ dispatcher = ConsolidatedMessageDispatcher(controller)+ context = MessageContext(+ user_id="user",+ channel_id="session-1",+ platform="avibe",+ platform_specific={+ "agent_session_id": "session-1",+ "agent_backend": "claude",+ "close_after": True,+ "agent_runtime_turn_key": "runtime-1",+ "agent_session_target": {+ "agent_backend": "claude",+ "session_anchor": "base-session-1",+ },+ },+ )+ end_running_agent = AsyncMock(return_value={"ok": True, "action": "ended"})++ async def exercise() -> None:+ with patch(+ "core.services.running_agents.end_running_agent",+ new=end_running_agent,+ ):+ dispatcher._schedule_close_after_runtime(context)+ await asyncio.sleep(0.01)++ asyncio.run(exercise())++ end_running_agent.assert_awaited_once_with(+ controller,+ backend="claude",+ session_id="session-1",+ base_session_id="base-session-1",+ )+ assert dispatcher._close_after_session_ids == set()+++def test_close_after_waits_until_runtime_turn_release() -> None:+ release_order: list[str] = []+ controller = SimpleNamespace(+ agent_service=SimpleNamespace(+ release_runtime_turn=lambda _context: release_order.append("release"),+ reserve_idle_close_after_teardown=AsyncMock(+ return_value=("runtime-1", "close-after:test", None)+ ),+ release_runtime_turn_key=lambda *_args: None,+ )+ )+ dispatcher = ConsolidatedMessageDispatcher(controller)+ context = MessageContext(+ user_id="user",+ channel_id="session-1",+ platform="avibe",+ platform_specific={+ "agent_session_id": "session-1",+ "agent_backend": "codex",+ "close_after": True,+ "agent_runtime_turn_key": "runtime-1",+ "agent_session_target": {+ "agent_backend": "codex",+ "session_anchor": "base-session-1",+ },+ "_close_after_runtime_pending": True,+ },+ )+ end_running_agent = AsyncMock(return_value={"ok": True, "action": "ended"})++ async def exercise() -> None:+ with patch(+ "core.services.running_agents.end_running_agent",+ new=end_running_agent,+ ):+ dispatcher._release_runtime_turn(context, MessageOutput(completes_turn=True))+ assert release_order == ["release"]+ await asyncio.sleep(0.01)++ asyncio.run(exercise())++ end_running_agent.assert_awaited_once_with(+ controller,+ backend="codex",+ session_id="session-1",+ base_session_id="base-session-1",+ )+++def test_close_after_does_not_schedule_for_ordinary_runs() -> None:+ controller = SimpleNamespace()+ dispatcher = ConsolidatedMessageDispatcher(controller)+ context = MessageContext(+ user_id="user",+ channel_id="session-1",+ platform="avibe",+ platform_specific={+ "agent_session_id": "session-1",+ "agent_backend": "claude",+ },+ )++ dispatcher._schedule_close_after_runtime(context)++ assert dispatcher._close_after_runtime_tasks == set()+++def test_close_after_holds_runtime_gate_until_teardown_finishes() -> None:+ async def exercise() -> None:+ controller = SimpleNamespace()+ service = AgentService(controller)+ controller.agent_service = service+ dispatcher = ConsolidatedMessageDispatcher(controller)+ context = MessageContext(+ user_id="user",+ channel_id="session-1",+ platform="avibe",+ platform_specific={+ "agent_session_id": "session-1",+ "agent_backend": "codex",+ "close_after": True,+ "agent_session_target": {+ "agent_backend": "codex",+ "session_anchor": "base-session-1",+ },+ "agent_runtime_turn_key": "runtime-1",+ "agent_runtime_turn_token": "turn-1",+ "_close_after_runtime_pending": True,+ },+ )+ gate = service._get_turn_gate("runtime-1")+ await gate.lock.acquire()+ gate.token = "turn-1"+ gate.backend = "codex"+ closing = asyncio.Event()+ finish_close = asyncio.Event()++ async def end_running_agent(*_args, **_kwargs):+ closing.set()+ await finish_close.wait()+ return {"ok": True}++ with patch(+ "core.services.running_agents.end_running_agent",+ new=end_running_agent,+ ):+ dispatcher._release_runtime_turn(context, MessageOutput(completes_turn=True))+ assert gate.lock.locked()+ assert gate.token.startswith("close-after:")+ await asyncio.wait_for(closing.wait(), timeout=1)+ successor = asyncio.create_task(gate.lock.acquire())+ await asyncio.sleep(0)+ assert not successor.done()+ finish_close.set()+ await asyncio.wait_for(successor, timeout=1)+ gate.lock.release()++ asyncio.run(exercise())+++def test_close_after_waits_for_backend_cleanup_after_terminal_delivery() -> None:+ async def exercise() -> None:+ controller = SimpleNamespace()+ service = AgentService(controller)+ controller.agent_service = service+ dispatcher = ConsolidatedMessageDispatcher(controller)+ context = MessageContext(+ user_id="user",+ channel_id="session-1",+ platform="avibe",+ platform_specific={+ "agent_session_id": "session-1",+ "agent_backend": "opencode",+ "close_after": True,+ "agent_session_target": {+ "agent_backend": "opencode",+ "session_anchor": "base-session-1",+ },+ "agent_runtime_turn_key": "runtime-1",+ "agent_runtime_turn_token": "turn-1",+ "_close_after_runtime_pending": True,+ },+ )+ gate = service._get_turn_gate("runtime-1")+ await gate.lock.acquire()+ gate.token = "turn-1"+ gate.backend = "opencode"+ backend_finished = asyncio.Event()+ backend_task = asyncio.create_task(backend_finished.wait())+ gate.task = backend_task+ end_running_agent = AsyncMock(return_value={"ok": True})++ with patch(+ "core.services.running_agents.end_running_agent",+ new=end_running_agent,+ ):+ dispatcher._release_runtime_turn(context, MessageOutput(completes_turn=True))+ await asyncio.sleep(0.01)+ assert gate.lock.locked()+ end_running_agent.assert_not_awaited()+ backend_finished.set()+ await backend_task+ await asyncio.sleep(0.01)+ end_running_agent.assert_awaited_once()+ assert not gate.lock.locked()++ asyncio.run(exercise())+++def test_close_after_does_not_close_when_successor_is_already_queued() -> None:+ async def exercise() -> None:+ controller = SimpleNamespace()+ service = AgentService(controller)+ controller.agent_service = service+ dispatcher = ConsolidatedMessageDispatcher(controller)+ context = MessageContext(+ user_id="user",+ channel_id="session-1",+ platform="avibe",+ platform_specific={+ "agent_session_id": "session-1",+ "agent_backend": "claude",+ "close_after": True,+ "agent_session_target": {+ "agent_backend": "claude",+ "session_anchor": "base-session-1",+ },+ "agent_runtime_turn_key": "runtime-1",+ "agent_runtime_turn_token": "turn-1",+ "_close_after_runtime_pending": True,+ },+ )+ gate = service._get_turn_gate("runtime-1")+ await gate.lock.acquire()+ gate.token = "turn-1"+ gate.backend = "claude"+ successor = asyncio.create_task(gate.lock.acquire())+ await asyncio.sleep(0)+ end_running_agent = AsyncMock(return_value={"ok": True})+ with patch(+ "core.services.running_agents.end_running_agent",+ new=end_running_agent,+ ):+ dispatcher._release_runtime_turn(context, MessageOutput(completes_turn=True))+ await asyncio.wait_for(successor, timeout=1)+ assert dispatcher._close_after_runtime_tasks == set()+ end_running_agent.assert_not_awaited()+ gate.lock.release()++ asyncio.run(exercise())+++def test_close_after_does_not_reserve_over_durable_successor() -> None:+ async def exercise() -> None:+ successor_promoted = False++ def on_native_terminal(_context, *, outcome):+ nonlocal successor_promoted+ assert outcome == "terminal"+ successor_promoted = True++ def has_successor(session_id, completed_turn_id):+ assert (session_id, completed_turn_id) == ("session-1", "logical-1")+ return successor_promoted++ controller = SimpleNamespace(+ session_turns=SimpleNamespace(+ on_native_terminal=on_native_terminal,+ has_close_after_successor=has_successor,+ )+ )+ service = AgentService(controller)+ controller.agent_service = service+ dispatcher = ConsolidatedMessageDispatcher(controller)+ context = MessageContext(+ user_id="user",+ channel_id="session-1",+ platform="avibe",+ platform_specific={+ "agent_session_id": "session-1",+ "agent_backend": "codex",+ "close_after": True,+ "turn_token": "logical-1",+ "agent_runtime_turn_key": "runtime-1",+ "agent_runtime_turn_token": "native-1",+ "agent_session_target": {+ "agent_backend": "codex",+ "session_anchor": "base-session-1",+ },+ "_close_after_runtime_pending": True,+ },+ )+ gate = service._get_turn_gate("runtime-1")+ await gate.lock.acquire()+ gate.token = "native-1"+ end_running_agent = AsyncMock(return_value={"ok": True})+ with patch(+ "core.services.running_agents.end_running_agent",+ new=end_running_agent,+ ):+ dispatcher._release_runtime_turn(+ context, MessageOutput(completes_turn=True)+ )+ assert successor_promoted+ assert not gate.lock.locked()+ await asyncio.sleep(0)+ end_running_agent.assert_not_awaited()+ assert dispatcher._close_after_runtime_tasks == set()++ asyncio.run(exercise())+++def test_close_after_preserves_runtime_when_durable_probe_fails() -> None:+ def unreadable_successor(_session_id, _completed_turn_id):+ raise RuntimeError("database unavailable")++ async def exercise() -> None:+ controller = SimpleNamespace(+ session_turns=SimpleNamespace(+ on_native_terminal=lambda *_args, **_kwargs: None,+ has_close_after_successor=unreadable_successor,+ )+ )+ service = AgentService(controller)+ controller.agent_service = service+ dispatcher = ConsolidatedMessageDispatcher(controller)+ context = MessageContext(+ user_id="user",+ channel_id="session-1",+ platform="avibe",+ platform_specific={+ "agent_session_id": "session-1",+ "agent_backend": "codex",+ "close_after": True,+ "agent_runtime_turn_key": "runtime-1",+ "agent_runtime_turn_token": "native-1",+ "_close_after_runtime_pending": True,+ "agent_session_target": {+ "agent_backend": "codex",+ "session_anchor": "base-session-1",+ },+ },+ )+ gate = service._get_turn_gate("runtime-1")+ await gate.lock.acquire()+ gate.token = "native-1"+ end_running_agent = AsyncMock(return_value={"ok": True})+ with patch(+ "core.services.running_agents.end_running_agent",+ new=end_running_agent,+ ):+ dispatcher._release_runtime_turn(+ context, MessageOutput(completes_turn=True)+ )+ assert not gate.lock.locked()+ await asyncio.sleep(0)+ end_running_agent.assert_not_awaited()++ asyncio.run(exercise())+++def test_deferred_close_after_skips_durable_successor() -> None:+ controller = SimpleNamespace(+ session_turns=SimpleNamespace(has_close_after_successor=lambda *_args: True)+ )+ controller.agent_service = AgentService(controller)+ dispatcher = ConsolidatedMessageDispatcher(controller)+ context = MessageContext(+ user_id="user",+ channel_id="session-1",+ platform="avibe",+ platform_specific={+ "agent_session_id": "session-1",+ "agent_backend": "codex",+ "close_after": True,+ "agent_runtime_turn_key": "runtime-1",+ "agent_session_target": {+ "agent_backend": "codex",+ "session_anchor": "base-session-1",+ },+ },+ )+ end_running_agent = AsyncMock(return_value={"ok": True})++ async def exercise() -> None:+ with patch(+ "core.services.running_agents.end_running_agent",+ new=end_running_agent,+ ):+ dispatcher._schedule_close_after_runtime(context)+ await dispatcher.drain_close_after_runtime()++ asyncio.run(exercise())+ end_running_agent.assert_not_awaited()+++def test_detached_close_after_reserves_idle_gate_before_teardown() -> None:+ async def exercise() -> None:+ controller = SimpleNamespace()+ service = AgentService(controller)+ controller.agent_service = service+ dispatcher = ConsolidatedMessageDispatcher(controller)+ context = MessageContext(+ user_id="user",+ channel_id="session-1",+ platform="avibe",+ platform_specific={+ "agent_session_id": "session-1",+ "agent_backend": "claude",+ "close_after": True,+ "agent_session_target": {+ "agent_backend": "claude",+ "session_anchor": "base-session-1",+ },+ "agent_runtime_turn_key": "runtime-1",+ "agent_runtime_turn_token": "old-turn",+ },+ )+ gate = service._get_turn_gate("runtime-1")+ closing = asyncio.Event()+ finish_close = asyncio.Event()++ async def end_running_agent(*_args, **_kwargs):+ assert gate.lock.locked()+ assert gate.token.startswith("close-after:")+ closing.set()+ await finish_close.wait()+ return {"ok": True}++ with (+ patch("core.message_dispatcher.SQLiteBackgroundTaskStore"),+ patch(+ "core.services.running_agents.end_running_agent",+ new=end_running_agent,+ ),+ ):+ dispatcher._terminal_agent_run_ids = lambda *_args: ["run-1"]+ dispatcher._record_agent_run_terminal_for_ids = lambda **_kwargs: None+ dispatcher._record_agent_run_terminal_result(+ context,+ "done",+ None,+ is_error=False,+ output_semantics=MessageOutput(+ completes_turn=False,+ completes_run=True,+ detached=True,+ ),+ )+ await asyncio.wait_for(closing.wait(), timeout=1)+ successor = asyncio.create_task(gate.lock.acquire())+ await asyncio.sleep(0)+ assert not successor.done()+ finish_close.set()+ await asyncio.wait_for(successor, timeout=1)+ gate.lock.release()++ asyncio.run(exercise())+++def test_failed_run_write_does_not_arm_close_after() -> None:+ async def exercise(detached: bool) -> None:+ controller = SimpleNamespace()+ service = AgentService(controller)+ controller.agent_service = service+ dispatcher = ConsolidatedMessageDispatcher(controller)+ context = MessageContext(+ user_id="user",+ channel_id="session-1",+ platform="avibe",+ platform_specific={+ "agent_session_id": "session-1",+ "agent_backend": "claude",+ "close_after": True,+ "agent_session_target": {+ "agent_backend": "claude",+ "session_anchor": "base-session-1",+ },+ "agent_runtime_turn_key": "runtime-1",+ "agent_runtime_turn_token": "turn-1",+ },+ )+ gate = service._get_turn_gate("runtime-1")+ await gate.lock.acquire()+ gate.token = "turn-1"+ gate.backend = "claude"+ output = MessageOutput(+ completes_turn=not detached,+ completes_run=True,+ detached=detached,+ )+ end_running_agent = AsyncMock(return_value={"ok": True})++ with (+ patch("core.message_dispatcher.SQLiteBackgroundTaskStore"),+ patch("core.services.running_agents.end_running_agent", new=end_running_agent),+ ):+ dispatcher._terminal_agent_run_ids = lambda *_args: ["run-1"]+ dispatcher._record_agent_run_terminal_for_ids = Mock(+ side_effect=RuntimeError("SQLite write failed")+ )+ dispatcher._record_agent_run_terminal_result(+ context,+ "done",+ None,+ is_error=False,+ output_semantics=output,+ )+ if not detached:+ dispatcher._release_runtime_turn(context, output)+ await asyncio.sleep(0)++ assert not context.platform_specific.get("_close_after_runtime_pending")+ assert dispatcher._close_after_runtime_tasks == set()+ end_running_agent.assert_not_awaited()+ if detached:+ gate.lock.release()++ asyncio.run(exercise(detached=False))+ asyncio.run(exercise(detached=True))+++def test_blocking_activity_delays_close_after_until_run_settles() -> None:+ async def exercise() -> None:+ controller = SimpleNamespace()+ service = AgentService(controller)+ controller.agent_service = service+ dispatcher = ConsolidatedMessageDispatcher(controller)+ blocked = [True]+ service.activities.has_blocking_run_activity = lambda _run_id: blocked[0]+ run = {"status": "running"}+ controller.scheduled_task_service = SimpleNamespace(+ request_store=SimpleNamespace(get_run=lambda _run_id: run)+ )+ context = MessageContext(+ user_id="user",+ channel_id="session-1",+ platform="avibe",+ platform_specific={+ "agent_session_id": "session-1",+ "agent_backend": "claude",+ "close_after": True,+ "task_execution_id": "run-1",+ "task_trigger_kind": "agent_run",+ "agent_session_target": {+ "agent_backend": "claude",+ "session_anchor": "base-session-1",+ },+ "agent_runtime_turn_key": "runtime-1",+ "agent_runtime_turn_token": "turn-1",+ },+ )+ gate = service._get_turn_gate("runtime-1")+ await gate.lock.acquire()+ gate.token = "turn-1"+ gate.backend = "claude"+ recorded = []+ store = SimpleNamespace(+ record_turn_run_outputs=lambda _run_ids, **kwargs: recorded.append(kwargs),+ close=lambda: None,+ )+ closed = asyncio.Event()++ async def end_running_agent(*_args, **_kwargs):+ closed.set()+ return {"ok": True}++ output = MessageOutput(completes_turn=True, completes_run=True)+ with (+ patch("core.message_dispatcher.SQLiteBackgroundTaskStore", return_value=store),+ patch("core.services.running_agents.end_running_agent", new=end_running_agent),+ ):+ dispatcher._record_agent_run_terminal_result(+ context, "done", None, is_error=False, output_semantics=output+ )+ assert recorded[0]["deferred_run_ids"] == ["run-1"]+ dispatcher._release_runtime_turn(context, output)+ await asyncio.sleep(0)+ assert not gate.lock.locked()+ assert not closed.is_set()++ run["status"] = "succeeded"+ bus.publish(RUNS_UPDATED_EVENT, {"run_id": "run-1", "status": "succeeded"})+ await asyncio.sleep(0)+ assert not closed.is_set()++ blocked[0] = False+ bus.publish(RUNS_UPDATED_EVENT, {"run_id": "run-1", "status": "succeeded"})+ await asyncio.wait_for(closed.wait(), timeout=1)++ asyncio.run(exercise())+++def test_prewrite_cancel_waits_for_durable_run_settlement() -> None:+ async def exercise() -> None:+ controller = SimpleNamespace()+ service = AgentService(controller)+ controller.agent_service = service+ dispatcher = ConsolidatedMessageDispatcher(controller)+ run = {"status": "running"}+ controller.scheduled_task_service = SimpleNamespace(+ request_store=SimpleNamespace(get_run=lambda _run_id: run)+ )+ context = MessageContext(+ user_id="user",+ channel_id="session-1",+ platform="avibe",+ platform_specific={+ "agent_session_id": "session-1",+ "agent_backend": "codex",+ "close_after": True,+ "task_execution_id": "run-1",+ "agent_session_target": {+ "agent_backend": "codex",+ "session_anchor": "base-session-1",+ },+ "agent_runtime_turn_key": "runtime-1",+ },+ )+ closed = asyncio.Event()++ async def end_running_agent(*_args, **_kwargs):+ closed.set()+ return {"ok": True}++ with patch(+ "core.services.running_agents.end_running_agent", new=end_running_agent+ ):+ dispatcher.defer_close_after_until_run_terminal(context)+ await asyncio.sleep(0)+ assert not closed.is_set()+ run["status"] = "canceled"+ bus.publish(RUNS_UPDATED_EVENT, {"run_id": "run-1", "status": "canceled"})+ await asyncio.wait_for(closed.wait(), timeout=1)++ asyncio.run(exercise())+++def test_close_after_waits_for_backend_terminal_cleanup() -> None:+ async def exercise() -> None:+ controller = SimpleNamespace()+ controller.agent_service = AgentService(controller)+ dispatcher = ConsolidatedMessageDispatcher(controller)+ cleanup = asyncio.Event()+ context = MessageContext(+ user_id="user",+ channel_id="session-1",+ platform="avibe",+ platform_specific={+ "agent_session_id": "session-1",+ "agent_backend": "claude",+ "close_after": True,+ "agent_runtime_turn_key": "runtime-1",+ "agent_session_target": {+ "agent_backend": "claude",+ "session_anchor": "base-session-1",+ },+ "_close_after_backend_cleanup": cleanup,+ },+ )+ closed = asyncio.Event()++ async def end_running_agent(*_args, **_kwargs):+ closed.set()+ return {"ok": True}++ with patch(+ "core.services.running_agents.end_running_agent", new=end_running_agent+ ):+ dispatcher._schedule_close_after_runtime(context)+ drain = asyncio.create_task(dispatcher.drain_close_after_runtime())+ await asyncio.sleep(0)+ assert not closed.is_set()+ assert not drain.done()+ cleanup.set()+ await asyncio.wait_for(closed.wait(), timeout=1)+ await asyncio.wait_for(drain, timeout=1)++ asyncio.run(exercise())+++def test_deferred_close_after_does_not_stop_successor_after_run_settles() -> None:+ async def exercise() -> None:+ controller = SimpleNamespace()+ service = AgentService(controller)+ controller.agent_service = service+ dispatcher = ConsolidatedMessageDispatcher(controller)+ run = {"status": "running"}+ controller.scheduled_task_service = SimpleNamespace(+ request_store=SimpleNamespace(get_run=lambda _run_id: run)+ )+ context = MessageContext(+ user_id="user",+ channel_id="session-1",+ platform="avibe",+ platform_specific={+ "agent_session_id": "session-1",+ "agent_backend": "claude",+ "close_after": True,+ "task_execution_id": "run-1",+ "agent_session_target": {+ "agent_backend": "claude",+ "session_anchor": "base-session-1",+ },+ "agent_runtime_turn_key": "runtime-1",+ },+ )+ gate = service._get_turn_gate("runtime-1")+ end_running_agent = AsyncMock(return_value={"ok": True})++ with patch(+ "core.services.running_agents.end_running_agent",+ new=end_running_agent,+ ):+ dispatcher._schedule_close_after_runtime(+ context, wait_for_run_ids=("run-1",)+ )+ await asyncio.sleep(0)+ await gate.lock.acquire()+ gate.token = "successor-turn"+ run["status"] = "succeeded"+ bus.publish(RUNS_UPDATED_EVENT, {"run_id": "run-1", "status": "succeeded"})+ await asyncio.sleep(0.01)+ end_running_agent.assert_not_awaited()+ assert gate.token == "successor-turn"+ service.release_runtime_turn_key("runtime-1", "successor-turn")+ assert dispatcher._close_after_session_ids == set()++ asyncio.run(exercise())+++def test_detached_close_after_does_not_stop_successor_that_won_gate() -> None:+ async def exercise() -> None:+ controller = SimpleNamespace()+ service = AgentService(controller)+ controller.agent_service = service+ dispatcher = ConsolidatedMessageDispatcher(controller)+ context = MessageContext(+ user_id="user",+ channel_id="session-1",+ platform="avibe",+ platform_specific={+ "agent_session_id": "session-1",+ "agent_backend": "claude",+ "close_after": True,+ "agent_session_target": {+ "agent_backend": "claude",+ "session_anchor": "base-session-1",+ },+ "agent_runtime_turn_key": "runtime-1",+ },+ )+ gate = service._get_turn_gate("runtime-1")+ end_running_agent = AsyncMock(return_value={"ok": True})++ with patch(+ "core.services.running_agents.end_running_agent",+ new=end_running_agent,+ ):+ dispatcher._schedule_close_after_runtime(context)+ await gate.lock.acquire()+ gate.token = "successor-turn"+ await asyncio.sleep(0.01)+ end_running_agent.assert_not_awaited()+ assert gate.token == "successor-turn"+ service.release_runtime_turn_key("runtime-1", "successor-turn")++ asyncio.run(exercise())+++def test_idle_close_after_does_not_bypass_queued_successor() -> None:+ async def exercise() -> None:+ service = AgentService(SimpleNamespace())+ gate = service._get_turn_gate("runtime-1")+ await gate.lock.acquire()+ successor = asyncio.create_task(gate.lock.acquire())+ await asyncio.sleep(0)+ gate.lock.release()++ assert await service.reserve_idle_close_after_teardown("runtime-1") is False+ await asyncio.wait_for(successor, timeout=1)+ gate.lock.release()++ asyncio.run(exercise())+++def test_detached_close_after_without_runtime_identity_does_not_teardown() -> None:+ async def exercise() -> None:+ controller = SimpleNamespace()+ controller.agent_service = AgentService(controller)+ dispatcher = ConsolidatedMessageDispatcher(controller)+ context = MessageContext(+ user_id="user",+ channel_id="session-1",+ platform="avibe",+ platform_specific={+ "agent_session_id": "session-1",+ "agent_backend": "claude",+ "close_after": True,+ "agent_session_target": {+ "agent_backend": "claude",+ "session_anchor": "base-session-1",+ },+ },+ )+ end_running_agent = AsyncMock(return_value={"ok": True})++ with patch(+ "core.services.running_agents.end_running_agent",+ new=end_running_agent,+ ):+ dispatcher._schedule_close_after_runtime(context)+ await asyncio.sleep(0.01)++ end_running_agent.assert_not_awaited()+ assert dispatcher._close_after_session_ids == set()++ asyncio.run(exercise())+++def test_resultless_close_after_stop_schedules_teardown() -> None:+ controller = SimpleNamespace(+ agent_service=SimpleNamespace(+ release_runtime_turn=lambda _context: None,+ reserve_idle_close_after_teardown=AsyncMock(+ return_value=("runtime-1", "close-after:test", None)+ ),+ release_runtime_turn_key=lambda *_args: None,+ )+ )+ dispatcher = ConsolidatedMessageDispatcher(controller)+ context = MessageContext(+ user_id="user",+ channel_id="session-1",+ platform="avibe",+ platform_specific={+ "agent_session_id": "session-1",+ "agent_backend": "claude",+ "close_after": True,+ "agent_runtime_turn_key": "runtime-1",+ "agent_session_target": {+ "agent_backend": "claude",+ "session_anchor": "base-session-1",+ },+ },+ )+ end_running_agent = AsyncMock(return_value={"ok": True})++ async def exercise() -> None:+ with patch(+ "core.services.running_agents.end_running_agent",+ new=end_running_agent,+ ):+ dispatcher._release_runtime_turn(context, stop_output_for(None))+ await asyncio.sleep(0.01)++ asyncio.run(exercise())+ end_running_agent.assert_awaited_once()+++def test_resultless_close_after_requires_terminal_run_before_teardown() -> None:+ release = Mock()+ reserve = Mock()+ controller = SimpleNamespace(+ agent_service=SimpleNamespace(+ release_runtime_turn=release,+ reserve_close_after_teardown=reserve,+ reserve_idle_close_after_teardown=AsyncMock(),+ )+ )+ dispatcher = ConsolidatedMessageDispatcher(controller)+ wait_for_runs = AsyncMock(return_value=False)+ dispatcher._wait_for_close_after_runs = wait_for_runs+ context = MessageContext(+ user_id="user",+ channel_id="session-1",+ platform="avibe",+ platform_specific={+ "agent_session_id": "session-1",+ "agent_backend": "claude",+ "close_after": True,+ "task_trigger_kind": "agent_run",+ "task_execution_id": "run-1",+ "agent_runtime_turn_key": "runtime-1",+ "agent_session_target": {+ "agent_backend": "claude",+ "session_anchor": "base-session-1",+ },+ },+ )+ end_running_agent = AsyncMock(return_value={"ok": True})++ async def exercise() -> None:+ with patch(+ "core.services.running_agents.end_running_agent", new=end_running_agent+ ):+ dispatcher._release_runtime_turn(context, stop_output_for(None))+ await dispatcher.drain_close_after_runtime()++ asyncio.run(exercise())+ release.assert_called_once_with(context)+ reserve.assert_not_called()+ wait_for_runs.assert_awaited_once_with(("run-1",))+ end_running_agent.assert_not_awaited()+++def test_shutdown_drain_skips_teardown_for_unsettled_run() -> None:+ controller = SimpleNamespace(+ scheduled_task_service=SimpleNamespace(+ request_store=SimpleNamespace(+ get_run=lambda _run_id: {"status": "running"}+ )+ ),+ agent_service=SimpleNamespace(+ reserve_idle_close_after_teardown=AsyncMock(),+ ),+ )+ dispatcher = ConsolidatedMessageDispatcher(controller)+ context = MessageContext(+ user_id="user",+ channel_id="session-1",+ platform="avibe",+ platform_specific={+ "agent_session_id": "session-1",+ "agent_backend": "claude",+ "close_after": True,+ "agent_runtime_turn_key": "runtime-1",+ "agent_session_target": {+ "agent_backend": "claude",+ "session_anchor": "base-session-1",+ },+ },+ )+ end_running_agent = AsyncMock(return_value={"ok": True})++ async def exercise() -> None:+ with patch(+ "core.services.running_agents.end_running_agent", new=end_running_agent+ ):+ dispatcher._schedule_close_after_runtime(+ context, wait_for_run_ids=("run-1",)+ )+ await asyncio.wait_for(dispatcher.drain_close_after_runtime(), timeout=1)++ asyncio.run(exercise())+ end_running_agent.assert_not_awaited()+++def test_turn_only_result_keeps_close_after_runtime_for_activity_retry() -> None:+ async def exercise() -> None:+ controller = SimpleNamespace()+ service = AgentService(controller)+ controller.agent_service = service+ dispatcher = ConsolidatedMessageDispatcher(controller)+ context = MessageContext(+ user_id="user",+ channel_id="session-1",+ platform="avibe",+ platform_specific={+ "agent_session_id": "session-1",+ "agent_backend": "claude",+ "close_after": True,+ "agent_session_target": {+ "agent_backend": "claude",+ "session_anchor": "base-session-1",+ },+ "agent_runtime_turn_key": "runtime-1",+ "agent_runtime_turn_token": "turn-1",+ },+ )+ gate = service._get_turn_gate("runtime-1")+ await gate.lock.acquire()+ gate.token = "turn-1"+ gate.backend = "claude"+ end_running_agent = AsyncMock(return_value={"ok": True})++ with patch(+ "core.services.running_agents.end_running_agent",+ new=end_running_agent,+ ):+ dispatcher._release_runtime_turn(+ context,+ MessageOutput(completes_turn=True, completes_run=False),+ )+ await asyncio.sleep(0)++ assert not gate.lock.locked()+ assert dispatcher._close_after_runtime_tasks == set()+ end_running_agent.assert_not_awaited()++ asyncio.run(exercise())diff --git a/tests/test_agent_service.py b/tests/test_agent_service.pyindex 194b3e744..9c2c68fa2 100644--- a/tests/test_agent_service.py+++ b/tests/test_agent_service.py@@ -1465,6 +1465,7 @@ def test_message_delivery_023_prewrite_stop_releases_gate_without_terminal_tidy(controller.message_dispatcher = SimpleNamespace(status_key_for_context=Mock(return_value="status:first"),finish_prewrite_stop_surfaces=AsyncMock(side_effect=_stall_surface_cleanup),+ defer_close_after_until_run_terminal=Mock(),)service = AgentService(controller=controller)controller.agent_service = service@@ -1480,6 +1481,8 @@ def test_message_delivery_023_prewrite_stop_releases_gate_without_terminal_tidy(agent = _PrewriteAgent()service.register(agent)first = _request("first")+ first.context.platform_specific["close_after"] = True+ first.context.platform_specific["task_execution_id"] = "run-first"first_task = asyncio.create_task(service.handle_message("claude", first))await asyncio.wait_for(entered.wait(), timeout=0.5)@@ -1499,6 +1502,9 @@ def test_message_delivery_023_prewrite_stop_releases_gate_without_terminal_tidy(first.context,consolidated_key="status:first",)+ controller.message_dispatcher.defer_close_after_until_run_terminal.assert_called_once_with(+ first.context+ )second = _request("second")await asyncio.wait_for(service.handle_message("claude", second), timeout=0.5)@@ -1830,6 +1836,63 @@ def test_hfr_432_opencode_timeout_releases_fifo_and_shared_runtime() -> None:asyncio.run(_run())+def test_agent_service_reports_captured_resource_failure_after_turn_acceptance() -> None:+ async def _run() -> None:+ controller = _Controller()+ recovered = asyncio.Event()+ service = AgentService(controller=controller)+ controller.agent_service = service++ class _AcceptedThenDeadAgent(_RuntimeAgent):+ name = "codex"++ def __init__(self) -> None:+ super().__init__()+ self.current = SimpleNamespace(alive=True)++ async def handle_message(self, request) -> None:+ service.mark_runtime_turn_started(request.context)++ def capture_backend_liveness(self, _context):+ accepted = self.current+ return lambda: accepted.alive++ def capture_backend_exit_failure(self, _context):+ accepted = self.current+ return lambda: (+ ("backend_runtime_exited_before_terminal\nResource diagnosis: pids", "❌ pids limit")+ if not accepted.alive+ else None+ )++ agent = _AcceptedThenDeadAgent()+ service.register(agent)+ service._liveness_probe_interval_seconds = 0.005+ service._liveness_failure_grace_seconds = 0.005+ emitted: list[tuple[str, str, object]] = []++ async def _emit(context, message_type, text, **kwargs):+ emitted.append((message_type, text, kwargs.get("terminal_error")))+ if message_type == "result":+ service.release_runtime_turn(context)+ recovered.set()++ controller.emit_agent_message = _emit+ request = _request("long-running codex turn")+ await service.handle_message("codex", request)+ accepted = agent.current+ agent.current = SimpleNamespace(alive=True)+ accepted.alive = False++ await asyncio.wait_for(recovered.wait(), timeout=0.5)+ assert [message_type for message_type, _, _ in emitted] == ["notify", "result"]+ assert emitted[0][1] == "❌ pids limit"+ assert "Resource diagnosis: pids" in emitted[1][2]+ assert not service._turn_gates["session:/repo"].lock.locked()++ asyncio.run(_run())++def test_agent_service_recovery_uses_the_accepted_backend_generation() -> None:"""HFR-002: a replacement runtime cannot hide the accepted owner's death."""diff --git a/tests/test_claude_agent_sessions.py b/tests/test_claude_agent_sessions.pyindex f0216a0ca..dc783f394 100644--- a/tests/test_claude_agent_sessions.py+++ b/tests/test_claude_agent_sessions.py@@ -4505,6 +4505,22 @@ class AdoptPendingTurnTokenTests(unittest.TestCase):ClaudeAgent._adopt_pending_turn_token(ctx, pending)self.assertEqual(ctx.platform_specific["turn_token"], "T2")+ def test_close_after_follows_the_matched_turn(self):+ ctx = SimpleNamespace(platform_specific={"turn_token": "T1", "close_after": True})+ ordinary = SimpleNamespace(+ context=SimpleNamespace(platform_specific={"turn_token": "T2"})+ )+ ClaudeAgent._adopt_pending_turn_token(ctx, ordinary)+ self.assertNotIn("close_after", ctx.platform_specific)++ disposable = SimpleNamespace(+ context=SimpleNamespace(+ platform_specific={"turn_token": "T3", "close_after": True}+ )+ )+ ClaudeAgent._adopt_pending_turn_token(ctx, disposable)+ self.assertTrue(ctx.platform_specific["close_after"])+def test_noop_without_pending_request(self):ctx = SimpleNamespace(platform_specific={"turn_token": "T1"})ClaudeAgent._adopt_pending_turn_token(ctx, None)diff --git a/tests/test_claude_receiver_result_settle.py b/tests/test_claude_receiver_result_settle.pyindex 984679cb2..d8271efac 100644--- a/tests/test_claude_receiver_result_settle.py+++ b/tests/test_claude_receiver_result_settle.py@@ -1487,6 +1487,47 @@ class ResultSettlesTurnOnEmitFailureTests(unittest.IsolatedAsyncioTestCase):self.assertEqual(mark_idle_calls, [composite_key])self.assertFalse(agent._has_pending_requests(composite_key))+ async def test_close_after_cleanup_waits_for_result_reaction(self):+ mark_idle_calls: list[str] = []+ agent = _build_agent(mark_idle_calls)+ context = SimpleNamespace(+ user_id="U1",+ channel_id="C1",+ platform_specific={"close_after": True},+ )+ composite_key = "session-close-after:/tmp/work"+ agent._pending_requests[composite_key] = [SimpleNamespace(context=context)]+ reaction_started = asyncio.Event()+ finish_reaction = asyncio.Event()+ emitted_cleanup = None++ async def emit_result(*_args, **_kwargs):+ nonlocal emitted_cleanup+ emitted_cleanup = context.platform_specific["_close_after_backend_cleanup"]++ async def remove_reaction(*_args):+ reaction_started.set()+ await finish_reaction.wait()++ agent.emit_result_message = AsyncMock(side_effect=emit_result)+ agent._remove_result_pending_reaction = AsyncMock(side_effect=remove_reaction)+ receiver = asyncio.create_task(+ agent._receive_messages(+ _one_result_client(),+ "session-close-after",+ "/tmp/work",+ context,+ composite_key=composite_key,+ )+ )+ await asyncio.wait_for(reaction_started.wait(), timeout=1)+ self.assertIsNotNone(emitted_cleanup)+ self.assertFalse(emitted_cleanup.is_set())+ finish_reaction.set()+ await receiver+ self.assertTrue(emitted_cleanup.is_set())+ self.assertEqual(mark_idle_calls, [composite_key])+async def test_force_cleanup_suppresses_receiver_release_until_terminal_emit(self):mark_idle_calls: list[str] = []agent = _build_agent(mark_idle_calls)diff --git a/tests/test_cli_agent_run_schema.py b/tests/test_cli_agent_run_schema.pyindex c194fcccf..f507d0507 100644--- a/tests/test_cli_agent_run_schema.py+++ b/tests/test_cli_agent_run_schema.py@@ -61,6 +61,7 @@ _EXPECTED_KEYS = {"callback_session_id","caller_context","callback_notice",+ "close_after","async","run",}@@ -77,6 +78,7 @@ _EXPECTED_RUN_KEYS_QUEUED = {"source_kind","source_actor","parent_run_id",+ "close_after",}@@ -129,6 +131,50 @@ def test_agent_run_default_async_envelope_schema(tmp_path: Path, capsys) -> Noneassert run["source_kind"] == "cli"assert run["source_actor"] is Noneassert run["parent_run_id"] is None+ assert payload["close_after"] is False+ assert run["close_after"] is False+++def test_agent_run_close_after_is_persisted_for_new_session(+ tmp_path: Path,+ capsys,+) -> None:+ db_path = tmp_path / "state" / "vibe.sqlite"+ agent_store = cli.VibeAgentStore(db_path)+ agent_store.create(name="worker", backend="codex")+ request_store = cli.TaskExecutionStore(tmp_path / "task_requests")+ args = _parse_agent_run(+ ["--agent", "worker", "--close-after", "--no-callback", "--message", "hi"]+ )++ with (+ patch("vibe.cli._agent_store", return_value=agent_store),+ patch("vibe.cli._task_request_store", return_value=request_store),+ patch("vibe.cli.paths.get_sqlite_state_path", return_value=db_path),+ patch("vibe.cli._primary_platform", return_value="slack"),+ ):+ result = cli.cmd_agent_run(args)++ assert result == 0+ payload = json.loads(capsys.readouterr().out)+ assert payload["close_after"] is True+ assert payload["run"]["close_after"] is True+ stored = request_store.get_run(payload["run_id"])+ assert stored is not None+ assert stored["metadata"]["close_after"] is True+++def test_agent_run_close_after_rejects_existing_session() -> None:+ args = _parse_agent_run(+ ["--agent", "worker", "--session-id", "ses_existing", "--close-after", "--message", "hi"]+ )++ with pytest.raises(cli.TaskCliError) as exc_info:+ cli._validate_run_session_policy(args, help_command="vibe agent run --help")++ # The flag is validated after the target is resolved in cmd_agent_run; the+ # parser still exposes it as a normal boolean for callers that inspect args.+ assert args.close_after is Truedef test_agent_run_releases_reserved_session_when_guarded_enqueue_loses(diff --git a/tests/test_codex_agent.py b/tests/test_codex_agent.pyindex c5e17e846..a84383377 100644--- a/tests/test_codex_agent.py+++ b/tests/test_codex_agent.py@@ -15,6 +15,7 @@ from unittest.mock import ANY, AsyncMock, Mock, call, patchsys.path.insert(0, str(Path(__file__).resolve().parents[1]))from core.processing_indicator import STOPPED_REACTION_EMOJI+from core.resource_governance import AgentResourceFailurefrom core.runtime_activation import RuntimeActivationRegistryfrom core.runtime_ownership import RuntimeTargetOwnershipSnapshot, SessionRuntimeDispositionfrom modules.agents.base import BaseAgent as RealBaseAgent@@ -188,6 +189,61 @@ for name, module in _saved_modules.items():sys.modules[name] = module+class CodexExitPressureCacheTests(unittest.TestCase):+ def _agent_with_transport(self, transport):+ agent = object.__new__(CodexAgent)+ agent.controller = SimpleNamespace(config=SimpleNamespace(language="en"))+ agent._session_mgr = SimpleNamespace(get_cwd=lambda _base: "/work")+ agent._transports = {"/work": transport}+ return agent++ def test_concurrent_sessions_share_positive_exit_observation(self):+ transport = SimpleNamespace(_process=SimpleNamespace(returncode=137))+ agent = self._agent_with_transport(transport)+ failure = AgentResourceFailure(+ kind="pids", message="shared PID event", pids_current=10, pids_max=32+ )+ first = agent.capture_backend_exit_failure(+ SimpleNamespace(platform_specific={"turn_base_session_id": "one"})+ )+ second = agent.capture_backend_exit_failure(+ SimpleNamespace(platform_specific={"turn_base_session_id": "two"})+ )++ with patch.object(+ _MODULE, "observe_agent_resource_pressure", return_value=failure+ ) as observe:+ assert first() == second()+ observe.assert_called_once()++ def test_negative_exit_observation_is_cached_only_for_that_transport(self):+ old_transport = SimpleNamespace(_process=SimpleNamespace(returncode=137))+ agent = self._agent_with_transport(old_transport)+ first = agent.capture_backend_exit_failure(+ SimpleNamespace(platform_specific={"turn_base_session_id": "one"})+ )+ second = agent.capture_backend_exit_failure(+ SimpleNamespace(platform_specific={"turn_base_session_id": "two"})+ )+ newer_failure = AgentResourceFailure(kind="memory", message="new event")++ with patch.object(+ _MODULE,+ "observe_agent_resource_pressure",+ side_effect=[None, newer_failure],+ ) as observe:+ assert first() is None+ assert second() is None+ agent._transports["/work"] = SimpleNamespace(+ _process=SimpleNamespace(returncode=137)+ )+ third = agent.capture_backend_exit_failure(+ SimpleNamespace(platform_specific={"turn_base_session_id": "three"})+ )+ assert "new event" in third()[0]+ assert observe.call_count == 2++class _StubSessionManager:def __init__(self):self._threads = {}@@ -1601,7 +1657,11 @@ class CodexAgentHandleMessageTests(unittest.IsolatedAsyncioTestCase):)set_dispatch_phase(request.context, DISPATCH_PHASE_PREWRITE)- bad_transport = SimpleNamespace(stop=AsyncMock(), is_alive=False)+ bad_transport = SimpleNamespace(+ stop=AsyncMock(),+ is_alive=False,+ _process=SimpleNamespace(returncode=137),+ )fresh_transport = SimpleNamespace()invalidated = []session_mgr = SimpleNamespace(@@ -1642,7 +1702,9 @@ class CodexAgentHandleMessageTests(unittest.IsolatedAsyncioTestCase):agent._start_thread = AsyncMock(return_value="thread-new")agent._start_turn = AsyncMock(return_value="thread-new")- await agent.handle_message(request)+ with patch.object(_MODULE, "observe_agent_resource_pressure") as observe_pressure:+ await agent.handle_message(request)+ observe_pressure.assert_not_called()bad_transport.stop.assert_awaited_once()self.assertEqual(agent._transports, {})diff --git a/tests/test_controller_dispatch_loop.py b/tests/test_controller_dispatch_loop.pyindex fa9253c2e..76ce75823 100644--- a/tests/test_controller_dispatch_loop.py+++ b/tests/test_controller_dispatch_loop.py@@ -426,6 +426,9 @@ async def test_runtime_work_stack_drains_run_activity_before_executor_stop() ->async def drain_agent_run_activity(self) -> None:stopped.append("activity")+ async def drain_close_after_runtime(self) -> None:+ stopped.append("close-after")+class _Service:def __init__(self, name: str) -> None:self.name = name@@ -450,7 +453,75 @@ async def test_runtime_work_stack_drains_run_activity_before_executor_stop() ->assert stopped[0:2] == ["quiesce", "activity"]assert set(stopped[2:5]) == {"model-hub", "tasks", "watch"}- assert stopped[5] == "supervisor"+ assert stopped[5:7] == ["close-after", "supervisor"]+++async def test_runtime_work_stack_waits_for_close_after_before_loop_shutdown() -> None:+ controller = Controller.__new__(Controller)+ controller._shutdown_tainted = False+ controller._runtime_work_tokens = []+ entered = asyncio.Event()+ release = asyncio.Event()+ stopped: list[str] = []++ class _Dispatcher:+ async def drain_close_after_runtime(self) -> None:+ entered.set()+ await release.wait()+ stopped.append("close-after")++ class _Service:+ async def stop(self) -> None:+ stopped.append("service")++ class _Supervisor:+ def quiesce(self) -> None:+ stopped.append("quiesce")++ async def stop(self) -> None:+ stopped.append("supervisor")++ controller.message_dispatcher = _Dispatcher()+ controller.scheduled_task_service = _Service()+ controller.runtime_work_supervisor = _Supervisor()+ shutdown = asyncio.create_task(controller._stop_runtime_work_stack())+ await asyncio.wait_for(entered.wait(), timeout=1)+ assert not shutdown.done()+ assert stopped == ["quiesce", "service"]+ release.set()+ await shutdown+ assert stopped[-2:] == ["close-after", "supervisor"]+++async def test_runtime_work_stack_does_not_drain_after_task_service_failure() -> None:+ controller = Controller.__new__(Controller)+ controller._shutdown_tainted = False+ controller._runtime_work_tokens = []+ drain = AsyncMock()+ stopped: list[str] = []++ class _Service:+ async def stop(self) -> None:+ raise RuntimeError("Run settlement failed")++ class _Supervisor:+ def quiesce(self) -> None:+ stopped.append("quiesce")++ async def stop(self) -> None:+ stopped.append("supervisor")++ controller.message_dispatcher = SimpleNamespace(drain_close_after_runtime=drain)+ controller.scheduled_task_service = _Service()+ controller.runtime_work_supervisor = _Supervisor()++ with pytest.raises(RuntimeError, match="runtime work stack shutdown failed") as exc:+ await controller._stop_runtime_work_stack()+ assert str(exc.value.__cause__) == "Run settlement failed"+ drain.assert_not_awaited()+ assert stopped == ["quiesce", "supervisor"]def test_request_shutdown_keeps_loop_owned_supervisor_join_alive_after_grace() -> None:diff --git a/tests/test_message_dispatcher_result_fallback.py b/tests/test_message_dispatcher_result_fallback.pyindex 0e388c61d..32296e48e 100644--- a/tests/test_message_dispatcher_result_fallback.py+++ b/tests/test_message_dispatcher_result_fallback.py@@ -617,20 +617,33 @@ class MessageDispatcherResultFallbackTests(unittest.IsolatedAsyncioTestCase):controller.mark_turn_complete = mock.Mock()return controller- async def _emit_silent_terminal(self, controller, *, completes_run: bool, output=None):+ async def _emit_silent_terminal(+ self, controller, *, completes_run: bool, output=None, close_after: bool = False+ ):dispatcher = ConsolidatedMessageDispatcher(controller)dispatcher._collapse_status_bubble = mock.AsyncMock()dispatcher._clear_consolidated_state = mock.AsyncMock()dispatcher._record_agent_run_terminal_result = mock.Mock()+ platform_specific = {+ "agent_runtime_turn_key": "runtime-1",+ "agent_runtime_turn_token": "runtime-turn-1",+ "turn_token": "turn-1",+ }+ if close_after:+ platform_specific.update({+ "close_after": True,+ "agent_session_id": "session-1",+ "agent_backend": "claude",+ "agent_session_target": {+ "agent_backend": "claude",+ "session_anchor": "base-session-1",+ },+ })context = MessageContext(user_id="U1",channel_id="C1",platform="slack",- platform_specific={- "agent_runtime_turn_key": "runtime-1",- "agent_runtime_turn_token": "runtime-turn-1",- "turn_token": "turn-1",- },+ platform_specific=platform_specific,)await dispatcher.emit_agent_message(context,@@ -653,7 +666,15 @@ class MessageDispatcherResultFallbackTests(unittest.IsolatedAsyncioTestCase):"""controller = self._terminal_lifecycle_controller()- dispatcher, context = await self._emit_silent_terminal(controller, completes_run=False)+ with mock.patch(+ "core.services.running_agents.end_running_agent",+ new_callable=mock.AsyncMock,+ ) as end_running_agent:+ dispatcher, context = await self._emit_silent_terminal(+ controller, completes_run=False, close_after=True+ )+ await asyncio.sleep(0.01)+ end_running_agent.assert_not_awaited()controller.mark_turn_complete.assert_called_once_with(context,@@ -705,18 +726,29 @@ class MessageDispatcherResultFallbackTests(unittest.IsolatedAsyncioTestCase):which no lane may settle, and the row would be left ``running``."""controller = self._terminal_lifecycle_controller()+ controller.agent_service.reserve_idle_close_after_teardown = mock.AsyncMock(+ return_value=("runtime-1", "close-after:test", None)+ )+ controller.agent_service.release_runtime_turn_key = mock.Mock()- with mock.patch("core.message_dispatcher.persist_silent_terminal") as persist:+ with mock.patch("core.message_dispatcher.persist_silent_terminal") as persist, mock.patch(+ "core.services.running_agents.end_running_agent",+ new_callable=mock.AsyncMock,+ return_value={"ok": True},+ ) as end_running_agent:dispatcher, context = await self._emit_silent_terminal(controller,completes_run=False,output=stop_output_for(None),+ close_after=True,)+ await asyncio.sleep(0.01)controller.mark_turn_complete.assert_called_once_with(context,settled_by=SETTLED_BY_STOPPED,)+ end_running_agent.assert_awaited_once()# A settlement the lanes MAY act on — unlike ``turn_only_result``.self.assertIn(SETTLED_BY_STOPPED, SETTLEMENTS_WITHOUT_RESULT)self.assertEqual(SETTLEMENT_TERMINAL_STATUS[SETTLED_BY_STOPPED], "canceled")diff --git a/tests/test_multi_platform_runtime.py b/tests/test_multi_platform_runtime.pyindex 3d41735e3..9c6ff9f44 100644--- a/tests/test_multi_platform_runtime.py+++ b/tests/test_multi_platform_runtime.py@@ -22,6 +22,7 @@ from core.native_dispatch_phase import (set_dispatch_phase,)from core.processing_indicator import ProcessingIndicatorService+from core.resource_governance import AgentResourceFailurefrom modules.agents.base import AgentRequestfrom modules.agents.model_hub import OpenCodeOverlay, launch_for_contextfrom modules.agents.service import AgentService@@ -95,6 +96,26 @@ def test_opencode_model_hub_overlay_failure_is_localized() -> None:assert "internal diagnostic" not in display+def test_opencode_resource_failure_preserves_zero_pid_count() -> None:+ agent = OpenCodeAgent.__new__(OpenCodeAgent)+ agent.controller = type(+ "Controller",+ (),+ {"config": type("Config", (), {"language": "en"})()},+ )()+ failure = AgentResourceFailure(+ kind="pids",+ message="shared cgroup limit event",+ pids_current=0,+ pids_max=4096,+ )++ suffix = agent._resource_failure_suffix(failure)++ assert "(0/4096)" in suffix+ assert "unknown" not in suffix++def test_opencode_hub_turn_with_empty_menu_uses_overlay_and_keeps_server_running(monkeypatch,) -> None:diff --git a/tests/test_native_takeover_lifecycle.py b/tests/test_native_takeover_lifecycle.pyindex 835117af4..d1c72f0ba 100644--- a/tests/test_native_takeover_lifecycle.py+++ b/tests/test_native_takeover_lifecycle.py@@ -637,6 +637,7 @@ async def test_opencode_unproven_pid_file_is_blocker_not_kill_target():server._has_active_run_sessions = Mock(return_value=False)server._runtime_activation_retire = Mock(return_value=True)server._process = None+ server.port = 4096server._read_pid_file = Mock(return_value={"pid": 123})server._pid_exists = Mock(return_value=True)server._terminate_pid_tree_sync = Mock(side_effect=AssertionError("must not kill"))diff --git a/tests/test_opencode_server.py b/tests/test_opencode_server.pyindex 113b6cdd4..0ac310906 100644--- a/tests/test_opencode_server.py+++ b/tests/test_opencode_server.py@@ -222,6 +222,7 @@ class OpenCodeServerTests(unittest.IsolatedAsyncioTestCase):self.assertEqual(create_process.await_args.kwargs["env"]["AVIBE_OPENCODE_MODEL_HUB"], "0")self.assertIsNone(manager._process)self.assertIsNone(manager._process_loop)+ self.assertIsNone(manager._last_start_failure_pid)self.assertEqual(json.loads(create_process.await_args.kwargs["env"]["OPENCODE_CONFIG_CONTENT"]),{@@ -945,6 +946,18 @@ class OpenCodeServerTests(unittest.IsolatedAsyncioTestCase):payload = json.loads(manager._pid_file.read_text(encoding="utf-8"))self.assertEqual(payload["active_run_sessions"], [])+ def test_pid_file_records_birth_only_when_supplied_by_spawn(self):+ manager = OpenCodeServerManager(binary="opencode", port=4096)+ with tempfile.TemporaryDirectory() as tmp_dir:+ manager._pid_file = Path(tmp_dir) / "opencode_server.json"+ manager._write_pid_file(123)+ legacy = json.loads(manager._pid_file.read_text(encoding="utf-8"))+ self.assertNotIn("process_created_at", legacy)++ manager._write_pid_file(123, process_created_at=1000.0)+ spawned = json.loads(manager._pid_file.read_text(encoding="utf-8"))+ self.assertEqual(spawned["process_created_at"], 1000.0)+async def test_mark_run_inactive_preserves_active_state_when_pid_write_fails(self):manager = OpenCodeServerManager(binary="opencode", port=4096)with tempfile.TemporaryDirectory() as tmp_dir:@@ -2333,6 +2346,107 @@ class OpenCodeServerTests(unittest.IsolatedAsyncioTestCase):manager._terminate_pid_tree_sync.assert_called_once_with(654)+ async def test_retire_adopted_server_requires_command_or_port_proof(self):+ manager = OpenCodeServerManager(binary="opencode", port=4096)+ manager._read_pid_file = Mock(return_value={"pid": 654, "port": 4096, "process_created_at": 1000.0}) # type: ignore[method-assign]+ manager._pid_exists = Mock(side_effect=[True, True, False]) # type: ignore[method-assign]+ manager._get_pid_command = Mock(return_value="opencode serve --port=4096") # type: ignore[method-assign]+ manager._terminate_pid_tree_sync = Mock(return_value=True) # type: ignore[method-assign]+ manager._clear_pid_file = Mock() # type: ignore[method-assign]++ with patch.object(SERVER_MODULE.runtime, "process_create_time", return_value=1000.0):+ await manager.retire_for_native_migration()++ manager._terminate_pid_tree_sync.assert_called_once_with(654)+ manager._clear_pid_file.assert_called_once()+ self.assertIsNone(manager._base_url)++ async def test_retire_adopted_server_refuses_reused_pid(self):+ manager = OpenCodeServerManager(binary="opencode", port=4096)+ manager._read_pid_file = Mock(return_value={"pid": 654, "port": 4096}) # type: ignore[method-assign]+ manager._pid_exists = Mock(return_value=True) # type: ignore[method-assign]+ manager._get_pid_command = Mock(return_value="python unrelated.py") # type: ignore[method-assign]+ manager._pid_owns_listening_port = Mock(return_value=False) # type: ignore[method-assign]+ manager._terminate_pid_tree_sync = Mock(return_value=True) # type: ignore[method-assign]+ manager._clear_pid_file = Mock() # type: ignore[method-assign]++ with self.assertRaisesRegex(RuntimeError, "ownership cannot be proven"):+ await manager.retire_for_native_migration()++ manager._terminate_pid_tree_sync.assert_not_called()+ manager._clear_pid_file.assert_not_called()++ async def test_retire_adopted_server_uses_port_owner_when_command_unavailable(self):+ manager = OpenCodeServerManager(binary="opencode", port=4096)+ manager._read_pid_file = Mock(return_value={"pid": 654, "port": 4096, "process_created_at": 1000.0}) # type: ignore[method-assign]+ manager._pid_exists = Mock(side_effect=[True, True, False]) # type: ignore[method-assign]+ manager._get_pid_command = Mock(return_value=None) # type: ignore[method-assign]+ manager._pid_owns_listening_port = Mock(return_value=True) # type: ignore[method-assign]+ manager._terminate_pid_tree_sync = Mock(return_value=True) # type: ignore[method-assign]+ manager._clear_pid_file = Mock() # type: ignore[method-assign]++ with patch.object(SERVER_MODULE.runtime, "process_create_time", return_value=1000.0):+ await manager.retire_for_native_migration()++ self.assertEqual(manager._pid_owns_listening_port.call_count, 2)+ manager._pid_owns_listening_port.assert_called_with(654, 4096)+ manager._terminate_pid_tree_sync.assert_called_once_with(654)++ async def test_retire_adopted_server_refuses_reused_pid_even_when_command_matches(self):+ manager = OpenCodeServerManager(binary="opencode", port=4096)+ manager._read_pid_file = Mock(return_value={+ "pid": 654, "port": 4096, "process_created_at": 1000.0+ }) # type: ignore[method-assign]+ manager._pid_exists = Mock(return_value=True) # type: ignore[method-assign]+ manager._get_pid_command = Mock(return_value="opencode serve --port=4096") # type: ignore[method-assign]+ manager._terminate_pid_tree_sync = Mock() # type: ignore[method-assign]+ retire = Mock(return_value=True)+ manager.set_runtime_activation_retire(retire)++ with patch.object(SERVER_MODULE.runtime, "process_create_time", return_value=2000.0):+ with self.assertRaisesRegex(RuntimeError, "ownership cannot be proven"):+ await manager.retire_for_native_migration()++ manager._terminate_pid_tree_sync.assert_not_called()+ retire.assert_not_called()++ async def test_retire_adopted_server_refuses_legacy_pid_file_without_birth_identity(self):+ manager = OpenCodeServerManager(binary="opencode", port=4096)+ manager._read_pid_file = Mock(return_value={"pid": 654, "port": 4096}) # type: ignore[method-assign]+ manager._pid_exists = Mock(return_value=True) # type: ignore[method-assign]+ manager._get_pid_command = Mock(return_value="opencode serve --port=4096") # type: ignore[method-assign]+ manager._terminate_pid_tree_sync = Mock() # type: ignore[method-assign]++ with self.assertRaisesRegex(RuntimeError, "ownership cannot be proven"):+ await manager.retire_for_native_migration()++ manager._terminate_pid_tree_sync.assert_not_called()++ async def test_retire_adopted_server_refuses_identity_change_before_signal(self):+ manager = OpenCodeServerManager(binary="opencode", port=4096)+ manager._read_pid_file = Mock(return_value={+ "pid": 654, "port": 4096, "process_created_at": 1000.0+ }) # type: ignore[method-assign]+ manager._pid_exists = Mock(side_effect=[True, True]) # type: ignore[method-assign]+ manager._get_pid_command = Mock(return_value="opencode serve --port=4096") # type: ignore[method-assign]+ manager._terminate_pid_tree_sync = Mock() # type: ignore[method-assign]++ with patch.object(SERVER_MODULE.runtime, "process_create_time", side_effect=[1000.0, 2000.0]):+ with self.assertRaisesRegex(RuntimeError, "ownership cannot be proven"):+ await manager.retire_for_native_migration()++ manager._terminate_pid_tree_sync.assert_not_called()++ def test_observed_adopted_server_reports_only_the_original_generation_exit(self):+ manager = OpenCodeServerManager(binary="opencode", port=4096)+ info = {"pid": 654, "port": 4096, "started_at": 1.0}+ manager._pid_exists = Mock(return_value=True) # type: ignore[method-assign]++ with patch.object(SERVER_MODULE.runtime, "process_create_time", side_effect=[1000.0, 1000.0, 2000.0]):+ manager._observe_runtime_generation(info)+ self.assertIsNone(manager.observed_runtime_exit_pid())+ self.assertEqual(manager.observed_runtime_exit_pid(), 654)+async def test_request_scope_does_not_restart_pending_auth_refresh_while_run_active(self):manager = OpenCodeServerManager(binary="opencode", port=4096)manager._auth_refresh_pending = Truediff --git a/tests/test_resource_governance.py b/tests/test_resource_governance.pyindex 30881df6e..47a769dbc 100644--- a/tests/test_resource_governance.py+++ b/tests/test_resource_governance.py@@ -7,13 +7,16 @@ from config import pathsfrom config.v2_config import AgentsConfig, RuntimeConfig, SlackConfig, V2Configfrom core.resource_governance import (MIB,+ AgentResourceFailure,AgentResourceGovernor,_is_known_avibe_runtime_member,config_from_controller,derive_agent_limits,is_controller_resource_governor,governor_from_controller,+ pids_failure_labels,tenant_memory_limit_bytes,+ tenant_pid_limit,)@@ -24,7 +27,208 @@ def test_derive_agent_limits_uses_single_aggregate_budget() -> None:assert limits.memory_high == 2367 * MIBassert limits.cpu_weight == 50assert limits.io_weight == 50- assert limits.pids_max == 512+ assert limits.pids_max == 4096+++def test_agent_pid_limit_reserves_runtime_capacity_below_ancestor_cap() -> None:+ assert derive_agent_limits(None, tenant_pids_max=4096).pids_max == 3072+ assert derive_agent_limits(+ None, {"agent_pids_max": 8192}, tenant_pids_max=1024+ ).pids_max == 768+ assert derive_agent_limits(+ None, {"agent_pids_max": 256}, tenant_pids_max=4096+ ).pids_max == 256+++def test_tenant_pid_limit_uses_tightest_ancestor(tmp_path: Path) -> None:+ root = tmp_path / "cgroup"+ base = root / "service"+ base.mkdir(parents=True)+ (root / "pids.max").write_text("2048\n", encoding="utf-8")+ (base / "pids.max").write_text("4096\n", encoding="utf-8")++ assert tenant_pid_limit(base, root) == 2048+++def test_governor_diagnoses_pid_limit_from_counter_delta(+ tmp_path: Path,+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ root = tmp_path / "cgroup"+ base = root / "service"+ group = base / "avibe-agents"+ base.mkdir(parents=True)+ group.mkdir()+ for name, value in (+ ("cgroup.procs", ""),+ ("pids.current", "100"),+ ("pids.max", "4096"),+ ("pids.events", "max 4\n"),+ ("memory.events", "max 0\noom 0\noom_kill 0\n"),+ ):+ (group / name).write_text(value, encoding="utf-8")++ governor = AgentResourceGovernor({"mode": "enabled"}, root=root, base_cgroup=base)+ monkeypatch.setattr(governor, "_group", group)+ governor._event_baseline = governor.snapshot()+ (group / "pids.events").write_text("max 5\n", encoding="utf-8")++ failure = governor.observe_resource_pressure()++ assert failure is not None+ assert failure.kind == "pids"+ assert failure.pids_current == 100+ assert failure.pids_max == 4096+ assert failure.event_delta == 1+ assert "events.max_delta=1" in failure.message+ assert "shared Agent cgroup" in failure.message+ assert governor.observe_resource_pressure() is None+ (group / "pids.current").write_text("0\n", encoding="utf-8")+ (group / "pids.events").write_text("max 6\n", encoding="utf-8")+ zero_failure = governor.observe_resource_pressure()+ assert zero_failure is not None+ assert zero_failure.pids_current == 0+ assert "current=0" in zero_failure.message+++def test_pid_limit_fallback_labels_are_localized() -> None:+ failure = AgentResourceFailure(kind="pids", message="pressure")++ assert pids_failure_labels(failure, "zh") == {+ "current": "未知",+ "limit": "未知或不限",+ }+ assert pids_failure_labels(failure, "en") == {+ "current": "unknown",+ "limit": "unknown or unlimited",+ }+++def test_unchanged_governance_config_keeps_pressure_baseline_across_reload(+ tmp_path: Path,+) -> None:+ group = tmp_path / "avibe-agents"+ group.mkdir()+ for name, value in (+ ("pids.current", "1"),+ ("pids.max", "4096"),+ ("pids.events", "max 4\n"),+ ("memory.events", "max 0\noom 0\noom_kill 0\n"),+ ):+ (group / name).write_text(value, encoding="utf-8")+ governor = AgentResourceGovernor({"mode": "enabled"})+ governor._group = group+ baseline = governor.snapshot()+ governor._event_baseline = baseline++ governor.update_config({"mode": "enabled"})+ (group / "pids.events").write_text("max 5\n", encoding="utf-8")++ assert governor.group_path == group+ assert governor._event_baseline is baseline+ assert governor.observe_resource_pressure().event_delta == 1+++def test_changed_limits_reconfigure_same_group_without_losing_pressure(+ tmp_path: Path,+) -> None:+ root = tmp_path / "cgroup"+ base = root / "service"+ group = base / "avibe-agents"+ group.mkdir(parents=True)+ (base / "memory.max").write_text(str(2 * 1024 * MIB), encoding="utf-8")+ (base / "pids.max").write_text("4096\n", encoding="utf-8")+ for name, value in (+ ("cgroup.procs", ""),+ ("cpu.weight", "50"),+ ("memory.high", "max"),+ ("memory.max", "max"),+ ("pids.current", "1"),+ ("pids.max", "4096"),+ ("pids.events", "max 4\n"),+ ("memory.events", "max 0\noom 0\noom_kill 0\n"),+ ):+ (group / name).write_text(value, encoding="utf-8")+ governor = AgentResourceGovernor(+ {"mode": "enabled", "agent_cpu_weight": 50},+ root=root,+ base_cgroup=base,+ )+ governor._base = base+ governor._group = group+ baseline = governor.snapshot()+ governor._event_baseline = baseline++ governor.update_config(+ {"mode": "enabled", "agent_cpu_weight": 100, "agent_pids_max": 8192}+ )+ (group / "pids.events").write_text("max 5\n", encoding="utf-8")++ assert governor.group_path == group+ assert governor._event_baseline is baseline+ assert (group / "cpu.weight").read_text(encoding="utf-8").strip() == "100"+ assert (group / "pids.max").read_text(encoding="utf-8").strip() == "3072"+ assert governor.observe_resource_pressure().event_delta == 1+++def test_governor_diagnoses_memory_limit_from_counter_delta(+ tmp_path: Path,+) -> None:+ root = tmp_path / "cgroup"+ base = root / "service"+ group = base / "avibe-agents"+ base.mkdir(parents=True)+ group.mkdir()+ for name, value in (+ ("cgroup.procs", ""),+ ("pids.current", "100"),+ ("pids.max", "4096"),+ ("pids.events", "max 0\n"),+ ("memory.events", "max 1\noom 0\noom_kill 0\n"),+ ):+ (group / name).write_text(value, encoding="utf-8")++ governor = AgentResourceGovernor({"mode": "enabled"}, root=root, base_cgroup=base)+ governor._group = group+ governor._event_baseline = governor.snapshot()+ (group / "memory.events").write_text("max 2\noom 0\noom_kill 0\n", encoding="utf-8")++ failure = governor.observe_resource_pressure()++ assert failure is not None+ assert failure.kind == "memory"+ assert "event=max" in failure.message+ assert governor.observe_resource_pressure() is None+++def test_simultaneous_pid_and_memory_events_remain_separately_observable(+ tmp_path: Path,+) -> None:+ group = tmp_path / "avibe-agents"+ group.mkdir()+ for name, value in (+ ("pids.current", "100"),+ ("pids.max", "4096"),+ ("pids.events", "max 4\n"),+ ("memory.events", "max 1\noom 0\noom_kill 0\n"),+ ):+ (group / name).write_text(value, encoding="utf-8")+ governor = AgentResourceGovernor({"mode": "enabled"})+ governor._group = group+ governor._event_baseline = governor.snapshot()++ (group / "pids.events").write_text("max 5\n", encoding="utf-8")+ (group / "memory.events").write_text(+ "max 2\noom 1\noom_kill 1\n", encoding="utf-8"+ )++ pid_failure = governor.observe_resource_pressure()+ memory_failure = governor.observe_resource_pressure()++ assert pid_failure is not None and pid_failure.kind == "pids"+ assert memory_failure is not None and memory_failure.kind == "memory"+ assert "event=oom_kill" in memory_failure.message+ assert governor.observe_resource_pressure() is Nonedef test_derive_agent_limits_honors_explicit_bytes() -> None:@@ -238,7 +442,8 @@ def test_governor_update_config_resets_cached_group(tmp_path: Path, monkeypatch:governor.update_config({"mode": "disabled"})- assert governor.group_path is None+ # Existing members remain observable, but new processes are not adopted.+ assert governor.group_path == groupassert governor.apply_to_pid(4322, label="test") is False@@ -248,6 +453,7 @@ def test_governor_configures_group_and_moves_pid(tmp_path: Path, monkeypatch: pybase.mkdir(parents=True)(root / "memory.max").write_text("max\n", encoding="utf-8")(base / "memory.max").write_text(str(2 * 1024 * MIB), encoding="utf-8")+ (base / "pids.max").write_text("4096\n", encoding="utf-8")(base / "cgroup.controllers").write_text("memory cpu io pids\n", encoding="utf-8")(base / "cgroup.subtree_control").write_text("", encoding="utf-8")(base / "cgroup.procs").write_text("1001\n1002\n", encoding="utf-8")@@ -268,9 +474,11 @@ def test_governor_configures_group_and_moves_pid(tmp_path: Path, monkeypatch: py"cpu.weight","io.weight","pids.max",+ "pids.events","cgroup.procs",):(group / name).write_text("", encoding="utf-8")+ (group / "pids.events").write_text("max 0\n", encoding="utf-8")if path == runtime_group:(runtime_group / "cgroup.procs").write_text("", encoding="utf-8")return result@@ -284,6 +492,8 @@ def test_governor_configures_group_and_moves_pid(tmp_path: Path, monkeypatch: pyremaining = "1002\n" if value == "1001" else ""(base / "cgroup.procs").write_text(remaining, encoding="utf-8")return+ if path == group / "cgroup.procs":+ (group / "pids.events").write_text("max 1\n", encoding="utf-8")path.write_text(f"{value}\n", encoding="utf-8")monkeypatch.setattr("core.resource_governance._write_cgroup_value", fake_write_cgroup_value)@@ -299,7 +509,32 @@ def test_governor_configures_group_and_moves_pid(tmp_path: Path, monkeypatch: pyassert (group / "memory.oom.group").read_text(encoding="utf-8").strip() == "1"assert (group / "cpu.weight").read_text(encoding="utf-8").strip() == "50"assert (group / "io.weight").read_text(encoding="utf-8").strip() == "default 50"- assert (group / "pids.max").read_text(encoding="utf-8").strip() == "512"+ assert (group / "pids.max").read_text(encoding="utf-8").strip() == "3072"+ assert governor.observe_resource_pressure().kind == "pids"+++def test_existing_agent_group_baseline_precedes_migrated_pid(+ tmp_path: Path, monkeypatch: pytest.MonkeyPatch+) -> None:+ root = tmp_path / "cgroup"+ base = root / "service"+ group = base / "avibe-agents"+ group.mkdir(parents=True)+ (base / "memory.max").write_text(str(512 * MIB), encoding="utf-8")+ (group / "cgroup.procs").write_text("", encoding="utf-8")+ (group / "pids.events").write_text("max 4\n", encoding="utf-8")+ (group / "memory.high").write_text("max\n", encoding="utf-8")+ (group / "memory.max").write_text("max\n", encoding="utf-8")+ governor = AgentResourceGovernor({"mode": "enabled"}, root=root, base_cgroup=base)++ def migrate(*_args, **_kwargs):+ (group / "pids.events").write_text("max 5\n", encoding="utf-8")++ monkeypatch.setattr(governor, "_prepare_base_cgroup", migrate)+ monkeypatch.setattr(governor, "_enable_subtree_controllers", lambda _base: None)++ assert governor._ensure_group(known_agent_pids={4321}) == group+ assert governor.observe_resource_pressure().event_delta == 1def test_governor_falls_back_when_memory_controller_is_missing(@@ -453,6 +688,7 @@ def test_governor_allows_known_agent_pids_during_base_migration(if path == group:for name in ("cpu.weight", "io.weight", "pids.max", "cgroup.procs"):(group / name).write_text("", encoding="utf-8")+ (group / "pids.events").write_text("max 0\n", encoding="utf-8")if path == runtime_group:(runtime_group / "cgroup.procs").write_text("", encoding="utf-8")return result@@ -462,6 +698,7 @@ def test_governor_allows_known_agent_pids_during_base_migration(runtime_writes.append(value)elif path == group / "cgroup.procs":agent_writes.append(value)+ (group / "pids.events").write_text("max 1\n", encoding="utf-8")else:path.write_text(f"{value}\n", encoding="utf-8")return@@ -481,6 +718,7 @@ def test_governor_allows_known_agent_pids_during_base_migration(assert runtime_writes == ["1001"]assert agent_writes == ["5001", "5002", "5001", "5002"]assert governor.group_path == group+ assert governor.observe_resource_pressure().kind == "pids"def test_governor_falls_back_when_subtree_control_enable_fails(diff --git a/tests/test_running_agents_service.py b/tests/test_running_agents_service.pyindex 94f36305c..7495ba6e7 100644--- a/tests/test_running_agents_service.py+++ b/tests/test_running_agents_service.py@@ -799,6 +799,8 @@ def test_end_claude_session_not_live():def test_end_codex_interrupts_clears_and_stops_last_transport():+ from modules.agents.codex.agent import CodexAgent+send = _AsyncFlag()stop = _AsyncFlag()transport = types.SimpleNamespace(send_request=send, stop=stop)@@ -814,8 +816,28 @@ def test_end_codex_interrupts_clears_and_stops_last_transport():get_active_turn=lambda b: "turn1",clear_session=lambda b: cleared.__setitem__("clr", b),)+ async def retire(cwd, *, ending_session_id=None):+ assert cwd == "/w"+ assert ending_session_id == "b1"+ await transport.stop()+ transports.pop(cwd)+ return True+codex = types.SimpleNamespace(- _session_mgr=mgr, _turn_registry=treg, _transports=transports, _transport_last_activity={"/w": 0.0}+ _session_mgr=mgr,+ _turn_registry=treg,+ _transports=transports,+ _transport_last_activity={"/w": 0.0},+ _session_locks={"b1": asyncio.Lock()},+ _session_last_activity={"b1": 1.0},+ _thread_developer_instructions={"b1": ("th1", "instructions")},+ _thread_prompt_strategies={"b1": ("th1", "fallback")},+ _thread_unpersisted_prompts={"b1": ("th1", "instructions", "fallback")},+ _thread_model_settings={"b1": ("th1", "model", None)},+ _thread_caller_env_configs={"b1": ("th1", {})},+ _thread_git_path_configs={"b1": ("th1", "", False)},+ _clear_thread_developer_instructions=lambda bid: CodexAgent._clear_thread_developer_instructions(codex, bid),+ retire_unowned_session_transport=retire,)res = asyncio.run(running_agents.end_running_agent(_make_controller(codex=codex), backend="codex", base_session_id="b1")@@ -825,6 +847,14 @@ def test_end_codex_interrupts_clears_and_stops_last_transport():assert cleared.get("inv") == "b1" and cleared.get("clr") == "b1"# Last session on the cwd → the shared app-server transport is stopped + dropped.assert stop.called and res["process_killed"] is True and "/w" not in transports+ assert codex._session_locks == {}+ assert codex._session_last_activity == {}+ assert codex._thread_developer_instructions == {}+ assert codex._thread_prompt_strategies == {}+ assert codex._thread_unpersisted_prompts == {}+ assert codex._thread_model_settings == {}+ assert codex._thread_caller_env_configs == {}+ assert codex._thread_git_path_configs == {}def test_end_codex_keeps_transport_when_other_sessions_share_cwd():@@ -846,6 +876,167 @@ def test_end_codex_keeps_transport_when_other_sessions_share_cwd():assert res["process_killed"] is False and "/w" in transports+def test_end_codex_reports_transport_retirement_failure():+ async def retire(_cwd, *, ending_session_id=None):+ assert ending_session_id == "b1"+ raise RuntimeError("transport still alive")++ cleared = []+ mgr = types.SimpleNamespace(+ get_cwd=lambda _base: "/w",+ get_thread_id=lambda _base: None,+ clear=cleared.append,+ sessions_for_cwd=lambda _cwd: ["b1"],+ )+ treg = types.SimpleNamespace(+ get_active_turn=lambda _base: None,+ clear_session=lambda _base: None,+ )+ codex = types.SimpleNamespace(+ _session_mgr=mgr,+ _turn_registry=treg,+ _transports={"/w": object()},+ retire_unowned_session_transport=retire,+ )++ result = asyncio.run(+ running_agents.end_running_agent(+ _make_controller(codex=codex), backend="codex", base_session_id="b1"+ )+ )+ assert result == {+ "ok": False,+ "error": "transport_retire_failed",+ "detail": "transport still alive",+ }+ assert cleared == []+++def test_end_codex_can_retry_failed_last_transport_retirement():+ from modules.agents.codex.session import CodexSessionManager++ mgr = CodexSessionManager()+ mgr.set_cwd("b1", "/w")+ mgr.set_session_key("b1", "session-key")+ attempts = []++ async def retire(cwd, *, ending_session_id=None):+ attempts.append((cwd, ending_session_id))+ if len(attempts) == 1:+ raise RuntimeError("transport still alive")+ return True++ codex = types.SimpleNamespace(+ _session_mgr=mgr,+ _turn_registry=types.SimpleNamespace(+ get_active_turn=lambda _base: None,+ clear_session=lambda _base: None,+ ),+ _transports={"/w": object()},+ retire_unowned_session_transport=retire,+ )+ controller = _make_controller(codex=codex)+ first = asyncio.run(+ running_agents.end_running_agent(+ controller, backend="codex", base_session_id="b1"+ )+ )+ assert first["error"] == "transport_retire_failed"+ assert mgr.get_cwd("b1") == "/w"+ assert mgr.get_session_key("b1") == "session-key"+ second = asyncio.run(+ running_agents.end_running_agent(+ controller, backend="codex", base_session_id="b1"+ )+ )+ assert second["ok"] is True+ assert second["process_killed"] is True+ assert mgr.get_cwd("b1") is None+ assert attempts == [("/w", "b1"), ("/w", "b1")]+++def test_codex_idle_retirement_serializes_successor_transport_generation():+ from modules.agents.codex.agent import CodexAgent++ async def exercise():+ agent = object.__new__(CodexAgent)+ agent._registered_runtime = False+ agent._transport_locks = {}+ agent._transport_last_activity = {"/w": 1.0}+ agent._transport_cwd_inodes = {}+ agent._session_mgr = types.SimpleNamespace(sessions_for_cwd=lambda _cwd: [])+ agent._has_active_turns_for_cwd = lambda _cwd: False+ stopping = asyncio.Event()+ resume_stop = asyncio.Event()++ class Transport:+ async def stop(self):+ stopping.set()+ await resume_stop.wait()++ old_transport = Transport()+ successor = Transport()+ agent._transports = {"/w": old_transport}+ retirement = asyncio.create_task(agent.retire_unowned_session_transport("/w"))+ await asyncio.wait_for(stopping.wait(), timeout=1)++ async def install_successor():+ async with agent._transport_locks["/w"]:+ agent._transports["/w"] = successor++ installation = asyncio.create_task(install_successor())+ await asyncio.sleep(0)+ assert not installation.done()+ resume_stop.set()+ assert await asyncio.wait_for(retirement, timeout=1) is True+ await asyncio.wait_for(installation, timeout=1)+ assert agent._transports["/w"] is successor++ asyncio.run(exercise())+++def test_codex_last_session_retirement_keeps_generation_on_failed_stop():+ from modules.agents.codex.agent import CodexAgent+ from modules.agents.codex.session import CodexSessionManager++ async def exercise():+ agent = object.__new__(CodexAgent)+ agent._registered_runtime = False+ agent._transport_locks = {}+ agent._transport_last_activity = {"/w": 1.0}+ agent._transport_cwd_inodes = {}+ agent._retire_model_hub_process_scope = lambda _cwd: None+ agent._session_mgr = CodexSessionManager()+ agent._session_mgr.set_cwd("b1", "/w")+ agent._has_active_turns_for_cwd = lambda _cwd: False++ class Transport:+ _process = None++ def __init__(self):+ self.attempts = 0++ async def stop(self):+ self.attempts += 1+ if self.attempts == 1:+ raise RuntimeError("stop failed")++ transport = Transport()+ agent._transports = {"/w": transport}+ with pytest.raises(RuntimeError, match="stop failed"):+ await agent.retire_unowned_session_transport(+ "/w", ending_session_id="b1"+ )+ assert agent._transports["/w"] is transport+ assert agent._session_mgr.get_cwd("b1") == "/w"+ assert await agent.retire_unowned_session_transport(+ "/w", ending_session_id="b1"+ )+ assert "/w" not in agent._transports++ asyncio.run(exercise())++def test_end_opencode_cancels_active_task():class _Task:def __init__(self):@@ -880,6 +1071,75 @@ def test_end_opencode_cancels_active_task():assert task.cancelled[email protected]("has_other_session", [False, True])+def test_end_idle_opencode_retires_only_last_shared_server(has_other_session):+ sessions = {+ "b1": ("oc-1", "/work", "channel-1"),+ }+ if has_other_session:+ sessions["b2"] = ("oc-2", "/work", "channel-2")+ retired = _AsyncFlag()+ server = types.SimpleNamespace(retire_for_native_migration=retired)+ manager = types.SimpleNamespace(+ get_request_session=lambda base: sessions.get(base),+ pop_request_session=lambda base: sessions.pop(base, None),+ list_all=lambda: dict(sessions),+ )+ agent = types.SimpleNamespace(+ _active_requests={},+ _session_manager=manager,+ _client_manager=types.SimpleNamespace(_server_manager=server),+ )++ result = asyncio.run(+ running_agents.end_running_agent(+ _make_controller(opencode=agent),+ backend="opencode",+ base_session_id="b1",+ )+ )++ assert result["ok"] is True+ assert result["process_killed"] is not has_other_session+ assert retired.called is not has_other_session+ assert "b1" not in sessions+ assert ("b2" in sessions) is has_other_session+++def test_end_idle_opencode_clears_disposable_session_caches():+ from modules.agents.opencode.session import OpenCodeSessionManager++ manager = object.__new__(OpenCodeSessionManager)+ manager._request_sessions = {+ "b1": ("oc-1", "/work", "channel-1"),+ "b2": ("oc-2", "/work", "channel-2"),+ }+ manager._agent_session_ids = {"b1": "session-1", "b2": "session-2"}+ manager._session_locks = {"b1": asyncio.Lock(), "b2": asyncio.Lock()}+ # The backend poll can remove its request mapping before close-after runs.+ manager.pop_request_session("b1")+ agent = types.SimpleNamespace(+ _active_requests={},+ _session_manager=manager,+ _session_last_activity={"b1": 1.0, "b2": 2.0},+ _client_manager=types.SimpleNamespace(_server_manager=None),+ )++ result = asyncio.run(+ running_agents.end_running_agent(+ _make_controller(opencode=agent),+ backend="opencode",+ base_session_id="b1",+ )+ )++ assert result["ok"] is True+ assert manager.list_all() == {"b2": ("oc-2", "/work", "channel-2")}+ assert set(manager._session_locks) == {"b2"}+ assert not hasattr(manager, "_initialized_sessions")+ assert agent._session_last_activity == {"b2": 2.0}++def test_end_opencode_settles_durable_owner_after_poll_is_gone(monkeypatch):"""A durable Workbench owner with no live poll is still an active turn.@@ -1268,6 +1528,13 @@ def test_end_active_codex_frees_runtime_after_stop():_transport_last_activity={"/w": 0.0},_runtime_turn_key_for_base_session=lambda b: f"{b}:/w",)+ async def retire(_cwd, *, ending_session_id=None):+ assert ending_session_id == "b1"+ await transport.stop()+ transports.pop("/w")+ return True++ codex.retire_unowned_session_transport = retirecontroller = _make_controller(codex=codex)controller.session_turns = types.SimpleNamespace(is_in_flight=lambda sid: False, cancel=_AsyncFlag())controller.command_handler = types.SimpleNamespace(handle_stop=_handle_stop)diff --git a/tests/test_session_delivery_fsm.py b/tests/test_session_delivery_fsm.pyindex 076002362..64ccfba3f 100644--- a/tests/test_session_delivery_fsm.py+++ b/tests/test_session_delivery_fsm.py@@ -208,6 +208,50 @@ def managers(tmp_path: Path, sqlite_db_factory, _fsm_schema_template):engine_b.dispose()+def test_close_after_successor_probe_reads_durable_queue_and_owner(managers) -> None:+ manager, _other, engine, _engine_b, _starts = managers+ assert manager.has_close_after_successor("ses_fsm", "completed-turn") is False++ timestamp = "2026-08-01T00:00:01+00:00"+ with engine.begin() as conn:+ conn.execute(+ message_deliveries.insert().values(+ id="queued-delivery",+ session_id="ses_fsm",+ priority="p3",+ state="queued",+ snapshot_sha256="snapshot",+ dispatch_sha256="dispatch",+ submitted_at=timestamp,+ updated_at=timestamp,+ )+ )+ assert manager.has_close_after_successor("ses_fsm", "completed-turn") is True++ with engine.begin() as conn:+ conn.execute(+ update(message_deliveries)+ .where(message_deliveries.c.id == "queued-delivery")+ .values(state="claimed", turn_id="successor-turn", turn_role="initial", turn_position=0)+ )+ conn.execute(+ session_turns.insert().values(+ id="successor-turn",+ session_id="ses_fsm",+ initial_delivery_id="queued-delivery",+ state="starting",+ backend="codex",+ start_attempt_id="attempt-1",+ dispatch_text="next",+ dispatch_sha256="dispatch",+ created_at=timestamp,+ updated_at=timestamp,+ )+ )+ assert manager.has_close_after_successor("ses_fsm", "completed-turn") is True+ assert manager.has_close_after_successor("ses_fsm", "successor-turn") is False++def test_fsm_template_matches_real_empty_metadata(tmp_path, _fsm_schema_template, sqlite_db_factory):reference = tmp_path / "reference.sqlite"engine = create_sqlite_engine(reference)diff --git a/tests/test_session_handler_base_id.py b/tests/test_session_handler_base_id.pyindex 4793d500c..17d3ecb9d 100644--- a/tests/test_session_handler_base_id.py+++ b/tests/test_session_handler_base_id.py@@ -9,6 +9,7 @@ from types import SimpleNamespacesys.path.insert(0, str(Path(__file__).resolve().parents[1]))from core.handlers.session_handler import ClaudeSessionNotFoundError, SessionHandler+from core.resource_governance import AgentResourceFailurefrom modules.im import MessageContext@@ -563,6 +564,155 @@ def test_claude_terminated_process_cleans_up_and_reports_signal_diagnostic() ->assert "Claude stderr tail:\nfatal: Claude CLI aborted\ntransport closed" in diagnostic+def test_claude_resource_failure_is_in_im_termination_notice(monkeypatch) -> None:+ for failure, expected in (+ (+ AgentResourceFailure(kind="memory", message="shared memory event"),+ "shared Agent cgroup recorded a memory limit event",+ ),+ (+ AgentResourceFailure(+ kind="pids",+ message="shared PID event",+ pids_current=0,+ pids_max=4096,+ ),+ "thread/process limit event (0/4096)",+ ),+ ):+ controller = _Controller(platform="slack")+ controller.im_client = _FakeIM()+ handler = SessionHandler(controller)+ client = SimpleNamespace(+ _transport=SimpleNamespace(_process=SimpleNamespace(returncode=-9)),+ )+ composite_key = "slack_C123:/tmp/workdir"+ controller.claude_sessions[composite_key] = client+ observations = []++ def observe(_controller):+ observations.append(True)+ return failure++ async def cleanup(_key, **_kwargs):+ return None++ monkeypatch.setattr(+ "core.handlers.session_handler.observe_agent_resource_pressure", observe+ )+ handler.cleanup_session = cleanup+ context = MessageContext(user_id="U123", channel_id="C123", platform="slack")++ asyncio.run(+ handler.handle_session_error(+ composite_key,+ context,+ RuntimeError("Claude process exited"),+ client=client,+ )+ )++ assert observations == [True]+ assert client._vibe_resource_failure is failure+ assert expected in controller.im_client.sent_messages[0][1]+++def test_claude_resource_diagnostic_uses_failed_client_not_replacement(monkeypatch) -> None:+ controller = _Controller(platform="slack")+ handler = SessionHandler(controller)+ composite_key = "slack_C123:/tmp/workdir"+ failed_client = SimpleNamespace(+ _transport=SimpleNamespace(_process=SimpleNamespace(returncode=-9)),+ )+ replacement = SimpleNamespace(+ _transport=SimpleNamespace(_process=SimpleNamespace(returncode=None)),+ )+ controller.claude_sessions[composite_key] = replacement+ failure = AgentResourceFailure(kind="memory", message="shared cgroup memory event")+ monkeypatch.setattr(+ "core.handlers.session_handler.observe_agent_resource_pressure",+ lambda _controller: failure,+ )++ diagnostic = handler.claude_error_diagnostic(+ composite_key,+ RuntimeError("old generation ended"),+ client=failed_client,+ )++ assert "SIGKILL" in diagnostic+ assert "shared cgroup memory event" in diagnostic+ assert failed_client._vibe_resource_failure is failure+ assert not hasattr(replacement, "_vibe_resource_failure")+++def test_intentional_claude_exit_does_not_consume_shared_resource_pressure(monkeypatch) -> None:+ controller = _Controller(platform="slack")+ handler = SessionHandler(controller)+ composite_key = "slack_C123:/tmp/workdir"+ intentional = SimpleNamespace(+ _transport=SimpleNamespace(_process=SimpleNamespace(returncode=-9)),+ _vibe_intentional_teardown=True,+ )+ failed = SimpleNamespace(+ _transport=SimpleNamespace(_process=SimpleNamespace(returncode=-9)),+ )+ failure = AgentResourceFailure(kind="memory", message="shared cgroup memory event")+ observations = []++ def observe(_controller):+ observations.append(True)+ return failure++ monkeypatch.setattr(+ "core.handlers.session_handler.observe_agent_resource_pressure",+ observe,+ )++ intentional_diagnostic = handler.claude_error_diagnostic(+ composite_key,+ RuntimeError("intentional exit"),+ client=intentional,+ )+ assert "Resource diagnosis" not in intentional_diagnostic+ assert observations == []++ failed_diagnostic = handler.claude_error_diagnostic(+ composite_key,+ RuntimeError("unexpected exit"),+ client=failed,+ )+ assert "shared cgroup memory event" in failed_diagnostic+ assert observations == [True]+++def test_negative_claude_pressure_check_is_cached_for_exited_client(monkeypatch) -> None:+ controller = _Controller(platform="slack")+ handler = SessionHandler(controller)+ client = SimpleNamespace(+ _transport=SimpleNamespace(_process=SimpleNamespace(returncode=-9)),+ )+ observations = []++ def observe(_controller):+ observations.append(True)+ return None if len(observations) == 1 else AgentResourceFailure(+ kind="pids", message="later shared event"+ )++ monkeypatch.setattr(+ "core.handlers.session_handler.observe_agent_resource_pressure", observe+ )+ for _ in range(2):+ diagnostic = handler.claude_error_diagnostic(+ "slack_C123:/tmp/workdir",+ RuntimeError("old generation ended"),+ client=client,+ )+ assert "later shared event" not in diagnostic+ assert observations == [True]++def test_service_initiated_teardown_signal_is_not_reported_as_session_error() -> None:"""A SIGKILL the service issued itself must not read as a backend crash.diff --git a/vibe/cli.py b/vibe/cli.pyindex b48818da8..b2c11ffb0 100644--- a/vibe/cli.py+++ b/vibe/cli.py@@ -36,6 +36,7 @@ from config import pathsfrom config.atomic_io import write_atomicfrom config.v2_config import V2Configfrom core.scheduled_tasks import (+ AGENT_RUN_CLOSE_AFTER_METADATA_KEY,AGENT_RUN_DELIVERY_QUEUE,AGENT_RUN_DELIVERY_STEER,BINDING_FOLLOWS_SESSION_METADATA_KEY,@@ -5723,6 +5724,7 @@ def _validate_run_session_policy(args, *, help_command: str) -> str:deliver_key = (getattr(args, "deliver_key", None) or "").strip()agent_name = (getattr(args, "agent", None) or "").strip()visibility = (getattr(args, "visibility", None) or "").strip()+ close_after = bool(getattr(args, "close_after", False))if bool(getattr(args, "async_run", False)) and bool(getattr(args, "sync_run", False)):raise TaskCliError("use either --async or --sync, not both",@@ -5803,6 +5805,13 @@ def _validate_run_session_policy(args, *, help_command: str) -> str:hint="Use `vibe session update --visible|--hidden` (or `--visibility ...`) to change an existing Session.",help_command=help_command,)+ if close_after and session_id:+ raise TaskCliError(+ "--close-after requires a new or forked Agent Session",+ code="close_after_requires_owned_session",+ hint="Use --close-after with --agent, --create-session, or --fork-session. Existing Sessions keep their runtime lifecycle.",+ help_command=help_command,+ )if session_id and (create_session or create_per_run):raise TaskCliError("use either --session-id or --create-session, not both",@@ -6709,6 +6718,7 @@ def cmd_agent_run(args):callback_session_id, callback_notice = _resolve_callback_session_id(args, caller_context, target_session_id=session_id)if callback_session_id:_validate_callback_session_id(callback_session_id, help_command="vibe agent run --help")+ close_after = bool(getattr(args, "close_after", False))legacy_deliver_key = args.deliver_keyif (getattr(args, "same_scope", False) or (getattr(args, "scope_id", None) or "").strip()) and legacy_deliver_key != scope_key:legacy_deliver_key = None@@ -6782,6 +6792,8 @@ def cmd_agent_run(args):provenance_metadata = metadata_with_resource_user_context(provenance_metadata, caller_authorization)+ if close_after:+ provenance_metadata[AGENT_RUN_CLOSE_AFTER_METADATA_KEY] = Truerequest_store = _task_request_store()request = request_store.enqueue_agent_run(agent_name=agent.name if agent else None,@@ -6820,6 +6832,7 @@ def cmd_agent_run(args):"visibility": target.visibility if session_id else visibility,"deliver_key": legacy_deliver_key,"callback_session_id": callback_session_id,+ "close_after": close_after,"async": run_async,"caller_context": caller_context.to_metadata() if caller_context else None,"callback_notice": callback_notice,@@ -6835,6 +6848,7 @@ def cmd_agent_run(args):"source_kind": source_kind,"source_actor": source_actor,"parent_run_id": parent_run_id,+ "close_after": close_after,},}if bool(getattr(args, "send_now", False)) or delivery_intent != AGENT_RUN_DELIVERY_STEER:@@ -16405,6 +16419,11 @@ def build_parser():action="store_true",help="For async runs, intentionally skip automatic callback delivery and inspect the run later.",)+ agent_run_parser.add_argument(+ "--close-after",+ action="store_true",+ help="Close the newly-created Agent runtime after the run settles while keeping its Session and transcript.",+ )agent_wait_group = agent_run_parser.add_mutually_exclusive_group()agent_wait_group.add_argument("--async",diff --git a/vibe/i18n/en.json b/vibe/i18n/en.jsonindex ca5ad8a90..e6922d2bc 100644--- a/vibe/i18n/en.json+++ b/vibe/i18n/en.json@@ -416,6 +416,10 @@"claudeProcessSignal": "{signal} (signal {number})","claudeProcessExitCode": "exit code {code}","claudeProcessTerminated": "Claude Code process terminated ({reason}); the session was reset. Please try your message again.",+ "agentPidsLimit": "The shared Agent cgroup recorded a thread/process limit event ({current}/{limit}); concurrent Agent processes may be affected.",+ "agentPidsCurrentUnavailable": "unknown",+ "agentPidsLimitUnavailable": "unknown or unlimited",+ "agentMemoryLimit": "The shared Agent cgroup recorded a memory limit event; concurrent Agent processes may be affected.","claudeCredentialTypeInvalid": "Choose either API key or auth token for the Claude Code credential.","claudeSessionNotFound": "Claude Code could not find the historical session `{sessionId}` in the current working directory:\n`{path}`\n\nClaude Code sessions are scoped to a working directory. This usually means the conversation was resumed after switching workdirs, or the local Claude Code session data changed. Restore the original session in its original working directory, then explicitly retry the pending input; or start a new conversation from the current directory.","sessionGeneric": "An error occurred: {error}",diff --git a/vibe/i18n/zh.json b/vibe/i18n/zh.jsonindex b5b950810..639b022bb 100644--- a/vibe/i18n/zh.json+++ b/vibe/i18n/zh.json@@ -416,6 +416,10 @@"claudeProcessSignal": "{signal}(信号 {number})","claudeProcessExitCode": "退出码 {code}","claudeProcessTerminated": "Claude Code 进程已终止({reason});会话已重置,请重试。",+ "agentPidsLimit": "共享 Agent cgroup 记录到进程/线程上限事件({current}/{limit});并发 Agent 进程可能受到影响。",+ "agentPidsCurrentUnavailable": "未知",+ "agentPidsLimitUnavailable": "未知或不限",+ "agentMemoryLimit": "共享 Agent cgroup 记录到内存上限事件;并发 Agent 进程可能受到影响。","claudeCredentialTypeInvalid": "Claude Code 凭据类型只能选择 API Key 或 Auth Token。","claudeSessionNotFound": "Claude Code 在当前工作目录下找不到历史会话 `{sessionId}`:\n`{path}`\n\nClaude Code 的会话和工作目录相关。通常是恢复会话后切换了工作目录,或本地 Claude Code 会话数据发生变化。请在原工作目录恢复原会话,再手动重试待发送的输入;也可以在当前目录开始一个新会话。","sessionGeneric": "发生错误:{error}",