@ponythewhite/base-context 1.0.14 → 1.0.16

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## [1.0.16] - 2026-09-28
+
+- Fixed background child-usage updates incorrectly stopping an active goal during request preparation.
+- Kept failed goals visible in the bottom-right status tray instead of hiding them.
+- Fixed temporary memory retention when reading a final multi-chunk line without a trailing newline.
+- Added `job-watch` for native job monitoring, prepared reports, and scoped waiting in goal and autonomous modes.
+- Added `bounded-inspect` for selected text and JSON evidence under shared source and output budgets.
+- Improved skill recovery, child-result capsule guidance, and reuse of small project helpers.
+
+## [1.0.15] - 2026-09-28
+
+- Fixed compaction of long-lived sessions by selecting the active canonical context before source hydration. This covers manual, agent-requested, threshold, and overflow-recovery compaction without increasing source limits.
+- Fixed Codex HTTP retries losing native context acknowledgement after retryable failures. Only an unchanged prepared request can reuse its acknowledged epoch.
+- Changed `/goal stop` and `/goal clear` to acknowledge the goal that was cleared instead of reporting only the resulting idle state.
+- Fixed daemon worker connection retries retaining failed socket and channel references.
+- Handled Python kernel stderr stream errors through the existing kernel error path.
+- Fixed the goal status display being overwritten by delayed state reads and streamed catch-up snapshots.
+
 ## [1.0.14] - 2026-09-23
 
 - Fixed compaction recovery after failed or interrupted partial tool calls, including resuming affected saved sessions without exposing failed replies to the provider.

package/dist/base-context-runtime/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "base-context-runtime"
-version = "1.0.14"
+version = "1.0.16"
 description = "Kernel-side runtime shim for Base Context recursion"
 license = "MIT"
 license-files = ["LICENSE", "NOTICE"]

package/dist/base-context-runtime/src/rlm/bash.py

@@ -594,6 +594,25 @@ class BashHandle:
                 return
         callback()
 
+    def add_done_callback(self, callback: Callable[[BashResult], None]) -> Callable[[], None]:
+        """Observe completion without taking await ownership; return an unsubscribe function.
+
+        The callback may run on a worker thread or immediately for a finished handle.
+        Removing it never signals the process. A callback already running may finish.
+        """
+        def invoke() -> None:
+            assert self._result is not None
+            callback(self._result)
+
+        self._add_done_callback(invoke)
+
+        def remove() -> None:
+            with self._callback_lock:
+                if invoke in self._callbacks:
+                    self._callbacks.remove(invoke)
+
+        return remove
+
     async def _wait(self) -> BashResult:
         # Asyncio-native wakeup: no executor thread is parked for the command's
         # duration, so many concurrent awaits cannot exhaust the default pool.

package/dist/base-context-runtime/src/rlm/job_watch.py

