@crvouga/mockingbird-service-hermes 0.1.0

package/oracle/compare.mjs

@@ -0,0 +1,274 @@
+import assert from "node:assert/strict"
+import { spawn } from "node:child_process"
+import { mkdir, readFile, writeFile } from "node:fs/promises"
+import { resolve } from "node:path"
+import { createInterface } from "node:readline"
+import { createServer } from "../dist/server.js"
+import { normalizeObservation } from "./comparison.mjs"
+
+if (!process.argv.includes("--run") || process.env.MOCKINGBIRD_HERMES_ORACLE_APPROVED !== "1") {
+  throw new Error(
+    "Opt-in oracle requires --run and explicit approved disposable-process/database execution",
+  )
+}
+const root = resolve(import.meta.dirname, "../../../..")
+const python = process.env.HERMES_ORACLE_PYTHON
+if (!python)
+  throw new Error("Set HERMES_ORACLE_PYTHON to the approved local virtualenv interpreter")
+const source = resolve(root, ".mockingbird/hermes-evidence/v2026.8.31")
+const scratch = resolve(root, ".mockingbird/hermes-oracle", crypto.randomUUID())
+await mkdir(scratch, { recursive: true })
+const lock = JSON.parse(await readFile(new URL("source-lock.json", import.meta.url), "utf8"))
+const mock = await createServer()
+let currentTime = 1700000000
+let upstream
+const epochs = []
+const comparisons = []
+const ids = { real: new Map(), mock: new Map() }
+
+const launch = () =>
+  new Promise((resolveLaunch, reject) => {
+    const child = spawn(
+      python,
+      [
+        resolve(import.meta.dirname, "server.py"),
+        "--sources",
+        source,
+        "--state",
+        resolve(scratch, "runs.db"),
+        "--time",
+        String(currentTime),
+        "--allow-disposable-state",
+      ],
+      {
+        cwd: root,
+        env: { PATH: process.env.PATH, PYTHONDONTWRITEBYTECODE: "1", HERMES_HOME: scratch },
+        stdio: ["ignore", "pipe", "pipe"],
+      },
+    )
+    const lines = createInterface({ input: child.stdout })
+    let stderr = ""
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString()
+    })
+    const timer = setTimeout(() => {
+      child.kill("SIGTERM")
+      reject(new Error(`Oracle startup deadline: ${stderr}`))
+    }, 10000)
+    child.once("error", (error) => {
+      clearTimeout(timer)
+      reject(error)
+    })
+    child.once("exit", (code) => {
+      clearTimeout(timer)
+      reject(new Error(`Oracle exited before ready (${code}): ${stderr}`))
+    })
+    lines.once("line", (line) => {
+      clearTimeout(timer)
+      try {
+        const ready = JSON.parse(line)
+        epochs.push({ ...ready, url: undefined })
+        resolveLaunch({ child, url: ready.url, stderr: () => stderr })
+      } catch (error) {
+        child.kill("SIGTERM")
+        reject(error)
+      }
+    })
+  })
+const raw = async (url, method, path, body, key = "") => {
+  const response = await fetch(`${url}${path}`, {
+    method,
+    headers: { "content-type": "application/json", "Idempotency-Key": key },
+    ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+    signal: AbortSignal.timeout(5000),
+  })
+  return {
+    status: response.status,
+    replayed: response.headers.get("Idempotency-Replayed"),
+    body: await response.json(),
+  }
+}
+const checkedControl = async (url, path, body) => {
+  const response = await raw(url, "POST", path, body)
+  assert.equal(response.status, 200, `control ${path}: ${JSON.stringify(response.body)}`)
+  return response
+}
+const control = (body) => checkedControl(upstream.url, "/__oracle/control", body)
+const admin = (path, body) => checkedControl(mock.url, `/__admin/${path}`, body)
+const equal = (label, real, mocked) => {
+  const expected = normalizeObservation(real, ids.real)
+  const actual = normalizeObservation(mocked, ids.mock)
+  assert.deepEqual(actual, expected, label)
+  comparisons.push({ label, status: real.status, observation: expected.body })
+}
+const poll = async (pair, label) => {
+  equal(
+    label,
+    await raw(upstream.url, "GET", `/v1/runs/${pair.real}`),
+    await raw(mock.url, "GET", `/v1/runs/${pair.mock}`),
+  )
+}
+const waitRunning = async (id) => {
+  const deadline = performance.now() + 3000
+  while (true) {
+    const response = await raw(upstream.url, "GET", `/v1/runs/${id}`)
+    if (response.body.status === "running") return
+    if (performance.now() > deadline || ["failed", "cancelled"].includes(response.body.status))
+      throw new Error(`Upstream executor did not reach running: ${JSON.stringify(response)}`)
+    await new Promise((resolve) => setImmediate(resolve))
+  }
+}
+const submit = async (name, key = name) => {
+  const body = { input: "synthetic oracle input" }
+  const real = await raw(upstream.url, "POST", "/v1/runs", body, key)
+  const mocked = await raw(mock.url, "POST", "/v1/runs", body, key)
+  assert.equal(real.status, 202)
+  assert.equal(mocked.status, 202)
+  const pair = { real: real.body.run_id, mock: mocked.body.run_id, key, body }
+  ids.real.set(pair.real, name)
+  ids.mock.set(pair.mock, name)
+  equal(`${name}:admission`, real, mocked)
+  await waitRunning(pair.real)
+  await admin(`hermes/runs/${pair.mock}/observe`, { status: "running" })
+  await poll(pair, `${name}:running`)
+  return pair
+}
+const replay = async (pair, label, body = pair.body) =>
+  equal(
+    label,
+    await raw(upstream.url, "POST", "/v1/runs", body, pair.key),
+    await raw(mock.url, "POST", "/v1/runs", body, pair.key),
+  )
+const stop = async (pair) =>
+  equal(
+    `${pair.key}:stop`,
+    await raw(upstream.url, "POST", `/v1/runs/${pair.real}/stop`, {}),
+    await raw(mock.url, "POST", `/v1/runs/${pair.mock}/stop`, {}),
+  )
+const settle = async (pair, status) => {
+  const result =
+    status === "cancelled"
+      ? { interrupted: true }
+      : status === "failed"
+        ? { failed: true, error: "synthetic failure" }
+        : { final_response: "synthetic output" }
+  await control({ settle: pair.real, result })
+  await admin(`hermes/runs/${pair.mock}/observe`, {
+    status,
+    last_event: `run.${status}`,
+    ...(status === "completed"
+      ? {
+          output: "synthetic output",
+          usage: { input_tokens: 0, output_tokens: 0, total_tokens: 0 },
+        }
+      : {}),
+    ...(status === "failed" ? { error: "synthetic failure" } : {}),
+  })
+  await poll(pair, `${pair.key}:${status}`)
+}
+const setTime = async (time) => {
+  currentTime = time
+  await control({ time })
+  await admin("clock", { set: time * 1000, freeze: true })
+}
+const crash = async () => {
+  const old = upstream
+  upstream = undefined
+  if (old.child.exitCode !== null || old.child.signalCode !== null)
+    throw new Error(`Oracle exited unexpectedly: ${old.stderr()}`)
+  let timer
+  const exited = new Promise((resolveExit, reject) => {
+    old.child.once("exit", (code) => {
+      clearTimeout(timer)
+      if (code === 0) resolveExit()
+      else reject(new Error(`Oracle process exited with ${code}`))
+    })
+    timer = setTimeout(() => {
+      old.child.kill("SIGTERM")
+      reject(new Error("Oracle crash endpoint did not exit the owned process"))
+    }, 6000)
+  })
+  // Observe rejection immediately while awaiting the expected lost connection.
+  const outcome = exited.then(
+    () => null,
+    (error) => error,
+  )
+  await fetch(`${old.url}/__oracle/crash`, {
+    method: "POST",
+    signal: AbortSignal.timeout(5000),
+  }).catch(() => {})
+  const error = await outcome
+  if (error) throw error
+}
+try {
+  upstream = await launch()
+  await admin("clock", { set: currentTime * 1000, freeze: true })
+  const cancelled = await submit("cancelled")
+  await replay(cancelled, "active replay")
+  await replay(cancelled, "changed body conflicts", { input: "different synthetic input" })
+  await stop(cancelled)
+  await settle(cancelled, "cancelled")
+  await replay(cancelled, "terminal replay")
+  const completed = await submit("completion-race")
+  await stop(completed)
+  await settle(completed, "completed")
+  const failed = await submit("failure")
+  await settle(failed, "failed")
+  const cached = await submit("cache-boundary", "")
+  await settle(cached, "completed")
+  await setTime(1700000000 + 3600)
+  await control({ sweep: true })
+  await admin("hermes/sweep", {})
+  await poll(cached, "cache TTL equality retains keyless terminal observation")
+  await setTime(1700000000 + 3600.001)
+  await control({ sweep: true })
+  await admin("hermes/sweep", {})
+  await poll(cached, "cache TTL strictly greater expires keyless terminal observation")
+  const unfinished = await submit("unfinished")
+  const keyless = await submit("keyless", "")
+  await crash()
+  upstream = await launch()
+  assert.notEqual(epochs[0].pid, epochs[1].pid, "restart must create a fresh process")
+  await admin("hermes/restart", { owner: "stale" })
+  await poll(completed, "terminal survives real process restart")
+  await poll(unfinished, "unfinished run interrupted after real process restart")
+  await poll(keyless, "keyless run lost after real process restart")
+  await replay(unfinished, "interrupted reservation replay")
+  await setTime(1700000000 + 86400)
+  await replay(completed, "durable TTL equality retains reservation")
+  await setTime(1700000000 + 86400.001)
+  await poll(completed, "GET alone does not prune durable history")
+  const renewed = await submit("renewed", completed.key)
+  assert.notEqual(renewed.real, completed.real)
+  assert.notEqual(renewed.mock, completed.mock)
+  await control({ sweep: true })
+  await admin("hermes/sweep", {})
+  await poll(completed, "pruned and swept result returns ordinary404")
+  await settle(renewed, "completed")
+  const report = {
+    release: lock.release,
+    commit: lock.commit,
+    sources: lock.sources,
+    epochs,
+    comparisons,
+    limitations: [
+      "scripted executor; no inference",
+      "ordinary default test listener; no credential enforcement claim",
+      "routing/session/approval/process-tool integrations substituted; no hosted rooms",
+      "controlled clock and explicit sweep; no background timing claim",
+    ],
+  }
+  await writeFile(resolve(scratch, "report.json"), `${JSON.stringify(report, null, 2)}\n`)
+  console.log(
+    JSON.stringify({ comparisons: comparisons.length, report: resolve(scratch, "report.json") }),
+  )
+} catch (error) {
+  if (upstream) console.error(upstream.stderr())
+  throw error
+} finally {
+  try {
+    if (upstream) await crash()
+  } finally {
+    await mock.close()
+  }
+}

