omnilane 0.34.0 → 0.41.1

package/scripts/runners/run-grok-live.py

@@ -0,0 +1,426 @@
+#!/usr/bin/env python3
+"""Long-lived Grok ACP bridge for omnilane's live mailbox."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import pathlib
+import queue
+import select
+import signal
+import subprocess
+import sys
+import threading
+import time
+from typing import Any
+
+
+class ProtocolError(RuntimeError):
+    pass
+
+
+def grok_acp_argv(grok_bin: str, model: str, mode: str) -> list[str]:
+    """Build the only supported ACP mode: explicit unrestricted sysops."""
+    if mode != "sysops":
+        raise ValueError(
+            f"Grok {mode} live is unavailable: ACP has no enforceable restricted-mode policy"
+        )
+    return [
+        grok_bin,
+        "--no-memory",
+        "--no-subagents",
+        "--no-plan",
+        "--verbatim",
+        "--sandbox",
+        "off",
+        "agent",
+        "--always-approve",
+        "--model",
+        model,
+        "stdio",
+    ]
+
+
+class GrokLiveClient:
+    def __init__(self, args: argparse.Namespace) -> None:
+        self.args = args
+        self.process: subprocess.Popen[str] | None = None
+        self.events: Any = None
+        self.inbox: Any = None
+        self.messages: queue.Queue[tuple[str, str | None]] = queue.Queue()
+        self.next_request_id = 1
+        self.active_prompt_request_id: int | None = None
+        self.session_id: str | None = None
+        self.turn_running = False
+        self.last_turn_succeeded = False
+        self.stop_requested = False
+        self.session_close_sent = False
+
+    def request_stop(self, _signum: int, _frame: Any) -> None:
+        self.stop_requested = True
+
+    def start_server(self) -> None:
+        self.process = subprocess.Popen(
+            grok_acp_argv(self.args.grok_bin, self.args.model, self.args.mode),
+            cwd=self.args.cwd,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=None,
+            text=True,
+            bufsize=1,
+            # The outer watchdog owns this process group. Do not split the
+            # ACP agent into a session that survives if this client is
+            # SIGKILLed before its finally block can run.
+            start_new_session=False,
+        )
+        threading.Thread(
+            target=self.read_server, name="grok-acp-agent", daemon=True
+        ).start()
+
+    def read_server(self) -> None:
+        assert self.process is not None and self.process.stdout is not None
+        try:
+            for raw in self.process.stdout:
+                self.messages.put(("message", raw))
+        finally:
+            self.messages.put(("eof", None))
+
+    def write_message(self, message: dict[str, Any]) -> None:
+        assert self.process is not None and self.process.stdin is not None
+        try:
+            self.process.stdin.write(
+                json.dumps(message, ensure_ascii=False, separators=(",", ":")) + "\n"
+            )
+            self.process.stdin.flush()
+        except (BrokenPipeError, OSError) as exc:
+            raise ProtocolError(f"Grok ACP stdin closed: {exc}") from exc
+
+    def send_request(self, method: str, params: dict[str, Any]) -> int:
+        request_id = self.next_request_id
+        self.next_request_id += 1
+        self.write_message(
+            {
+                "jsonrpc": "2.0",
+                "id": request_id,
+                "method": method,
+                "params": params,
+            }
+        )
+        return request_id
+
+    def send_notification(self, method: str, params: dict[str, Any]) -> None:
+        # session/cancel must be an ACP notification. Adding an id changes it
+        # into a request, which Grok rejects with -32601 Method not found.
+        self.write_message({"jsonrpc": "2.0", "method": method, "params": params})
+
+    def record_event(self, raw: str) -> dict[str, Any] | None:
+        assert self.events is not None
+        self.events.write(raw if raw.endswith("\n") else raw + "\n")
+        self.events.flush()
+        try:
+            message = json.loads(raw)
+        except json.JSONDecodeError:
+            return None
+        if not isinstance(message, dict):
+            return None
+
+        if (
+            self.active_prompt_request_id is not None
+            and message.get("id") == self.active_prompt_request_id
+        ):
+            if "error" in message:
+                error = message.get("error")
+                if isinstance(error, dict):
+                    detail = (
+                        f"code={error.get('code')!r} "
+                        f"message={error.get('message')!r}"
+                    )
+                else:
+                    detail = repr(error)
+                self.active_prompt_request_id = None
+                self.turn_running = False
+                self.last_turn_succeeded = False
+                raise ProtocolError(
+                    f"Grok ACP rejected session/prompt: {detail}"
+                )
+            self.active_prompt_request_id = None
+
+        if message.get("method") == "session/update":
+            params = message.get("params")
+            update = params.get("update") if isinstance(params, dict) else None
+            if isinstance(update, dict):
+                update_type = update.get("sessionUpdate")
+                if update_type == "agent_message_chunk":
+                    content = update.get("content")
+                    text = content.get("text") if isinstance(content, dict) else None
+                    if isinstance(text, str):
+                        self.append_agent_text(text)
+                # agent_thought_chunk is private reasoning and is deliberately
+                # journaled only; it must never reach OUTPUT_FILE.
+
+        if message.get("method") == "_x.ai/session/prompt_complete":
+            params = message.get("params")
+            stop_reason = params.get("stopReason") if isinstance(params, dict) else None
+            self.active_prompt_request_id = None
+            self.turn_running = False
+            self.last_turn_succeeded = stop_reason == "end_turn"
+
+        return message
+
+    def append_agent_text(self, text: str) -> None:
+        with open(self.args.output, "a", encoding="utf-8") as output:
+            output.write(text)
+            output.flush()
+            os.fsync(output.fileno())
+
+    def receive(self, timeout: float) -> dict[str, Any] | None:
+        try:
+            kind, raw = self.messages.get(timeout=timeout)
+        except queue.Empty:
+            return None
+        if kind == "eof":
+            raise ProtocolError("Grok ACP stdout closed")
+        assert raw is not None
+        return self.record_event(raw)
+
+    def wait_response(self, request_id: int, method: str) -> dict[str, Any]:
+        deadline = time.monotonic() + self.args.rpc_timeout
+        while not self.stop_requested and time.monotonic() < deadline:
+            message = self.receive(min(0.2, max(0.0, deadline - time.monotonic())))
+            if message is None or message.get("id") != request_id:
+                continue
+            result = message.get("result")
+            if not isinstance(result, dict):
+                error = message.get("error")
+                raise ProtocolError(f"Grok ACP rejected {method}: {error!r}")
+            return result
+        raise ProtocolError(f"Grok ACP timed out waiting for {method}")
+
+    def initialize(self) -> None:
+        request_id = self.send_request(
+            "initialize",
+            {
+                "protocolVersion": 1,
+                "clientCapabilities": {
+                    "fs": {"readTextFile": False, "writeTextFile": False}
+                },
+            },
+        )
+        self.wait_response(request_id, "initialize")
+
+        request_id = self.send_request(
+            "session/new", {"cwd": self.args.cwd, "mcpServers": []}
+        )
+        result = self.wait_response(request_id, "session/new")
+        session_id = result.get("sessionId")
+        if not isinstance(session_id, str) or not session_id:
+            raise ProtocolError("Grok session/new response omitted sessionId")
+        self.session_id = session_id
+        self.record_session_id(session_id)
+
+        # The verified ACP surface has no permission-mode or model-selection
+        # field equivalent to single-shot --permission-mode/--model. Do not
+        # invent one. run-grok.sh keeps its single-shot mapping unchanged.
+        print(
+            "omnilane: Grok ACP live exposes no permission-mode field; "
+            f"MODE={self.args.mode} uses the ACP default. jobs.sh send cancels "
+            "an active Grok turn before starting the new prompt; conversation "
+            "context survives, but in-progress work is lost.",
+            file=sys.stderr,
+        )
+
+    def record_session_id(self, session_id: str) -> None:
+        session_path = pathlib.Path(self.args.session_id_file)
+        session_path.write_text(session_id + "\n", encoding="utf-8")
+        session_path.chmod(0o600)
+        progress = {
+            "event": "session.started",
+            "session_id": session_id,
+            "vendor": "grok",
+        }
+        pathlib.Path(self.args.progress).write_text(
+            json.dumps(progress, ensure_ascii=False, separators=(",", ":")) + "\n",
+            encoding="utf-8",
+        )
+
+    def decode_mailbox(self, raw: str) -> str:
+        try:
+            payload = json.loads(raw)
+        except json.JSONDecodeError as exc:
+            raise ProtocolError("Grok mailbox line is not JSON") from exc
+        if not isinstance(payload, dict) or payload.get("type") != "grok-user":
+            raise ProtocolError("Grok mailbox line has the wrong type")
+        text = payload.get("text")
+        if not isinstance(text, str):
+            raise ProtocolError("Grok mailbox line omitted text")
+        return text
+
+    def start_prompt(self, text: str) -> None:
+        assert self.session_id is not None
+        self.active_prompt_request_id = self.send_request(
+            "session/prompt",
+            {
+                "sessionId": self.session_id,
+                "prompt": [{"type": "text", "text": text}],
+            },
+        )
+        self.turn_running = True
+        self.last_turn_succeeded = False
+
+    def cancel_active_turn(self) -> None:
+        assert self.session_id is not None
+        if not self.turn_running:
+            return
+        self.send_notification("session/cancel", {"sessionId": self.session_id})
+        # A cancelled request may answer late after the replacement prompt has
+        # started. Only an error for the current active request is fatal.
+        self.active_prompt_request_id = None
+        deadline = time.monotonic() + self.args.rpc_timeout
+        while self.turn_running and not self.stop_requested:
+            if time.monotonic() >= deadline:
+                raise ProtocolError("Grok ACP timed out waiting for cancelled turn")
+            self.receive(min(0.1, max(0.0, deadline - time.monotonic())))
+
+    def close_session(self, deadline: float) -> None:
+        if self.session_id is None or self.session_close_sent:
+            return
+        if self.turn_running:
+            self.send_notification("session/cancel", {"sessionId": self.session_id})
+            while self.turn_running and time.monotonic() < deadline:
+                self.receive(min(0.1, max(0.0, deadline - time.monotonic())))
+        request_id = self.send_request("session/close", {"sessionId": self.session_id})
+        self.session_close_sent = True
+        while time.monotonic() < deadline:
+            try:
+                message = self.receive(
+                    min(0.1, max(0.0, deadline - time.monotonic()))
+                )
+            except ProtocolError:
+                if self.process is not None and self.process.poll() is not None:
+                    return
+                raise
+            if message is not None and message.get("id") == request_id:
+                if "error" in message:
+                    raise ProtocolError(
+                        f"Grok ACP rejected session/close: {message['error']!r}"
+                    )
+                return
+
+    def drain_server_messages(self) -> None:
+        while True:
+            try:
+                kind, raw = self.messages.get_nowait()
+            except queue.Empty:
+                return
+            if kind == "eof":
+                raise ProtocolError("Grok ACP stdout closed")
+            assert raw is not None
+            self.record_event(raw)
+
+    def run_mailbox(self) -> None:
+        self.inbox = open(self.args.inbox, "r", encoding="utf-8")
+        while not self.stop_requested:
+            self.drain_server_messages()
+            if self.process is not None and self.process.poll() is not None:
+                raise ProtocolError(f"Grok ACP exited with {self.process.returncode}")
+
+            readable, _, _ = select.select([self.inbox], [], [], 0.1)
+            if not readable:
+                continue
+            raw = self.inbox.readline()
+            if raw == "":
+                # Coupled to job-worker.sh's 50 * 0.1s outer grace. The entire
+                # ACP cancel/close grace plus close()'s one-second TERM wait
+                # must expire before the worker escalates at five seconds.
+                self.close_session(time.monotonic() + self.args.close_grace)
+                return
+
+            text = self.decode_mailbox(raw)
+            if self.turn_running:
+                self.cancel_active_turn()
+            self.start_prompt(text)
+
+    def close(self) -> None:
+        if self.inbox is not None:
+            self.inbox.close()
+        if self.process is None:
+            return
+
+        if self.process.poll() is None and self.session_id is not None:
+            try:
+                self.close_session(time.monotonic() + min(0.2, self.args.close_grace))
+            except (ProtocolError, OSError):
+                pass
+        if self.process.stdin is not None:
+            try:
+                self.process.stdin.close()
+            except OSError:
+                pass
+        if self.process.poll() is None:
+            try:
+                self.process.terminate()
+                self.process.wait(timeout=1)
+            except (OSError, subprocess.TimeoutExpired):
+                try:
+                    self.process.kill()
+                except OSError:
+                    pass
+                self.process.wait()
+        if self.process.stdout is not None:
+            self.process.stdout.close()
+
+    def run(self) -> int:
+        pathlib.Path(self.args.output).write_text("", encoding="utf-8")
+        pathlib.Path(self.args.progress).write_text("", encoding="utf-8")
+        self.events = open(self.args.events, "a", encoding="utf-8", buffering=1)
+        try:
+            self.start_server()
+            self.initialize()
+            self.run_mailbox()
+            return 0 if self.last_turn_succeeded else 1
+        except ProtocolError as exc:
+            print(f"omnilane: {exc}", file=sys.stderr)
+            return 1
+        finally:
+            self.close()
+            self.events.close()
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--grok-bin", required=True)
+    parser.add_argument("--cwd", required=True)
+    parser.add_argument("--model", required=True)
+    parser.add_argument("--mode", choices=("advise", "work", "sysops"), required=True)
+    parser.add_argument("--inbox", required=True)
+    parser.add_argument("--events", required=True)
+    parser.add_argument("--output", required=True)
+    parser.add_argument("--progress", required=True)
+    parser.add_argument("--session-id-file", required=True)
+    parser.add_argument("--rpc-timeout", type=float, default=10.0)
+    # Coupled to job-worker.sh's 50 * 0.1s outer grace: leave time for the
+    # one-second ACP process TERM wait before the worker escalates.
+    parser.add_argument("--close-grace", type=float, default=3.0)
+    return parser.parse_args()
+
+
+def main() -> int:
+    args = parse_args()
+    if args.mode != "sysops":
+        print(
+            f"omnilane: Grok {args.mode} live is unavailable because ACP exposes no "
+            "enforceable restricted-mode policy",
+            file=sys.stderr,
+        )
+        return 2
+    client = GrokLiveClient(args)
+    signal.signal(signal.SIGTERM, client.request_stop)
+    signal.signal(signal.SIGHUP, client.request_stop)
+    signal.signal(signal.SIGINT, client.request_stop)
+    return client.run()
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/scripts/runners/run-grok.sh

@@ -37,13 +37,120 @@ unset XAI_API_KEY 2>/dev/null || true
 
 truncate_payload "$PROMPT_FILE" 140000
 
+MODE_ARGS=()
+case "$MODE" in
+  advise)
+    # Native tool allowlisting plus deny rules form the read-only boundary.
+    # Keep Bash visible so a requested mutation produces an actual policy
+    # denial rather than mere model avoidance; deny wins over allow. Avoid the
+    # filesystem sandbox here because it rejects a legitimate symlinked user
+    # hooks root before provider startup.
+    MODE_ARGS=(
+      --permission-mode dontAsk
+      # Hosted search uses strict internal IDs, unlike client-tool aliases.
+      # Keep permission-rule class names below separate from tool selection.
+      --tools 'Bash,Read,Glob,Grep,web_search,web_fetch'
+      --allow Read --allow Glob --allow Grep --allow WebSearch --allow WebFetch
+      --deny Bash --deny Edit --deny MCPTool
+    )
+    ;;
+  work)
+    # Grok child-network restriction is Linux-only. macOS work therefore
+    # fails before provider startup instead of silently weakening policy.
+    if [[ "$(uname -s)" == "Darwin" ]]; then
+      echo "omnilane: Grok work requires enforced agent-tool network isolation; Grok sandbox network isolation is unavailable on macOS (use explicit --mode sysops or another work-capable vendor)" >&2
+      exit 2
+    fi
+    MODE_ARGS=(--permission-mode acceptEdits --sandbox strict --disable-web-search)
+    ;;
+  sysops)
+    MODE_ARGS=(--always-approve --sandbox off)
+    ;;
+  *)
+    echo "omnilane: invalid Grok mode '$MODE'" >&2
+    exit 2
+    ;;
+esac
+
+LIVE_INBOX="${OMNILANE_INBOX:-}"
+if [[ "$MODE" != "sysops" && -n "$LIVE_INBOX" ]]; then
+  echo "omnilane: Grok $MODE live is unavailable because ACP exposes no enforceable restricted-mode policy; use single-shot $MODE or explicit --mode sysops" >&2
+  exit 2
+fi
+if [[ -n "$LIVE_INBOX" && -p "$LIVE_INBOX" ]]; then
+  EVENTS_FILE="${OUTPUT_FILE}.events.jsonl"
+  STDERR_FILE="${OUTPUT_FILE}.stderr.log"
+  PROGRESS_FILE="${OUTPUT_FILE}.progress.log"
+  SESSION_ID_FILE="${OUTPUT_FILE}.session-id"
+  GROK_LIVE_RUNNER="$(dirname "${BASH_SOURCE[0]}")/run-grok-live.py"
+
+  for path in "$EVENTS_FILE" "$STDERR_FILE" "$PROGRESS_FILE" "$SESSION_ID_FILE"; do
+    if [[ -L "$path" || ( -e "$path" && ! -f "$path" ) ]]; then
+      echo "omnilane: unsafe Grok live artifact path" >&2
+      exit 125
+    fi
+  done
+  command -v python3 >/dev/null 2>&1 || {
+    echo "omnilane: Grok live mode requires python3" >&2
+    exit 127
+  }
+  [[ -f "$GROK_LIVE_RUNNER" ]] || {
+    echo "omnilane: Grok live runner missing" >&2
+    exit 127
+  }
+  (umask 077; : > "$EVENTS_FILE"; : > "$STDERR_FILE")
+
+  set +e
+  (
+    cd "$WORKDIR" || exit 127
+    run_with_timeout "$RUN_TIMEOUT" env -u XAI_API_KEY \
+      OMNILANE_DEPTH=1 \
+      python3 "$GROK_LIVE_RUNNER" \
+        --grok-bin "$GROK_BIN" \
+        --cwd "$WORKDIR" \
+        --model "$MODEL" \
+        --mode "$MODE" \
+        --inbox "$LIVE_INBOX" \
+        --events "$EVENTS_FILE" \
+        --output "$OUTPUT_FILE" \
+        --progress "$PROGRESS_FILE" \
+        --session-id-file "$SESSION_ID_FILE" \
+        2> "$STDERR_FILE"
+  )
+  RC=$?
+  set -e
+  [[ -s "$STDERR_FILE" ]] || rm "$STDERR_FILE" 2>/dev/null || true
+  exit "$RC"
+fi
+
+# Advise denies MCPTool, so another session's live context-mode MCP is not
+# available to this agent. Give its readiness hook a private job scope instead
+# of letting the hook redirect native WebFetch to an inaccessible MCP tool.
+# This does not disable hooks: their security decisions still run normally.
+if [[ "$MODE" == "advise" ]]; then
+  if [[ -n "${CONTEXT_MODE_MCP_SENTINEL_DIR:-}" ]]; then
+    echo "omnilane: Grok advise needs its own MCP readiness scope; conflicting CONTEXT_MODE_MCP_SENTINEL_DIR was left unchanged" >&2
+    exit 2
+  fi
+  GROK_MCP_READINESS_DIR="$(umask 077; mktemp -d "${TMPDIR:-/tmp}/omnilane-grok-mcp.XXXXXX")" || {
+    echo "omnilane: could not create private Grok MCP readiness scope" >&2
+    exit 125
+  }
+  export CONTEXT_MODE_MCP_SENTINEL_DIR="$GROK_MCP_READINESS_DIR"
+  # Remove only our empty leaf. Never remove foreign markers or a live server's
+  # newly created state if a future Grok version starts an MCP there.
+  trap 'rmdir "$GROK_MCP_READINESS_DIR" 2>/dev/null || echo "omnilane: retained nonempty Grok MCP readiness scope: $GROK_MCP_READINESS_DIR" >&2' EXIT
+fi
+
 ARGS=(--cwd "$WORKDIR" --model "$MODEL"
-  --no-memory --no-subagents --no-plan --no-alt-screen
-  --output-format plain --verbatim --prompt-file "$PROMPT_FILE")
-ARGS+=("${THREAD_ARGS[@]}")
-[[ "$MODE" == "advise" ]] && ARGS+=(--permission-mode plan)
-# Web/X search stays ON by default — it is this vendor's signature lane.
-[[ "${OMNILANE_GROK_NO_WEB:-0}" == "1" ]] && ARGS+=(--disable-web-search)
+      --no-memory --no-subagents --no-plan --no-alt-screen
+      --output-format plain --verbatim --prompt-file "$PROMPT_FILE")
+[[ ${#THREAD_ARGS[@]} -eq 0 ]] || ARGS+=("${THREAD_ARGS[@]}")
+ARGS+=("${MODE_ARGS[@]}")
+# Web/X search stays ON by default for advise and sysops.
+if [[ "$MODE" != "work" && "${OMNILANE_GROK_NO_WEB:-0}" == "1" ]]; then
+  ARGS+=(--disable-web-search)
+fi
 
 # Grok intermittently emits empty output on large inputs; retry until it speaks.
 RC=0; attempt=1

package/scripts/runners/run-vote.sh

@@ -30,9 +30,9 @@ trap cleanup_temp_files EXIT
 
 voter_spec() { # vendor -> "model<TAB>effort"
   case "$1" in
-    codex)  printf 'gpt-5.6-sol\thigh' ;;
-    claude) printf 'claude-fable-5-1\thigh' ;;
-    gemini) printf 'Gemini 3.7 Flash (High)\t-' ;;
+    codex)  printf 'gpt-6-astra\txhigh' ;;
+    claude) printf 'claude-fable-5-1\txhigh' ;;
+    gemini) printf 'gemini-3.8-flash-medium\t-' ;;
     grok)   printf 'grok-4.6\t-' ;;
     *)      return 1 ;;
   esac