@@ -0,0 +1,156 @@
+"""Contained job-watch probes and completion callbacks. No notebook evaluation."""
+from __future__ import annotations
+
+import asyncio
+import json
+import math
+import uuid
+from decimal import Decimal
+import weakref
+from datetime import datetime, timezone
+from typing import Any, Callable
+
+from .bash import BashHandle, BashResult, bash
+
+_identities: weakref.WeakKeyDictionary[BashHandle, str] = weakref.WeakKeyDictionary()
+_handles: weakref.WeakValueDictionary[str, BashHandle] = weakref.WeakValueDictionary()
+_results: weakref.WeakKeyDictionary[BashHandle, BashResult] = weakref.WeakKeyDictionary()
+_callbacks: dict[tuple[str, str], Callable[[], None]] = {}
+_probes: dict[str, asyncio.Task[None]] = {}
+
+
+def identity(handle: BashHandle) -> str:
+    if not isinstance(handle, BashHandle):
+        raise TypeError("job must be a live BashHandle")
+    resource = _identities.setdefault(handle, uuid.uuid4().hex)
+    _handles[resource] = handle
+    return resource
+
+
+def _observed(job_id: str, result: BashResult | None) -> dict[str, Any]:
+    return {
+        "observed_at": datetime.now(timezone.utc).isoformat(),
+        "job_id": job_id,
+        "state": "running" if result is None else "succeeded" if result.exit_code == 0 else "failed",
+        "progress": {} if result is None else {"exit_code": result.exit_code, "duration_seconds": result.duration},
+        "attention": [], "evidence": [],
+    }
+
+
+def bind(handle: BashHandle, watch_id: str, generation: str, job_id: str) -> None:
+    from . import host_request
+    loop = asyncio.get_running_loop()
+    key = (watch_id, generation)
+    if key in _callbacks:
+        return
+
+    async def deliver(observation: dict[str, Any]) -> None:
+        try:
+            await host_request("job_watch.observation", {
+                "id": watch_id, "generation": generation,
+                "result": {"source": "handle", "observation": observation},
+            })
+        except RuntimeError:
+            pass  # Host teardown owns recovery; never restart a monitored process.
+
+    def completed(result: BashResult) -> None:
+        _results[handle] = result
+        observation = _observed(job_id, result)
+        try:
+            loop.call_soon_threadsafe(lambda: asyncio.create_task(deliver(observation)))
+        except RuntimeError:
+            pass
+
+    _callbacks[key] = handle.add_done_callback(completed)
+
+
+def unbind(watch_id: str) -> None:
+    for key in list(_callbacks):
+        if key[0] == watch_id:
+            _callbacks.pop(key)()
+
+
+_SAFE_INTEGER = 2**53 - 1
+_NUMERIC_ERROR = "probe numeric precision is unavailable; encode exact identifiers and precision-sensitive values as strings"
+
+
+def _exact_integer(token: str) -> int:
+    try:
+        value = int(token)
+    except ValueError:
+        raise ValueError(_NUMERIC_ERROR) from None
+    if abs(value) > _SAFE_INTEGER or token == "-0":
+        raise ValueError(_NUMERIC_ERROR)
+    return value
+
+
+def _exact_decimal(token: str) -> float:
+    value = float(token)
+    if (not math.isfinite(value) or abs(value) > _SAFE_INTEGER
+            or (value == 0 and token.startswith("-")) or Decimal(str(value)) != Decimal(token)):
+        raise ValueError(_NUMERIC_ERROR)
+    return value
+
+
+async def _probe(request: dict[str, Any]) -> None:
+    from . import host_request
+    request_id = request["id"]
+    try:
+        command = request.get("command")
+        handle = _handles.get(request["resourceId"])
+        if request.get("completionSource") == "handle" and handle is None:
+            result = {"source": "handle", "error": "handle unavailable after kernel restart"}
+        elif command is None:
+            result = ({"source": "handle", "observation": _observed(request["jobId"], _results.get(handle))}
+                      if handle is not None else {"source": "handle", "error": "handle unavailable after kernel restart"})
+        else:
+            # The first await owns this new probe only. Cancellation never reaches the monitored job.
+            finished = await asyncio.wait_for(bash(command), timeout=request["timeoutMs"] / 1000)
+            output = finished.output
+            result = {"source": "probe", "output": output, "capture_complete": False}
+            if finished.exit_code != 0:
+                result["error"] = f"probe exited {finished.exit_code}"
+            elif len(output.encode("utf-8")) > 16384:
+                result["error"] = "probe JSON exceeds 16 KiB; use a project summary producer"
+            else:
+                try:
+                    result["observation"] = json.loads(output, parse_int=_exact_integer,
+                                                       parse_float=_exact_decimal, parse_constant=_exact_decimal)
+                except (ValueError, TypeError) as error:
+                    result["error"] = (str(error) if isinstance(error, ValueError) and not isinstance(error, json.JSONDecodeError)
+                                       else "probe JSON unavailable or incomplete")
+        await host_request("job_watch.probe_result", {"request_id": request_id, "result": result})
+    except asyncio.CancelledError:
+        raise
+    except Exception as error:
+        try:
+            await host_request("job_watch.probe_result", {
+                "request_id": request_id, "result": {"source": "probe", "error": f"{type(error).__name__}: {error}"[:256]},
+            })
+        except RuntimeError:
+            pass
+    finally:
+        _probes.pop(request_id, None)
+
+
+def dispatch(request: dict[str, Any]) -> None:
+    """Called only by the REPL protocol dispatcher, not by notebook eval."""
+    request_id = request.get("id")
+    if not isinstance(request_id, str):
+        raise ValueError("job_watch_probe requires an id")
+    if request.get("cancel"):
+        task = _probes.get(request_id)
+        if task:
+            task.cancel()
+        return
+    if request_id in _probes:
+        return
+    if not isinstance(request.get("jobId"), str) or not isinstance(request.get("resourceId"), str):
+        raise ValueError("job_watch_probe requires resource and job identity")
+    command = request.get("command")
+    if command is not None and (not isinstance(command, str) or not command or len(command.encode()) > 8192):
+        raise ValueError("invalid probe command")
+    timeout = request.get("timeoutMs")
+    if not isinstance(timeout, (int, float)) or not 1 <= timeout <= 300000:
+        raise ValueError("invalid probe timeout")
+    _probes[request_id] = asyncio.create_task(_probe(request))