package/oracle/comparison.mjs

@@ -0,0 +1,16 @@
+/** Map only public identity fields and the exact pinned missing-run error template. */
+export const normalizeObservation = (response, ids) => {
+  const body = structuredClone(response.body)
+  for (const field of ["run_id", "session_id"]) {
+    if (typeof body[field] === "string" && ids.has(body[field])) body[field] = ids.get(body[field])
+  }
+  if (response.status === 404 && body.error?.code === "run_not_found") {
+    for (const [id, name] of ids) {
+      if (body.error.message === `Run not found: ${id}`) {
+        body.error.message = `Run not found: ${name}`
+        break
+      }
+    }
+  }
+  return { ...response, body }
+}

package/oracle/comparison.test.mjs

@@ -0,0 +1,41 @@
+import assert from "node:assert/strict"
+import { test } from "node:test"
+import { normalizeObservation } from "./comparison.mjs"
+
+const realIds = new Map([["real-id", "run"]])
+const mockIds = new Map([["mock-id", "run"]])
+const same = (real, mock) =>
+  assert.deepEqual(normalizeObservation(real, realIds), normalizeObservation(mock, mockIds))
+
+test("identity fields map without mutating the response", () => {
+  const real = { status: 200, body: { run_id: "real-id", session_id: "real-id" } }
+  same(real, { status: 200, body: { run_id: "mock-id", session_id: "mock-id" } })
+  assert.equal(real.body.run_id, "real-id")
+})
+test("result and arbitrary error strings retain generated IDs", () => {
+  for (const field of ["output", "error"]) {
+    assert.throws(
+      () =>
+        same(
+          { status: 200, body: { [field]: "result real-id" } },
+          { status: 200, body: { [field]: "result mock-id" } },
+        ),
+      assert.AssertionError,
+    )
+  }
+})
+test("missing-run normalization requires the exact error template", () => {
+  const missing = (message) => ({
+    status: 404,
+    body: { error: { code: "run_not_found", message } },
+  })
+  same(missing("Run not found: real-id"), missing("Run not found: mock-id"))
+  assert.throws(
+    () => same(missing("Run not found: real-id"), missing("Different: mock-id")),
+    assert.AssertionError,
+  )
+  assert.throws(
+    () => same(missing("Run not found: real-id"), missing("Run not found: mock-id suffix")),
+    assert.AssertionError,
+  )
+})

