- `SCV_OBJECTIVE` with a bounded read-only inspection request.

   - `SCV_MODEL` with the admitted model identifier.

   - `SCV_REASONING_EFFORT=low` for the production-code-capable SCV baseline.

   - `SCV_REPOSITORY_REVISION` with the exact committed Git SHA.

   - `SCV_TIMEOUT_MS` and `SCV_HEARTBEAT_INTERVAL_MS` with bounded values.

   - `SCV_DIAGNOSTIC_LOGS=false`.

- one `openagents.scv.worker.result.v1` terminal result.

Verify that the result reports the `opencode` driver, `opencode-core`

environment, `read_only` permission profile, exact source SHA, successful exit

status, bounded duration, resource measurements, event counts, token totals,

and no output truncation. Verify the deployed job uses the dedicated service

account and contains no prohibited environment or secret references.

environment, `openai/gpt-5.6-luna` model, `low` reasoning effort, `read_only`

permission profile, exact source SHA, successful exit status, bounded duration,

resource measurements, event counts, token totals, and no output truncation.

Verify the deployed job uses the dedicated service account and contains no

prohibited environment or secret references.

Treat a successful execution as an environment qualification receipt only. Do

not call it an isolated-staging pass or enable writes. Before an SCV can write,

| `SCV_ENVIRONMENT` | `opencode-core` |

| `SCV_PERMISSION_PROFILE` | `read_only` |

| `SCV_MODEL` | Admitted OpenCode model identifier |

| `SCV_REASONING_EFFORT` | `low` by default; `none` is also admitted |

| `SCV_REPOSITORY_REVISION` | Exact 40-character lowercase Git SHA baked into the image |

| `SCV_RUN_ID` | Optional externally assigned UUID; the worker generates one when omitted |

| `SCV_TIMEOUT_MS` | Wall-clock limit for the OpenCode process |

narrow, low-risk change class. Production autonomy is a later admission, not a

configuration toggle hidden inside the first release.

### Model capability boundary

SCVs use `openai/gpt-5.6-luna` with `low` reasoning by default. You may select

`none` for latency-sensitive, measured workloads. Do not run implementation or

production-code tasks with GPT-5.4. GPT-5.6 is the minimum admitted model family

for code generation by an SCV.

Model capability does not grant infrastructure authority. A code-writing SCV

must still use an isolated workspace, repository-scoped principal, durable

effect records, required tests, and Forge promotion policy before its code can

reach staging or production.

## SCV runtime boundary

Define an SCV as the durable execution and supervision contract. Do not define

lock files into the isolated directory; it never copies OpenCode configuration

or authentication state.

### Proven local run

### GPT-5.6 local qualification receipt

On 2026-08-20, installed OpenCode `1.18.5` ran a read-only SCV against OpenCode

commit `b155b15694dbcc6768f11d2f25cc2bdd1f738ab4` with

`openai/gpt-5.6-luna` and `low` reasoning. The run read `package.json` and

returned the package name and a one-sentence repository description without

changing the checkout.

SCV run `f4955a8b-d0a1-42ad-bc8b-acf4c6cb48b8` succeeded in 5,475

milliseconds. It emitted six normalized events, completed one `read` call,

used 6 input, 59 output, and 11 reasoning tokens, and reported no truncation.

The terminal receipt recorded the exact model and reasoning effort. This run

qualifies the local model-selection and event path. It does not authorize an SCV

to write to a shared repository or deploy code.

### Historical GPT-5.4 read-only run

On 2026-08-20, the adapter ran installed OpenCode `1.18.5` against the inspected

OpenCode `dev` commit `b155b15694dbcc6768f11d2f25cc2bdd1f738ab4` with model

OPENCODE_CONFIG_SEED=/absolute/path/to/trusted/opencode-config \