package/dist/base-context-runtime/src/rlm/repl.md

@@ -3,7 +3,7 @@
 `python -m rlm.repl` starts a CPython REPL runtime that executes code cells in
 one persistent `__main__` namespace on a single asyncio event loop. The wire
 format is newline-delimited JSON: one object per line, UTF-8, no other framing.
-The current protocol version is `3`; the runtime announces it in the `ready`
+The current protocol version is `4`; the runtime announces it in the `ready`
 event.
 
 ## Channels
@@ -30,20 +30,23 @@ event.
 | `execute` | `{"type":"execute","id":str,"code":str}` |
 | `interrupt` | `{"type":"interrupt","id"?:str}` — no reply |
 | `host_reply` | `{"type":"host_reply","id":str,"data":{"status":"ok","result":{...}}}` or an error envelope — no reply |
+| `job_watch_probe` | Optional capability: `{"type":"job_watch_probe","id":str,"watchId":str,"generation":str,"resourceId":str,"jobId":str,"completionSource":"handle"|"probe","command":str|null,"timeoutMs":number}`; cancel with `{"type":"job_watch_probe","id":str,"cancel":true}` |
 | `snapshot` | `{"type":"snapshot","id":str,"path":str,"manifest_path":str,"max_bytes"?:int,"max_variable_bytes"?:int,"prune_oversized"?:bool}` |
 | `restore` | `{"type":"restore","id":str,"path":str}` |
 | `list_names` | `{"type":"list_names","id":str}` |
 | `shutdown` | `{"type":"shutdown","id"?:str}` |
 
-Requests other than `interrupt` and `host_reply` run strictly in order, one at
-a time. A malformed line
+Requests other than `interrupt`, `host_reply`, and the optional `job_watch_probe`
+run strictly in order, one at a time. A malformed line
 produces `{"event":"error","id":null,"ename":"ProtocolError",...}` and the
 runtime keeps serving. Closing stdin is equivalent to `shutdown`.
 
 ## Events
 
-- `{"event":"ready","protocol":3,"python":"3.13.11"}` — sent once at startup;
-  the handshake. No banner precedes it.
+- `{"event":"ready","protocol":4,"python":"3.13.11"}` — sent once at startup;
+  the handshake. No banner precedes it. The optional `capabilities` array may
+  contain `"job_watch_probe_v1"`. Protocol version remains 4; old hosts ignore
+  optional metadata and new hosts refuse probes locally when the capability is absent.
 - `{"event":"stdout"|"stderr","id":str|null,"text":str}` — captured output.
   `id` is the cell whose Python execution context performed the write; asyncio
   tasks inherit the spawning cell's id (even after that cell finished). `null`
@@ -62,7 +65,7 @@ runtime keeps serving. Closing stdin is equivalent to `shutdown`.
   carrying the same id.
 - `{"event":"error","id":str|null,"ename":str,"evalue":str,"traceback":[str,...]}`
 - `{"event":"done","id":str,"status":"ok"|"error"}` — exactly one per id'd