package/oracle/fetch.py

@@ -0,0 +1,29 @@
+"""Explicitly fetch hash-locked source files; never install or execute upstream."""
+import argparse
+import hashlib
+from pathlib import Path
+from urllib.request import urlopen
+from sources import LOCK, verify
+
+parser = argparse.ArgumentParser()
+parser.add_argument("--fetch", action="store_true")
+args = parser.parse_args()
+if not args.fetch:
+    parser.error("pass --fetch to download the pinned source files")
+root = Path(__file__).resolve().parents[4]
+destination = root / ".mockingbird/hermes-evidence/v2026.8.31"
+destination.mkdir(parents=True, exist_ok=True)
+for name, entry in LOCK["sources"].items():
+    path = destination / name
+    if path.exists():
+        data = path.read_bytes()
+    else:
+        url = f"https://raw.githubusercontent.com/NousResearch/hermes-agent/{LOCK['commit']}/{entry['path']}"
+        with urlopen(url, timeout=30) as response:
+            data = response.read()
+    if hashlib.sha256(data).hexdigest() != entry["sha256"]:
+        raise ValueError(f"Pinned source hash mismatch: {name}")
+    if not path.exists():
+        path.write_bytes(data)
+verify(destination)
+print(f"Verified {len(LOCK['sources'])} files at {LOCK['commit']}")