mix openagents.scv.opencode \

  --repo /absolute/path/to/target \

  --model openai/gpt-5.4-mini \

  --model openai/gpt-5.6-luna \

  --reasoning-effort low \

  --timeout-seconds 180 \

  --diagnostic-logs \

  --prompt 'Inspect the requested files without changing them.' \

    prompt: :string,

    prompt_file: :string,

    model: :string,

    reasoning_effort: :string,

    opencode: :string,

    config_seed: :string,

    output: :string,

        api_key: System.get_env("OPENAI_API_KEY"),

        executable: Keyword.get(options, :opencode, default_executable()),

        config_seed: config_seed(options),

        model: Keyword.get(options, :model, "openai/gpt-5.4-mini"),

        model: Keyword.get(options, :model, "openai/gpt-5.6-luna"),

        reasoning_effort: Keyword.get(options, :reasoning_effort, "low"),

        output_root: output_root,

        timeout_ms: timeout_ms,

        diagnostic_logs: Keyword.get(options, :diagnostic_logs, false),

  alias OpenAgents.SCV.ResourceSampler

  @schema "openagents.scv.opencode.run.v1"

  @default_model "openai/gpt-5.4-mini"

  @default_model "openai/gpt-5.6-luna"

  @default_reasoning_effort "low"

  @reasoning_efforts ~w(none low)

  @default_timeout_ms 5 * 60 * 1_000

  @maximum_timeout_ms 60 * 60 * 1_000

  @default_maximum_output_bytes 16 * 1_024 * 1_024

         :ok <-

           emit_event(input, "run_preparing", %{

             model: input.model,

             reasoning_effort: input.reasoning_effort,

             permission_profile: Atom.to_string(input.permissions)

           }),

         {:ok, paths} <- prepare_paths(input.output_root, input.run_id, input.config_seed) do

  defp validate_input(repository, prompt, options) do

    model = Keyword.get(options, :model, @default_model)

    reasoning_effort = Keyword.get(options, :reasoning_effort, @default_reasoning_effort)

    timeout_ms = Keyword.get(options, :timeout_ms, @default_timeout_ms)

    maximum_output_bytes =

    with {:ok, repository} <- validate_directory(repository),

         :ok <- validate_prompt(prompt),

         :ok <- validate_model(model),

         :ok <- validate_reasoning_effort(reasoning_effort),

         :ok <- validate_integer(timeout_ms, 1, @maximum_timeout_ms, :timeout_invalid),

         :ok <-

           validate_integer(

         prompt: prompt,

         prompt_bytes: byte_size(prompt),

         model: model,

         reasoning_effort: reasoning_effort,

         timeout_ms: timeout_ms,

         maximum_output_bytes: maximum_output_bytes,

         sample_interval_ms: sample_interval_ms,

        adapter: "opencode",

        executable: input.executable,

        model: input.model,

        reasoning_effort: input.reasoning_effort,

        diagnostic_logs: input.diagnostic_logs,

        config_seeded: not is_nil(input.config_seed),

        permission_profile: Atom.to_string(input.permissions),

      "json",

      "--model",

      input.model,

      "--variant",

      input.reasoning_effort,

      "--dir",

      input.repository

    ]

  defp validate_model(_model), do: {:error, :model_invalid}

  defp validate_reasoning_effort(reasoning_effort)

       when reasoning_effort in @reasoning_efforts,

       do: :ok

  defp validate_reasoning_effort(_reasoning_effort), do: {:error, :reasoning_effort_invalid}

  defp validate_integer(value, minimum, maximum, _error)

       when is_integer(value) and value >= minimum and value <= maximum,

       do: :ok

  alias OpenAgents.SCV.OpenCodeReport

  alias OpenAgents.SCV.Run

  @default_model "openai/gpt-5.4-mini"

  @default_model "openai/gpt-5.6-luna"

  @default_reasoning_effort "low"

  @default_timeout_ms 300_000

  @default_output_root "/workspace/runs"

  @maximum_report_chunk_bytes 3_072

           fetch_value(environment, "SCV_ENVIRONMENT", "opencode-core", ["opencode-core"]),

         {:ok, permission_profile} <-

           fetch_value(environment, "SCV_PERMISSION_PROFILE", "read_only", ["read_only"]),

         {:ok, reasoning_effort} <-

           fetch_value(

             environment,

             "SCV_REASONING_EFFORT",

             @default_reasoning_effort,

             ["none", "low"]

           ),

         {:ok, timeout_ms} <-

           fetch_integer(environment, "SCV_TIMEOUT_MS", @default_timeout_ms, 1..3_600_000),

         {:ok, heartbeat_interval_ms} <-

         environment: scv_environment,

         permission_profile: permission_profile,

         model: Map.get(environment, "SCV_MODEL", @default_model),

         reasoning_effort: reasoning_effort,

         output_root: Map.get(environment, "SCV_OUTPUT_ROOT", @default_output_root),

         executable: Map.get(environment, "OPENCODE_BIN"),

         config_seed: optional_value(environment, "OPENCODE_CONFIG_SEED"),

        executable: input.executable,

        config_seed: input.config_seed,

        model: input.model,

        reasoning_effort: input.reasoning_effort,

        output_root: input.output_root,

        timeout_ms: input.timeout_ms,

        heartbeat_interval_ms: input.heartbeat_interval_ms,

      status: result.status,

      driver: result.scv.driver,

      environment: result.scv.environment,

      model: result.runtime.model,

      reasoning_effort: result.runtime.reasoning_effort,

      repository_revision: result.repository.git_sha,

      duration_ms: result.duration_ms,

      event_count: result.events.event_count,

    assert result.status == "succeeded"

    assert result.exit_status == 0

    assert result.runtime.permission_profile == "read_only"

    assert result.runtime.model == "openai/test-model"

    assert result.runtime.reasoning_effort == "low"

    assert result.events.event_count == 4

    assert result.events.diagnostic_line_count == 0

    assert result.events.invalid_event_count == 0

               "prompt",

               Keyword.put(shared_options(context), :api_key, nil)

             )

    assert {:error, :reasoning_effort_invalid} =

             OpenCode.run(

               context.repository,

               "prompt",

               Keyword.put(shared_options(context), :reasoning_effort, "medium")

             )

  end

  defp shared_options(context) do

    prompt=$(cat)

    if [ -z "$prompt" ]; then exit 30; fi

    if [ "$1" != "run" ]; then exit 26; fi

    case " $* " in *" --variant low "*) :;; *) exit 32;; esac

    case " $* " in *" --auto "*) exit 27;; esac

    case " $* " in *" $prompt "*) exit 31;; esac

    if [ "${OPENCODE_CONFIG_DIR:-}" != "${XDG_CONFIG_HOME:-}/opencode" ]; then exit 28; fi

      "SCV_ENVIRONMENT" => "opencode-core",

      "SCV_PERMISSION_PROFILE" => "read_only",

      "SCV_MODEL" => "openai/test-model",

      "SCV_REASONING_EFFORT" => "none",

      "SCV_OUTPUT_ROOT" => context.output,

      "OPENAI_API_KEY" => "fixture-secret-key"

    }

    assert result.status == "succeeded"

    assert result.runtime.permission_profile == "read_only"

    assert result.runtime.reasoning_effort == "none"

    assert_receive {:worker_event, %{type: "process_started", driver: "opencode"}}

    assert {:error, {:environment_value_not_admitted, "SCV_PERMISSION_PROFILE"}} =

    assert {:error, {:environment_missing, "OPENAI_API_KEY"}} =

             Worker.run(Map.delete(environment, "OPENAI_API_KEY"))

    assert {:error, {:environment_value_not_admitted, "SCV_REASONING_EFFORT"}} =

             Worker.run(Map.put(environment, "SCV_REASONING_EFFORT", "medium"))

  end

  test "emits bounded structured report chunks before the terminal result" do

      duration_ms: 100,

      repository: %{git_sha: String.duplicate("a", 40)},

      scv: %{driver: "opencode", environment: "opencode-core"},

      runtime: %{model: "openai/gpt-5.6-luna", reasoning_effort: "low"},

      events: %{event_count: 2, tool_calls: %{}, usage: %{}},

      resources: %{},

      artifacts: %{events_digest: String.duplicate("b", 64)},

    chunks = Enum.drop(events, -1)

    assert terminal.type == "worker_finished"

    assert terminal.model == "openai/gpt-5.6-luna"

    assert terminal.reasoning_effort == "low"

    assert terminal.report.digest == digest

    assert terminal.report.chunk_count == length(chunks)

    refute Map.has_key?(terminal.report, :text)

    if [ "${OPENAI_API_KEY:-}" != "fixture-secret-key" ]; then exit 21; fi

    prompt=$(cat)

    if [ -z "$prompt" ]; then exit 22; fi

    case " $* " in *" --variant low "*|*" --variant none "*) :;; *) exit 23;; esac

    printf '%s\n' '{"type":"step_start","timestamp":1,"sessionID":"ses_scv","part":{"type":"step-start"}}'

    printf '%s\n' '{"type":"step_finish","timestamp":2,"sessionID":"ses_scv","part":{"type":"step-finish","cost":0.001,"tokens":{"input":4,"output":2,"reasoning":1,"cache":{"read":0,"write":0}}}}'

    """