-  request, always after all of that request's other events. A snapshot `done`
+  queued request, always after all of that request's other events. A snapshot `done`
   adds `saved`, `skipped`, `pruned`, `bytes`; a restore `done` adds `restored`,
   `failed`; a `list_names` `done` adds `names`; a failed snapshot/restore adds
   `reason`. Restoring a missing file reports `status:"ok"` with empty
@@ -138,6 +141,25 @@ in-flight execute. Replies for unknown ids, or for a request whose awaiting
 cell was cancelled, are dropped. `rlm.repl.is_active()` reports whether the
 process is serving the protocol (importing the module does not count).
 
+## Optional job-watch bridge
+
+`job_watch_probe_v1` runs contained read-only probes outside the ordinary cell
+FIFO, not notebook closures. Results use the existing host bridge with
+`type:"job_watch.probe_result"`, the original `request_id`, and `result`; this
+request does not produce an ordinary cell `done`. Local handle completion uses
+`job_watch.observation` with watch identity/generation. The host owns comparison,
+scheduling, prepared follow-ups, and scoped goal/autonomous parking.
+
+Probe commands must name the intended working directory, interpreter, and paths;
+no notebook environment snapshot is persisted.
+
+`completionSource` distinguishes a local handle from an authoritative external
+probe. A lost handle becomes unknown; neither a PID nor a successful detached
+launcher is proof of remote completion. Cancelling a probe or unregistering a
+watch does not kill the monitored job. The passive Bash callback bridge does
+not change interrupted-await ownership. This adds no daemon wire version or
+model tool and requires no extra startup service.
+
 ## Snapshot / restore
 
 `snapshot` serializes the user namespace with `dill` (recurse mode), one name

package/dist/base-context-runtime/src/rlm/repl.py

@@ -986,6 +986,10 @@ def _handle_request_line(raw: bytes, queue: asyncio.Queue[dict[str, Any]]) -> No
             return
         _request_interrupt(req.get("id"))
         return
+    if rtype == "job_watch_probe":
+        from .job_watch import dispatch
+        _loop.call_soon_threadsafe(dispatch, req)
+        return
     if rtype == "host_reply":
         # Bypass the FIFO queue: the awaiting cell IS the in-flight
         # execute, so a queued reply would deadlock behind it.
@@ -1152,7 +1156,8 @@ def main() -> None:
     signal.signal(signal.SIGINT, _sigint_handler)
     threading.Thread(target=_read_requests, args=(stdin_fd, queue), daemon=True).start()
 
-    _send({"event": "ready", "protocol": PROTOCOL_VERSION, "python": platform.python_version()})
+    _send({"event": "ready", "protocol": PROTOCOL_VERSION, "python": platform.python_version(),
+           "capabilities": ["job_watch_probe_v1"]})
 
     _serve_task = _loop.create_task(_serve(queue, user_module.__dict__))
     # A KeyboardInterrupt escaping a cell or background task stops

package/dist/base-context-runtime/test/test_bash.py

@@ -1237,8 +1237,8 @@ class BashTest(unittest.IsolatedAsyncioTestCase):
             with mock.patch.dict(
                 os.environ,
                 {
-                    "PRIME_AGENT_INTERNAL_ORPHAN_PROCESS_JOURNAL": journal,
-                    "PRIME_AGENT_KERNEL_OWNER_PID": "notanint",
+                    "BASE_CONTEXT_INTERNAL_ORPHAN_PROCESS_JOURNAL": journal,
+                    "BASE_CONTEXT_KERNEL_OWNER_PID": "notanint",
                 },
             ):
                 with self.assertRaises(RuntimeError):
@@ -1250,8 +1250,8 @@ class BashTest(unittest.IsolatedAsyncioTestCase):
             with mock.patch.dict(
                 os.environ,
                 {
-                    "PRIME_AGENT_INTERNAL_ORPHAN_PROCESS_JOURNAL": journal,
-                    "PRIME_AGENT_KERNEL_OWNER_PID": str(os.getpid()),
+                    "BASE_CONTEXT_INTERNAL_ORPHAN_PROCESS_JOURNAL": journal,
+                    "BASE_CONTEXT_KERNEL_OWNER_PID": str(os.getpid()),
                 },
             ):
                 with mock.patch.object(bash_module, "_process_start_id", return_value=None):