package/oracle/requirements.lock

@@ -0,0 +1,11 @@
+# Versions observed in the passing pinned oracle run.
+aiohappyeyeballs==2.7.1
+aiohttp==3.14.3
+aiosignal==1.4.0
+attrs==26.1.0
+frozenlist==1.8.0
+idna==3.20
+multidict==6.9.1
+propcache==0.5.4
+typing-extensions==4.16.0
+yarl==1.25.1

package/oracle/server.py

@@ -0,0 +1,227 @@
+"""Opt-in loopback oracle: pinned run/store code, scripted non-inference executor."""
+import argparse
+import asyncio
+import contextlib
+import contextvars
+import hmac
+import itertools
+import importlib.metadata
+import json
+import logging
+import os
+import re
+import sqlite3
+import subprocess
+import sys
+import threading
+import time
+import types
+import typing
+from pathlib import Path
+
+from sources import LOCK, definitions, load_module, verify
+
+
+def package(name):
+    module = types.ModuleType(name)
+    module.__path__ = []
+    sys.modules[name] = module
+    return module
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--sources", required=True)
+    parser.add_argument("--state", required=True)
+    parser.add_argument("--time", type=float, required=True)
+    parser.add_argument("--allow-disposable-state", action="store_true")
+    args = parser.parse_args()
+    if not args.allow_disposable_state:
+        parser.error("explicit --allow-disposable-state is required")
+    root = Path(__file__).resolve().parents[4]
+    state = Path(args.state).resolve()
+    state.relative_to(root / ".mockingbird" / "hermes-oracle")
+    if not state.parent.is_dir():
+        parser.error("create a fresh oracle state directory before launch")
+    source = Path(args.sources).resolve()
+    verify(source)
+    if not (3, 11) <= sys.version_info[:2] < (3, 14):
+        parser.error("pinned Hermes requires Python >=3.11,<3.14")
+    import aiohttp
+    from aiohttp import web
+    if aiohttp.__version__ != LOCK["aiohttp"]:
+        parser.error("aiohttp version differs from source-lock.json")
+
+    provenance = {}
+    base = {**{key: value for key, value in vars(typing).items() if not key.startswith("__")}, "asyncio": asyncio, "contextlib": contextlib,
+            "ContextVar": contextvars.ContextVar, "contextmanager": contextlib.contextmanager,
+            "hmac": hmac, "itertools": itertools, "json": json, "logging": logging,
+            "os": os, "re": re, "sqlite3": sqlite3, "subprocess": subprocess,
+            "sys": sys, "threading": threading, "time": time, "Path": Path,
+            "logger": logging.getLogger("oracle"), "web": web}
+    def selected(filename, names, extra=None):
+        namespace = {**base, **(extra or {})}
+        provenance[filename] = definitions(source / filename, names, namespace)
+        return namespace
+    for name in ["agent", "gateway", "tools", "hermes_cli"]:
+        package(name)
+    safety = types.ModuleType("agent.file_safety")
+    safety.__dict__.update(selected("file_safety.py", ["_BLOCKED_PROJECT_ENV_BASENAMES"]))
+    sys.modules[safety.__name__] = safety
+    redactor = load_module(source / "agent_redact.py", "agent.redact")
+    interrupt = load_module(source / "interrupt_compat.py", "agent.interrupt_compat")
+    sqlite_runtime = load_module(source / "sqlite_runtime.py", "hermes_cli.sqlite_runtime")
+    sys.modules[sqlite_runtime.__name__] = sqlite_runtime
+    state_module = types.ModuleType("hermes_state")
+    state_module.__dict__.update(selected("hermes_state.py", ["apply_wal_with_fallback"], {
+        "_is_sqlite_wal_reset_vulnerable": sqlite_runtime.is_sqlite_wal_reset_vulnerable,
+    }))
+    sys.modules["hermes_state"] = state_module
+    status = types.ModuleType("gateway.status")
+    status.__dict__.update(selected("gateway_status.py", ["_pid_exists", "get_process_start_time"]))
+    sys.modules["gateway.status"] = status
+    # Only these execution integration hooks are substituted. They never dispatch
+    # tools, persist sessions, spawn child tools or register real approval work.
+    approval = types.ModuleType("tools.approval")
+    for name in ["register_gateway_notify", "unregister_gateway_notify", "reset_current_session_key", "set_current_session_key"]:
+        setattr(approval, name, lambda *a, **k: None)
+    sys.modules[approval.__name__] = approval
+    session = types.ModuleType("gateway.session_context")
+    session.clear_session_vars = lambda *a: None
+    sys.modules[session.__name__] = session
+    clock = [args.time]
+    controlled_time = types.SimpleNamespace(time=lambda: clock[0])
+    store_module = load_module(source / "api_server_run_idempotency.py", "oracle_store")
+    store_module.time = controlled_time
+    runs = load_module(source / "api_server_runs.py", "oracle_runs")
+    runs.time = controlled_time
+    api = types.SimpleNamespace(**selected("api_server.py", [
+        "_openai_error", "_redact_api_error_text", "_request_agent_overrides",
+        "_approval_event_choices", "_expected_api_key", "_check_auth", "_parse_session_key_header",
+    ], {"redact_sensitive_text": redactor.redact_sensitive_text}))
+    api._api_request_profile = contextvars.ContextVar("oracle_profile", default="default")
+    api._api_request_browser_control_principal = contextvars.ContextVar("oracle_principal", default=None)
+    api._api_request_browser_control_transport_family = contextvars.ContextVar("oracle_transport", default=None)
+    api._ProviderAuthResolutionError = type("UnexercisedProviderAuthError", (Exception,), {})
+    api._publish_turn_process_ownership = lambda *a: None
+    api._clear_turn_process_ownership = lambda *a: None
+    api._reap_disconnected_agent_processes = lambda *a, **k: None
+    api.request_hard_interrupt = interrupt.request_hard_interrupt
+    # Preserve the selected functions' original global context variable binding.
+    for name in ["_expected_api_key", "_check_auth"]:
+        getattr(api, name).__globals__["_api_request_profile"] = api._api_request_profile
+    room = selected("room_grants.py", ["_room_grant_token"])
+
+    class ScriptedAgent:
+        session_prompt_tokens = 0
+        session_completion_tokens = 0
+        session_total_tokens = 0
+        def __init__(self):
+            self.release = threading.Event()
+            self.result = {"final_response": "synthetic output"}
+        def hard_interrupt(self, message=None):
+            # Hold acknowledgement until the fixture selects cancellation or a
+            # completion-winning race; the upstream stop handler owns stopping.
+            self.interrupted = True
+        def run_conversation(self, **kwargs):
+            if not self.release.wait(30):
+                raise TimeoutError("oracle executor was not explicitly settled")
+            return self.result
+
+    class Adapter:
+        _model_name = "hermes-agent"
+        _api_key = ""
+        _MAX_SESSION_HEADER_LEN = 256
+        _RUN_STATUS_TTL = 3600
+        _RUN_STREAM_TTL = 300
+        _room_grant_token = staticmethod(room["_room_grant_token"])
+        _expected_api_key = api._expected_api_key
+        _check_auth = api._check_auth
+        _parse_session_key_header = api._parse_session_key_header
+        def __init__(self):
+            self._background_tasks = set()
+            self._stopping_run_ids = set()
+            self._active_run_agents = {}
+            self._active_run_tasks = {}
+            self._response_store = {}
+            runs._initialize_run_state(self, store_factory=lambda: store_module.RunIdempotencyStore(str(state)))
+        def _make_run_event_callback(self, run_id, loop):
+            return runs._make_run_event_callback(self, run_id, loop, _api_server=api)
+        def _run_idempotency_scope(self, request):
+            return runs._run_idempotency_scope(self, request, _api_server=api)
+        def _check_run_auth(self, request, *, permission):
+            return runs._check_run_auth(self, request, permission=permission, _api_server=api)
+        async def _normalize_room_dispatch(self, request, body):
+            if self._room_grant_token(request) or "hosted_room_dispatch" in body or "_room_execution_policy" in body:
+                raise ValueError("hosted rooms are outside this oracle")
+            return body, None
+        def _resolve_route(self, model):
+            return None
+        def _request_route_conflict_error(self, **kwargs):
+            return None
+        def _concurrency_limited_response(self):
+            return None
+        async def _conversation_history_for_session(self, session):
+            return []
+        def _profile_scope(self, profile):
+            return contextlib.nullcontext()
+        def _bind_api_server_session(self, **kwargs):
+            return []
+        def _activate_admitted_request(self):
+            pass
+        def _create_agent(self, **kwargs):
+            return ScriptedAgent()
+    for name in ["_set_run_status", "_durable_run_status", "_request_owns_run"]:
+        setattr(Adapter, name, getattr(runs, name))
+    adapter = Adapter()
+
+    async def submit(request):
+        error = adapter._check_auth(request)
+        if error is not None:
+            return error
+        return await runs._handle_runs(adapter, request, _api_server=api)
+    async def poll(request):
+        return await runs._handle_get_run(adapter, request, _api_server=api)
+    async def stop(request):
+        return await runs._handle_stop_run(adapter, request, _api_server=api)
+    async def control(request):
+        body = await request.json()
+        if "time" in body:
+            clock[0] = float(body["time"])
+        if body.get("sweep"):
+            runs._sweep_orphaned_runs_once(adapter, clock[0])
+        if "settle" in body:
+            run_id = body["settle"]
+            agent = adapter._active_run_agents[run_id]
+            agent.result = body["result"]
+            agent.release.set()
+            await asyncio.wait_for(asyncio.shield(adapter._active_run_tasks[run_id]), 5)
+        return web.json_response({"ok": True})
+    async def crash(request):
+        # Deliberately omit executor cleanup and SQLite close: next invocation
+        # opens the same disposable database in a genuinely new process.
+        os._exit(0)
+    async def serve():
+        app = web.Application()
+        app.router.add_post("/v1/runs", submit)
+        app.router.add_get("/v1/runs/{run_id}", poll)
+        app.router.add_post("/v1/runs/{run_id}/stop", stop)
+        app.router.add_post("/__oracle/control", control)
+        app.router.add_post("/__oracle/crash", crash)
+        runner = web.AppRunner(app, access_log=None)
+        await runner.setup()
+        site = web.TCPSite(runner, "127.0.0.1", 0)
+        await site.start()
+        port = site._server.sockets[0].getsockname()[1]
+        print(json.dumps({"url": f"http://127.0.0.1:{port}", "commit": LOCK["commit"],
+                          "python": sys.version.split()[0], "aiohttp": aiohttp.__version__,
+                          "sqlite": sqlite3.sqlite_version, "pid": os.getpid(),
+                          "journal_mode": adapter._run_idempotency_store._conn.execute("PRAGMA journal_mode").fetchone()[0],
+                          "dependencies": {name: importlib.metadata.version(name) for name in ["aiohttp", "aiohappyeyeballs", "aiosignal", "attrs", "frozenlist", "idna", "multidict", "propcache", "typing-extensions", "yarl"]},
+                          "definitions": provenance}), flush=True)
+        await asyncio.Event().wait()
+    asyncio.run(serve())
+
+
+if __name__ == "__main__":
+    main()

