omnilane 0.34.0 → 0.41.1

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

@@ -0,0 +1,462 @@
+#!/usr/bin/env python3
+"""Long-lived Codex app-server 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 codex_app_server_argv(codex_bin: str, sandbox: str) -> list[str]:
+    """Pin every mode-relevant control before app-server starts."""
+    config = ['approval_policy="never"', f'sandbox_mode="{sandbox}"']
+    if sandbox == "workspace-write":
+        config.extend(
+            [
+                'web_search="disabled"',
+                "sandbox_workspace_write.network_access=false",
+                "sandbox_workspace_write.exclude_slash_tmp=true",
+                "sandbox_workspace_write.exclude_tmpdir_env_var=true",
+                "sandbox_workspace_write.writable_roots=[]",
+            ]
+        )
+    elif sandbox in {"read-only", "danger-full-access"}:
+        config.append('web_search="live"')
+    else:
+        raise ValueError(f"unsupported Codex sandbox: {sandbox}")
+
+    argv = [codex_bin]
+    for value in config:
+        argv.extend(["-c", value])
+    argv.append("app-server")
+    return argv
+
+
+class CodexLiveClient:
+    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.thread_id: str | None = None
+        self.turn_id: str | None = None
+        self.last_turn_succeeded = False
+        self.stop_requested = False
+        self.server_stdout_eof = threading.Event()
+
+    def request_stop(self, _signum: int, _frame: Any) -> None:
+        self.stop_requested = True
+
+    def start_server(self) -> None:
+        self.process = subprocess.Popen(
+            codex_app_server_argv(self.args.codex_bin, getattr(self.args, "sandbox", "workspace-write")),
+            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
+            # app-server 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="codex-app-server", 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.server_stdout_eof.set()
+            self.messages.put(("eof", None))
+
+    def send(self, method: str, params: dict[str, Any]) -> int:
+        assert self.process is not None and self.process.stdin is not None
+        request_id = self.next_request_id
+        self.next_request_id += 1
+        request = {
+            "jsonrpc": "2.0",
+            "id": request_id,
+            "method": method,
+            "params": params,
+        }
+        try:
+            self.process.stdin.write(json.dumps(request, ensure_ascii=False, separators=(",", ":")) + "\n")
+            self.process.stdin.flush()
+        except (BrokenPipeError, OSError) as exc:
+            raise ProtocolError(f"Codex app-server stdin closed during {method}") from exc
+        return request_id
+
+    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 message.get("method") == "item/completed":
+            params = message.get("params")
+            item = params.get("item") if isinstance(params, dict) else None
+            if isinstance(item, dict) and item.get("type") == "agentMessage":
+                text = item.get("text")
+                if isinstance(text, str):
+                    self.append_agent_text(text)
+
+        if message.get("method") == "turn/completed":
+            params = message.get("params")
+            turn = params.get("turn") if isinstance(params, dict) else None
+            if isinstance(turn, dict) and turn.get("id") == self.turn_id:
+                self.last_turn_succeeded = turn.get("status") == "completed" and turn.get("error") is None
+                self.turn_id = None
+        return message
+
+    def append_agent_text(self, text: str) -> None:
+        with open(self.args.output, "a", encoding="utf-8") as output:
+            output.write(text)
+            if not text.endswith("\n"):
+                output.write("\n")
+            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("Codex app-server 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"Codex app-server rejected {method}: {error!r}")
+            return result
+        raise ProtocolError(f"Codex app-server timed out during {method}")
+
+    def initialize(self) -> None:
+        request_id = self.send(
+            "initialize",
+            {"clientInfo": {"name": "omnilane", "version": self.args.version}},
+        )
+        self.wait_response(request_id, "initialize")
+
+        params: dict[str, Any] = {
+            "cwd": self.args.cwd,
+            "model": self.args.model,
+            "sandbox": self.args.sandbox,
+        }
+        request_id = self.send("thread/start", params)
+        result = self.wait_response(request_id, "thread/start")
+        thread = result.get("thread")
+        thread_id = thread.get("id") if isinstance(thread, dict) else None
+        if not isinstance(thread_id, str) or not thread_id:
+            raise ProtocolError("Codex thread/start response omitted thread.id")
+        self.thread_id = thread_id
+        self.record_thread_id(thread_id)
+
+    def record_thread_id(self, thread_id: str) -> None:
+        session_path = pathlib.Path(self.args.session_id_file)
+        session_path.write_text(thread_id + "\n", encoding="utf-8")
+        session_path.chmod(0o600)
+        progress = {
+            "type": "thread.started",
+            "thread_id": thread_id,
+        }
+        pathlib.Path(self.args.progress).write_text(
+            json.dumps(progress, separators=(",", ":")) + "\n",
+            encoding="utf-8",
+        )
+
+    @staticmethod
+    def decode_mailbox(raw: str) -> str:
+        try:
+            payload = json.loads(raw)
+        except json.JSONDecodeError as exc:
+            raise ProtocolError("Codex live mailbox received invalid JSON") from exc
+        if not isinstance(payload, dict) or payload.get("type") != "codex-user":
+            raise ProtocolError("Codex live mailbox received an invalid payload type")
+        text = payload.get("text")
+        if not isinstance(text, str):
+            raise ProtocolError("Codex live mailbox payload omitted text")
+        return text
+
+    def start_turn(self, text: str) -> None:
+        assert self.thread_id is not None
+        params: dict[str, Any] = {
+            "threadId": self.thread_id,
+            "input": [{"type": "text", "text": text}],
+        }
+        if self.args.effort and self.args.effort != "-":
+            params["effort"] = self.args.effort
+        request_id = self.send("turn/start", params)
+        result = self.wait_response(request_id, "turn/start")
+        turn = result.get("turn")
+        turn_id = turn.get("id") if isinstance(turn, dict) else None
+        if not isinstance(turn_id, str) or not turn_id:
+            raise ProtocolError("Codex turn/start response omitted turn.id")
+        self.turn_id = turn_id
+        self.last_turn_succeeded = False
+
+    def steer_turn(self, text: str) -> None:
+        assert self.thread_id is not None and self.turn_id is not None
+        expected_turn_id = self.turn_id
+        params = {
+            "threadId": self.thread_id,
+            "expectedTurnId": expected_turn_id,
+            "input": [{"type": "text", "text": text}],
+        }
+        request_id = self.send("turn/steer", params)
+        result = self.wait_response(request_id, "turn/steer")
+        returned_turn_id = result.get("turnId")
+        if returned_turn_id != expected_turn_id:
+            raise ProtocolError("Codex turn/steer response changed the active turn id")
+
+    def run_mailbox(self) -> None:
+        self.inbox = open(self.args.inbox, "r", encoding="utf-8")
+        eof_deadline: float | None = None
+        while not self.stop_requested:
+            while True:
+                try:
+                    kind, raw = self.messages.get_nowait()
+                except queue.Empty:
+                    break
+                if kind == "eof":
+                    raise ProtocolError("Codex app-server stdout closed")
+                assert raw is not None
+                self.record_event(raw)
+
+            if eof_deadline is not None:
+                if self.turn_id is None:
+                    return
+                if time.monotonic() >= eof_deadline:
+                    raise ProtocolError("Codex turn did not finish before live close deadline")
+                self.receive(0.1)
+                continue
+
+            ready, _, _ = select.select([self.inbox], [], [], 0.1)
+            if not ready:
+                if self.process is not None and self.process.poll() is not None:
+                    raise ProtocolError(f"Codex app-server exited {self.process.returncode}")
+                continue
+            raw = self.inbox.readline()
+            if raw == "":
+                eof_deadline = time.monotonic() + self.args.close_grace
+                continue
+            text = self.decode_mailbox(raw)
+            if self.turn_id is None:
+                self.start_turn(text)
+            else:
+                self.steer_turn(text)
+
+    @staticmethod
+    def process_identity(pid: int) -> str | None:
+        """Return a stable start-time identity so a recycled PID is never signalled."""
+        try:
+            result = subprocess.run(
+                ["ps", "-o", "state=,lstart=", "-p", str(pid)],
+                text=True,
+                capture_output=True,
+                check=False,
+                timeout=1,
+            )
+        except (OSError, subprocess.TimeoutExpired):
+            return None
+        value = result.stdout.strip()
+        if result.returncode != 0 or not value:
+            return None
+        state, _, identity = value.partition(" ")
+        if state.startswith("Z") or not identity.strip():
+            return None
+        return " ".join(identity.split())
+
+    @classmethod
+    def snapshot_descendants(cls, root_pid: int) -> dict[int, str]:
+        """Snapshot descendants before app-server EOF can reparent its helpers."""
+        try:
+            result = subprocess.run(
+                ["ps", "-axo", "pid=,ppid=,lstart="],
+                text=True,
+                capture_output=True,
+                check=False,
+                timeout=1,
+            )
+        except (OSError, subprocess.TimeoutExpired):
+            return {}
+        if result.returncode != 0:
+            return {}
+        children: dict[int, list[int]] = {}
+        identities: dict[int, str] = {}
+        for line in result.stdout.splitlines():
+            parts = line.split(None, 7)
+            if len(parts) < 7:
+                continue
+            try:
+                pid, ppid = int(parts[0]), int(parts[1])
+            except ValueError:
+                continue
+            children.setdefault(ppid, []).append(pid)
+            identities[pid] = " ".join(parts[2:7])
+        found: dict[int, str] = {}
+        pending = [root_pid]
+        while pending:
+            parent = pending.pop()
+            for pid in children.get(parent, []):
+                if pid in found:
+                    continue
+                identity = identities.get(pid)
+                if identity:
+                    found[pid] = identity
+                pending.append(pid)
+        return found
+
+    @classmethod
+    def terminate_tracked_descendants(cls, tracked: dict[int, str]) -> None:
+        """Reap app-server helpers that remain after their parent exits."""
+        alive: list[int] = []
+        for pid, identity in tracked.items():
+            if cls.process_identity(pid) != identity:
+                continue
+            try:
+                os.kill(pid, signal.SIGTERM)
+                alive.append(pid)
+            except (ProcessLookupError, PermissionError):
+                pass
+        if alive:
+            time.sleep(0.05)
+        survivors: list[int] = []
+        for pid in alive:
+            identity = tracked[pid]
+            if cls.process_identity(pid) != identity:
+                continue
+            try:
+                os.kill(pid, signal.SIGKILL)
+                survivors.append(pid)
+            except (ProcessLookupError, PermissionError):
+                pass
+        if survivors:
+            # Give init a bounded chance to reap detached grandchildren.
+            time.sleep(0.05)
+
+    def wait_for_server_exit(self, timeout: float) -> bool:
+        assert self.process is not None
+        try:
+            self.process.wait(timeout=timeout)
+            return True
+        except subprocess.TimeoutExpired:
+            return False
+
+    def close(self) -> None:
+        if self.inbox is not None:
+            self.inbox.close()
+        if self.process is None:
+            return
+        tracked_descendants = self.snapshot_descendants(self.process.pid)
+        if self.process.stdin is not None:
+            try:
+                self.process.stdin.close()
+            except OSError:
+                pass
+        if self.process.poll() is None and not self.wait_for_server_exit(
+            self.args.app_server_eof_grace
+        ):
+            try:
+                self.process.terminate()
+            except OSError:
+                pass
+            if self.process.poll() is None and not self.wait_for_server_exit(
+                self.args.app_server_term_grace
+            ):
+                try:
+                    self.process.kill()
+                except OSError:
+                    pass
+                if self.process.poll() is None:
+                    self.wait_for_server_exit(self.args.app_server_kill_grace)
+        # The reader thread owns stdout. A sidecar may inherit that pipe even
+        # after app-server exits, so closing it here can block on the reader's
+        # file-object lock and defeat the bounded shutdown contract.
+        if self.process.stdout is not None and self.server_stdout_eof.is_set():
+            self.process.stdout.close()
+        self.terminate_tracked_descendants(tracked_descendants)
+
+    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("--codex-bin", required=True)
+    parser.add_argument("--cwd", required=True)
+    parser.add_argument("--model", required=True)
+    parser.add_argument("--effort", required=True)
+    parser.add_argument("--sandbox", 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("--version", default="0.41.1")
+    parser.add_argument("--rpc-timeout", type=float, default=10.0)
+    # Coupled to job-worker.sh's 100 * 0.1s outer grace. The default turn,
+    # EOF, TERM, and KILL waits total seven seconds below that boundary.
+    parser.add_argument("--close-grace", type=float, default=3.0)
+    parser.add_argument("--app-server-eof-grace", type=float, default=2.0)
+    parser.add_argument("--app-server-term-grace", type=float, default=1.0)
+    parser.add_argument("--app-server-kill-grace", type=float, default=1.0)
+    return parser.parse_args()
+
+
+def main() -> int:
+    args = parse_args()
+    client = CodexLiveClient(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-codex.sh

@@ -38,19 +38,78 @@ else
   ARGS=(exec --json -m "$MODEL" -o "${OUTPUT_FILE}.tmp" --skip-git-repo-check)
 fi
 [[ -n "$EFFORT" && "$EFFORT" != "-" ]] && ARGS+=(-c "model_reasoning_effort=\"$EFFORT\"")
+ARGS+=(-c 'approval_policy="never"')
 if [[ "$MODE" == "advise" ]]; then
   [[ -z "$THREAD_MODE" ]] && ARGS+=(--ephemeral)
   SANDBOX=read-only
+  ARGS+=(-c 'web_search="live"')
 elif [[ "$MODE" == "sysops" ]]; then
   SANDBOX=danger-full-access
+  ARGS+=(-c 'web_search="live"')
 else
   SANDBOX=workspace-write
+  ARGS+=(
+    -c 'web_search="disabled"'
+    -c 'sandbox_workspace_write.network_access=false'
+    -c 'sandbox_workspace_write.exclude_slash_tmp=true'
+    -c 'sandbox_workspace_write.exclude_tmpdir_env_var=true'
+    -c 'sandbox_workspace_write.writable_roots=[]'
+  )
+fi
+ARGS+=(-c "sandbox_mode=\"$SANDBOX\"")
+
+LIVE_INBOX="${OMNILANE_INBOX:-}"
+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"
+  CODEX_LIVE_RUNNER="$(dirname "${BASH_SOURCE[0]}")/run-codex-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 Codex live artifact path" >&2
+      exit 125
+    fi
+  done
+  command -v python3 >/dev/null 2>&1 || {
+    echo "omnilane: Codex live mode requires python3" >&2
+    exit 127
+  }
+  [[ -f "$CODEX_LIVE_RUNNER" ]] || {
+    echo "omnilane: Codex live runner is missing" >&2
+    exit 127
+  }
+  truncate_payload "$PROMPT_FILE" 140000
+  (umask 077; : > "$EVENTS_FILE"; : > "$STDERR_FILE")
+
+  set +e
+  (
+    cd "$WORKDIR" || exit 127
+    run_with_timeout "$RUN_TIMEOUT" env \
+      -u OPENAI_API_KEY -u OPENAI_ORG_ID -u OPENAI_ORGANIZATION -u OPENAI_PROJECT -u OPENAI_API_BASE \
+      OMNILANE_DEPTH=1 \
+      python3 "$CODEX_LIVE_RUNNER" \
+        --codex-bin "$CODEX_BIN" \
+        --cwd "$WORKDIR" \
+        --model "$MODEL" \
+        --effort "$EFFORT" \
+        --sandbox "$SANDBOX" \
+        --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
 # `codex exec resume` has no -s/--sandbox flag (rejects it with exit 2); the
 # same policy is only reachable there through the sandbox_mode config override.
-if [[ "$THREAD_MODE" == "resume" ]]; then
-  ARGS+=(-c "sandbox_mode=\"$SANDBOX\"")
-else
+if [[ "$THREAD_MODE" != "resume" ]]; then
   ARGS+=(-s "$SANDBOX")
 fi
 [[ "$THREAD_MODE" == "resume" ]] && ARGS+=("$THREAD_ID" -)

package/scripts/runners/run-gemini.sh

@@ -31,6 +31,58 @@ fi
 
 truncate_payload "$PROMPT_FILE" 140000
 
+WORKDIR="$(cd -- "$WORKDIR" && pwd -P)" || {
+  echo "omnilane: Gemini workdir is not accessible" >&2
+  exit 2
+}
+
+# agy 1.1.27 loads per-run CLI settings from the hidden app_data_dir
+# interface while leaving GeminiDir (and subscription auth) unchanged. Keep
+# one stable root for a named thread; anonymous jobs use their output path.
+AGY_PREPARE="$OMNILANE_REPO/scripts/lib/prepare-agy-mode.py"
+[[ -f "$AGY_PREPARE" ]] || {
+  echo "omnilane: Gemini mode policy helper missing" >&2
+  exit 127
+}
+if [[ -n "${OMNILANE_THREAD_NAME:-}" ]]; then
+  AGY_APP_KEY="thread-v1-${MODE}-$(printf '%s' "$OMNILANE_THREAD_NAME" | hash_str)"
+else
+  AGY_APP_KEY="job-v1-${MODE}-$(printf '%s' "$OUTPUT_FILE" | hash_str)"
+fi
+AGY_APP_ROOT="$OMNILANE_HOME/agy-app/$AGY_APP_KEY"
+AGY_APP_DATA_REL="$(python3 "$AGY_PREPARE" \
+  --mode "$MODE" --workdir "$WORKDIR" --app-root "$AGY_APP_ROOT" \
+  --gemini-dir "$HOME/.gemini")" || {
+  echo "omnilane: Gemini isolated mode settings could not be prepared" >&2
+  exit 2
+}
+APP_DATA_ARGS=("--app_data_dir=$AGY_APP_DATA_REL")
+AGY_WORK_ENV=()
+if [[ "$MODE" == "work" ]]; then
+  agy_cleanup_workspace_policy() {
+    local previous_rc=$?
+    trap - EXIT
+    if ! python3 "$AGY_PREPARE" --cleanup --mode "$MODE" --workdir "$WORKDIR" \
+        --app-root "$AGY_APP_ROOT" --gemini-dir "$HOME/.gemini"; then
+      echo "omnilane: agy workspace policy cleanup/integrity check failed; inspect owned leaf" >&2
+      [[ "$previous_rc" -ne 0 ]] || previous_rc=125
+    fi
+    exit "$previous_rc"
+  }
+  trap agy_cleanup_workspace_policy EXIT
+  AGY_WORK_META="$(python3 - "$AGY_APP_ROOT/workspace-agent.json" <<'PY'
+import json, pathlib, sys
+state = json.loads(pathlib.Path(sys.argv[1]).read_text())
+print(state["agent"])
+print(state["cache"])
+PY
+  )"
+  AGY_AGENT_NAME="${AGY_WORK_META%%$'\n'*}"
+  AGY_CACHE_ROOT="${AGY_WORK_META#*$'\n'}"
+  AGY_WORK_ENV=("TMPDIR=$AGY_CACHE_ROOT/tmp" "XDG_CACHE_HOME=$AGY_CACHE_ROOT/cache"
+    "CLANG_MODULE_CACHE_PATH=$AGY_CACHE_ROOT/clang" "SWIFT_MODULECACHE_PATH=$AGY_CACHE_ROOT/swift")
+fi
+
 # Both modes run inside the target WORKDIR so the worker can actually see the
 # repo it is asked about. Tradeoff: repo-level agent personas may color advise
 # answers; set OMNILANE_GEMINI_SCRATCH=1 to run advise in a neutral scratch dir.
@@ -44,9 +96,26 @@ fi
 MODEL_ARGS=()
 [[ -n "$MODEL" && "$MODEL" != "-" ]] && MODEL_ARGS=(--model "$MODEL")
 
-# Without an execution mode, print mode denies tool calls outright:
-# plan = read-only tools (advise), accept-edits = file edits allowed (work).
-if [[ "$MODE" == "advise" ]]; then MODE_ARGS=(--mode plan); else MODE_ARGS=(--mode accept-edits); fi
+MODE_ARGS=()
+case "$MODE" in
+  advise)
+    # A private per-job settings file carries the permission policy; --sandbox
+    # supplies the native terminal sandbox for restricted modes.
+    MODE_ARGS=(--sandbox)
+    ;;
+  work)
+    MODE_ARGS=(--sandbox --agent "$AGY_AGENT_NAME")
+    ;;
+  sysops)
+    # Explicit opt-in: bypass approval prompts. The private settings file also
+    # selects always-proceed and disables the terminal sandbox for this job.
+    MODE_ARGS=(--mode accept-edits --dangerously-skip-permissions)
+    ;;
+  *)
+    echo "omnilane: invalid Gemini mode (advise|work|sysops)" >&2
+    exit 2
+    ;;
+esac
 
 LIVE_INBOX="${OMNILANE_INBOX:-}"
 if [[ -n "$LIVE_INBOX" && -p "$LIVE_INBOX" ]]; then
@@ -129,8 +198,8 @@ PY
     cd "$RUN_DIR" || exit 127
     run_with_timeout "$RUN_TIMEOUT" env \
       -u GEMINI_API_KEY -u GOOGLE_API_KEY -u GOOGLE_AI_API_KEY \
-      NO_BROWSER=1 OMNILANE_DEPTH=1 \
-      "$AGY_BIN" --dangerously-skip-permissions --add-dir "$RUN_DIR" \
+      NO_BROWSER=1 OMNILANE_DEPTH=1 ${AGY_WORK_ENV[@]+"${AGY_WORK_ENV[@]}"} \
+      "$AGY_BIN" "${APP_DATA_ARGS[@]}" --add-dir "$RUN_DIR" \
       "${MODE_ARGS[@]}" ${MODEL_ARGS[@]+"${MODEL_ARGS[@]}"} \
       --input-format stream-json --output-format stream-json -p "" \
       < "$LIVE_INBOX" > "$EVENTS_FILE" 2> "$STDERR_FILE"
@@ -162,11 +231,11 @@ if [[ -n "$THREAD_MODE" ]]; then
   (
     cd "$RUN_DIR" || exit 127
     env -u GEMINI_API_KEY -u GOOGLE_API_KEY -u GOOGLE_AI_API_KEY \
-      NO_BROWSER=1 OMNILANE_DEPTH=1 \
-      "$AGY_BIN" --dangerously-skip-permissions --add-dir "$RUN_DIR" \
+      NO_BROWSER=1 OMNILANE_DEPTH=1 ${AGY_WORK_ENV[@]+"${AGY_WORK_ENV[@]}"} \
+      "$AGY_BIN" "${APP_DATA_ARGS[@]}" --add-dir "$RUN_DIR" \
       "${MODE_ARGS[@]}" ${MODEL_ARGS[@]+"${MODEL_ARGS[@]}"} \
       --print-timeout "${RUN_TIMEOUT}s" --output-format json \
-      "${THREAD_ARGS[@]}" -p "$(cat "$PROMPT_FILE")" \
+      ${THREAD_ARGS[@]+"${THREAD_ARGS[@]}"} -p "$(cat "$PROMPT_FILE")" \
       > "${OUTPUT_FILE}.result.json" 2> "${OUTPUT_FILE}.stderr.log"
   )
   RC=$?
@@ -196,8 +265,8 @@ set +e
   # --add-dir registers RUN_DIR as the active workspace; without it agy's
   # sandbox denies every tool call (run_command/view_file) in print mode.
   env -u GEMINI_API_KEY -u GOOGLE_API_KEY -u GOOGLE_AI_API_KEY \
-    NO_BROWSER=1 OMNILANE_DEPTH=1 \
-    "$AGY_BIN" --dangerously-skip-permissions --add-dir "$RUN_DIR" \
+    NO_BROWSER=1 OMNILANE_DEPTH=1 ${AGY_WORK_ENV[@]+"${AGY_WORK_ENV[@]}"} \
+    "$AGY_BIN" "${APP_DATA_ARGS[@]}" --add-dir "$RUN_DIR" \
     "${MODE_ARGS[@]}" ${MODEL_ARGS[@]+"${MODEL_ARGS[@]}"} \
     --print-timeout "${RUN_TIMEOUT}s" \
     --print "$(cat "$PROMPT_FILE")" \
@@ -207,6 +276,12 @@ RC=$?
 set -e
 fi
 
+
+if [[ "$RC" -eq 0 && -f "${OUTPUT_FILE}.tmp" && ! -s "${OUTPUT_FILE}.tmp" ]]; then
+  echo "omnilane: Gemini completed without a readable response" >> "${OUTPUT_FILE}.stderr.log"
+  RC=1
+fi
+
 if grep -Eiq "$CAPACITY_PATTERN" "${OUTPUT_FILE}.tmp" "${OUTPUT_FILE}.result.json" "${OUTPUT_FILE}.stderr.log" 2>/dev/null; then
   echo "omnilane: gemini capacity exhausted" >> "${OUTPUT_FILE}.stderr.log"
   RC=126