package/dist/base-context-runtime/test/test_job_watch.py

@@ -0,0 +1,67 @@
+import asyncio
+import unittest
+from rlm.bash import bash
+from rlm.job_watch import identity, _probe, _handles
+from unittest.mock import AsyncMock, patch
+import gc
+import threading
+
+
+class JobWatchCallbackTest(unittest.IsolatedAsyncioTestCase):
+    async def test_callback_and_identity_preserve_first_await_ownership(self):
+        handle = bash("python3 -c 'import time; time.sleep(10)'")
+        resource = identity(handle)
+        remove = handle.add_done_callback(lambda result: None)
+        with patch("rlm.host_request", new=AsyncMock()):
+            await _probe({"id": "probe", "resourceId": resource, "jobId": "job", "completionSource": "handle", "command": None})
+        self.assertFalse(handle._released)
+        async def wait():
+            return await handle
+        task = asyncio.create_task(wait())
+        await asyncio.sleep(0)
+        task.cancel()
+        with self.assertRaises(asyncio.CancelledError):
+            await task
+        self.assertIsNotNone(handle.poll())
+        self.assertNotEqual(handle.poll().exit_code, 0)
+        remove()
+
+    async def test_background_await_stays_nonowning_and_unregister_never_kills(self):
+        handle = bash("python3 -c 'import time; time.sleep(10)'")
+        _ = handle.pid
+        remove = handle.add_done_callback(lambda result: None)
+        async def wait():
+            return await handle
+        task = asyncio.create_task(wait())
+        await asyncio.sleep(0)
+        task.cancel()
+        with self.assertRaises(asyncio.CancelledError):
+            await task
+        remove()
+        self.assertIsNone(handle.poll())
+        handle.kill(grace=0)
+        await handle
+
+    async def test_completed_callback_is_immediate_and_idempotently_removable(self):
+        workers = []
+        real_thread = threading.Thread
+        def worker_thread(*args, **kwargs):
+            thread = real_thread(*args, **kwargs)
+            workers.append(thread)
+            return thread
+        with patch("rlm.bash.threading.Thread", side_effect=worker_thread):
+            handle = bash("printf done")
+        resource = identity(handle)
+        result = await handle
+        seen = []
+        remove = handle.add_done_callback(seen.append)
+        remove(); remove()
+        self.assertEqual(seen, [result])
+        # Foreground result delivery precedes containment-worker retirement.
+        # Their bound methods legitimately retain the handle until they exit.
+        for worker in workers:
+            await asyncio.to_thread(worker.join, 1)
+            self.assertFalse(worker.is_alive())
+        del remove, handle
+        gc.collect()
+        self.assertNotIn(resource, _handles)

package/dist/base-context-runtime/uv.lock

@@ -367,7 +367,7 @@ wheels = [
 
 [[package]]
 name = "base-context-runtime"
-version = "1.0.14"
+version = "1.0.16"
 source = { editable = "." }
 dependencies = [
     { name = "mcp" },

package/dist/build-info.json

@@ -1,5 +1,5 @@
 {
-  "sourceCommit": "1c9651df8abd812cdba9e323517067363acc621c",
+  "sourceCommit": "2ec583d3c870d042a46a5ecc1e6ffa83b8edd95e",
   "sourceDirty": false,
   "buildHost": {
     "platform": "linux",

package/dist/bundle/{bundled-modules-UODO7ZR7.js → bundled-modules-2DMTK7VK.js}

@@ -51,7 +51,7 @@ import {
   oauth_exports,
   runPrintMode,
   runRpcMode
-} from "./chunk-NLRWERWA.js";
+} from "./chunk-T2OK7SRV.js";
 import {
   AgentSession,
   CURRENT_SESSION_VERSION,
@@ -143,7 +143,7 @@ import {
   withFileMutationQueue,
   wrapRegisteredTool,
   wrapRegisteredTools
-} from "./chunk-SX7CAXWU.js";
+} from "./chunk-MSH6QRP5.js";
 import "./chunk-CFNASUYO.js";
 import "./chunk-V6LOBH6X.js";
 import {