package/oracle/source-lock.json

@@ -0,0 +1,52 @@
+{
+  "release": "v2026.8.31",
+  "commit": "29112bef099274229cadff79cdff7bf7b99c4b77",
+  "python": ">=3.11,<3.14",
+  "aiohttp": "3.14.3",
+  "sources": {
+    "api_server_runs.py": {
+      "path": "gateway/platforms/api_server_runs.py",
+      "sha256": "048ae843592d701ff47437bd8edd47cd64ca6c0fdf88a71045bdb6fb337fbc63"
+    },
+    "api_server_run_idempotency.py": {
+      "path": "gateway/platforms/api_server_run_idempotency.py",
+      "sha256": "746904b3b6ed45d8359655b2e87c1f101394b13f6253e718ac9a83acd46174f2"
+    },
+    "api_server.py": {
+      "path": "gateway/platforms/api_server.py",
+      "sha256": "6aec6687d47c81b3567e930882a499c5c5c041ecbe40e1d08f93038212401962"
+    },
+    "hermes_state.py": {
+      "path": "hermes_state.py",
+      "sha256": "696fd2d37d66a599228f5b1be5d5b76423b744149c83a2fbd59bf3f45a5f3891"
+    },
+    "sqlite_runtime.py": {
+      "path": "hermes_cli/sqlite_runtime.py",
+      "sha256": "682ae7f6a783673b7687377a37f210f5b1f86f54d227baed95df279bdd561310"
+    },
+    "agent_redact.py": {
+      "path": "agent/redact.py",
+      "sha256": "db98c5b9cf5727abbb471b5009d19d3f8230863869cde207d53c5e5d8d4831f0"
+    },
+    "file_safety.py": {
+      "path": "agent/file_safety.py",
+      "sha256": "f2cb782cda3f091acba507e3af6a31e7326770dfc6b75657cd5adb1006521db9"
+    },
+    "interrupt_compat.py": {
+      "path": "agent/interrupt_compat.py",
+      "sha256": "f10ecfe97b6be6d150c3e41d5d377a9ca845e74d454240f2d6506f753dc23441"
+    },
+    "room_grants.py": {
+      "path": "gateway/platforms/api_server_room_grants.py",
+      "sha256": "d6e51eae92043ed8ab116e4f555db3c100829c93b61d516e31fc239ff90da204"
+    },
+    "gateway_status.py": {
+      "path": "gateway/status.py",
+      "sha256": "c7f2615117643f536f4d678a185dc1f9e6e407daea79e85f351613efac0ecefd"
+    },
+    "pyproject.toml": {
+      "path": "pyproject.toml",
+      "sha256": "c70c8b52f6cc08a4e65f0fc1713c26814fd4f19811bc7e01de645009b2a76600"
+    }
+  }
+}