meridian-cli 0.3.2__tar.gz → 0.3.4__tar.gz

{meridian_cli-0.3.2 → meridian_cli-0.3.4}/.gitignore

@@ -17,6 +17,7 @@ smoke/
 tmp/
 .tmp-*/
 plan/
+temp/
 
 .orchestrate/
 .scratch/

{meridian_cli-0.3.2 → meridian_cli-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meridian-cli
-Version: 0.3.2
+Version: 0.3.4
 Summary: Orchestrate CLI + MCP server for multi-model agent workflows
 Project-URL: Homepage, https://github.com/haowjy/meridian-cli
 Project-URL: Repository, https://github.com/haowjy/meridian-cli
@@ -54,18 +54,6 @@ Orchestrate AI coding agents across Claude Code, Codex, and OpenCode. Each model
 
 > **Early development.** Meridian is not stable. Expect breaking changes in any release. If you need a stable workflow, this project is not ready for you yet.
 
-## v0.1.0 Migration
-
-v0.1.0 removes all legacy state format support in the state layer.
-
-If you are upgrading from any pre-0.1.0 build, run:
-
-```bash
-rm -rf ~/.meridian
-```
-
-This is a clean break. There is no automatic migration.
-
 ## Why
 
 Claude Code is (supposed to be) the best way to run Claude. Codex CLI is often the best way to run GPT. Each provider's harness is optimized for their models — sandboxing, tool use, context handling, everything (supposedly).

{meridian_cli-0.3.2 → meridian_cli-0.3.4}/README.md

@@ -4,18 +4,6 @@ Orchestrate AI coding agents across Claude Code, Codex, and OpenCode. Each model
 
 > **Early development.** Meridian is not stable. Expect breaking changes in any release. If you need a stable workflow, this project is not ready for you yet.
 
-## v0.1.0 Migration
-
-v0.1.0 removes all legacy state format support in the state layer.
-
-If you are upgrading from any pre-0.1.0 build, run:
-
-```bash
-rm -rf ~/.meridian
-```
-
-This is a clean break. There is no automatic migration.
-
 ## Why
 
 Claude Code is (supposed to be) the best way to run Claude. Codex CLI is often the best way to run GPT. Each provider's harness is optimized for their models — sandboxing, tool use, context handling, everything (supposedly).

{meridian_cli-0.3.2 → meridian_cli-0.3.4}/src/meridian/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.3.2"
+__version__ = "0.3.4"

{meridian_cli-0.3.2 → meridian_cli-0.3.4}/src/meridian/cli/spawn.py

@@ -185,6 +185,7 @@ def _shared_launch_input_kwargs(
     debug: bool,
     task_ping_interval: str | None,
     task_ping_reset_on_activity: bool | None,
+    env: tuple[str, ...],
 ) -> SpawnLaunchOptionUpdates:
     return {
         "dry_run": dry_run,
@@ -204,6 +205,7 @@ def _shared_launch_input_kwargs(
         "debug": debug,
         "task_ping_interval": task_ping_interval,
         "task_ping_reset_on_activity": task_ping_reset_on_activity,
+        "env": env,
     }
 
 
@@ -454,6 +456,18 @@ def _spawn_create(
             show=False,
         ),
     ] = False,
+    env: Annotated[
+        tuple[str, ...],
+        Parameter(
+            name="--env",
+            help=(
+                "Environment variables for the spawned harness "
+                "in KEY=VALUE form (repeatable). "
+                "Overrides config-level [env] defaults."
+            ),
+            negative_iterable=(),
+        ),
+    ] = (),
 ) -> None:
     # Passthrough lives on GlobalOptions, not a function parameter — see
     # _split_passthrough_args() for why cyclopts can't handle ``--`` correctly.
@@ -500,6 +514,7 @@ def _spawn_create(
         task_ping_interval=task_ping_interval,
         task_ping_reset_on_activity=task_ping_reset_on_activity,
         debug=debug,
+        env=env,
     )
     resolved_prompt = _resolve_spawn_prompt(
         prompt,

{meridian_cli-0.3.2 → meridian_cli-0.3.4}/src/meridian/lib/config/settings.py

@@ -428,6 +428,23 @@ def _normalize_harness_table(
     return values
 
 
+def _normalize_env_table(raw_value: object, *, source: str) -> dict[str, str]:
+    if not isinstance(raw_value, dict):
+        raise ValueError(f"Invalid value for '{source}': expected table.")
+    values: dict[str, str] = {}
+    for raw_key, raw_val in cast("dict[str, object]", raw_value).items():
+        key = str(raw_key).strip()
+        if not key:
+            raise ValueError(f"Invalid value for '{source}': expected non-empty key.")
+        if not isinstance(raw_val, str):
+            raise ValueError(
+                f"Invalid value for '{source}.{key}': expected string, got "
+                f"{type(raw_val).__name__} ({raw_val!r})."
+            )
+        values[key] = raw_val
+    return values
+
+
 def _normalize_spawn_table(raw_value: object, *, source: str) -> dict[str, object]:
     if not isinstance(raw_value, dict):
         raise ValueError(f"Invalid value for '{source}': expected table.")
@@ -766,6 +783,19 @@ DYNAMIC_SECTION_DESCRIPTORS: dict[str, DynamicSectionDescriptor] = {
             "",
         ),
     ),
+    "env": DynamicSectionDescriptor(
+        section_key="env",
+        merge_kind="nested_dict",
+        scaffold_lines=(
+            "# -- Environment variables passed to spawned harnesses -----------------------",
+            "# Flat key-value string map. Applied to every spawn from this project.",
+            "# Keys from meridian.local.toml override meridian.toml; project overrides user.",
+            "",
+            "# [env]",
+            '# OPENCODE_ENABLE_EXA = "1"',
+            "",
+        ),
+    ),
 }
 
 
@@ -791,6 +821,8 @@ def normalize_dynamic_sections(
                 source=section_key,
                 project_root=project_root,
             )
+        elif section_key == "env":
+            value = _normalize_env_table(raw_value, source=section_key)
         else:
             continue
         if descriptor.merge_kind != "external" and value is not None:
@@ -862,6 +894,9 @@ def _normalize_toml_payload(
                 _normalize_spawn_table(raw_value, source="spawn"),
             )
             continue
+        if key == "env":
+            normalized["env"] = _normalize_env_table(raw_value, source="env")
+            continue
         if key in DYNAMIC_SECTION_DESCRIPTORS:
             normalized = merge_dynamic_sections(
                 normalized,
@@ -1404,6 +1439,7 @@ class MeridianConfig(BaseSettings):
     output: OutputConfig = Field(default_factory=OutputConfig)
     state: StateConfig = Field(default_factory=StateConfig)
     work: WorkConfig = Field(default_factory=WorkConfig)
+    env: dict[str, str] = Field(default_factory=dict)
 
     @field_validator("default_wait_yield_seconds", "min_wait_yield_seconds")
     @classmethod

{meridian_cli-0.3.2 → meridian_cli-0.3.4}/src/meridian/lib/core/child_env.py

@@ -31,7 +31,7 @@ def validate_child_env_keys(overrides: Mapping[str, str]) -> None:
     :data:`ALLOWED_CHILD_ENV_KEYS`.
     """
     for key in overrides:
-        if not key.startswith("MERIDIAN_"):
+        if not key.upper().startswith("MERIDIAN_"):
             continue
         if key in ALLOWED_CHILD_ENV_KEYS:
             continue

{meridian_cli-0.3.2 → meridian_cli-0.3.4}/src/meridian/lib/core/launch_policy_snapshot.py

@@ -25,6 +25,7 @@ class LaunchPolicySnapshot(BaseModel):
     skill_paths: tuple[str, ...] = ()
     loaded_skills: tuple[SkillContent, ...] = ()
     extra_args: tuple[str, ...] = ()
+    env: dict[str, str] = Field(default_factory=dict)
     execution_policy: ResolvedExecutionPolicy = Field(default_factory=ResolvedExecutionPolicy)
     tools: ToolsField | None = None
     mcp_tools: tuple[str, ...] = ()

{meridian_cli-0.3.2 → meridian_cli-0.3.4}/src/meridian/lib/core/spawn_service.py

@@ -76,6 +76,20 @@ _MAX_REAP_PASSES = 4
 logger = structlog.get_logger()
 
 
+def _config_snapshot_env(config_snapshot: dict[str, object]) -> dict[str, str]:
+    env = config_snapshot.get("env")
+    if isinstance(env, dict):
+        result: dict[str, str] = {}
+        for k, v in cast("dict[str, object]", env).items():
+            if not k.strip():
+                continue
+            if not isinstance(v, str):
+                continue
+            result[k] = v
+        return result
+    return {}
+
+
 def _resolve_explicit_timeout_seconds(resolved_request: object) -> float | None:
     """Extract explicit timeout seconds from resolved request-like objects."""
 
@@ -360,6 +374,9 @@ class SpawnApplicationService:
             project_paths=project_paths,
             spawn_id=str(final_spawn_id),
         )
+        config_env = _config_snapshot_env(payload.runtime.config_snapshot)
+        request_env = dict(prepared_surface.request.env)
+        resolved_env = {**config_env, **request_env}
         launch_ctx = await asyncio.to_thread(
             bind_spawn_launch_context,
             prepared=prepared_surface,
@@ -368,6 +385,7 @@ class SpawnApplicationService:
                 report_output_path=report_output_path,
                 runtime_work_id=effective_work_id,
                 dry_run=False,
+                plan_overrides=resolved_env,
             ),
             runtime=payload.runtime,
             harness_registry=payload.harness_registry,

{meridian_cli-0.3.2 → meridian_cli-0.3.4}/src/meridian/lib/harness/connections/.context/CONTEXT.md

@@ -45,12 +45,16 @@ Required abstract methods — every subclass must implement all of these:
 - `harness_id`, `spawn_id`, `capabilities` properties
 - `session_id` → `str | None` (None until the transport delivers a session identifier)
 - `subprocess_pid` → `int | None`
+- `resident_backend` → `ResidentBackendControl | None`; Codex/OpenCode expose
+  this for resident-until-done structured liveness and follow-up turns;
+  non-resident transports return None. This is the only public resident control
+  seam — callers do not reach for adapter-specific backend objects.
+- `scope_snapshot` → `ProcessScopeSnapshot | None`; managed backends expose the
+  process-scope facts captured at launch so primary attach and cleanup paths do
+  not reconstruct containment from PID fields.
 - `start(config, spec)` → async; raises if already started
 - `stop()` → async; idempotent
 - `health()` → bool
-- `resident_backend` → `ResidentBackendControl | None`; Codex/OpenCode expose
-  this for resident-until-done structured liveness and follow-up turns;
-  non-resident transports return None.
 - `send_user_message(text)` → async
 - `send_cancel()` → async
 - `events()` → `AsyncIterator[HarnessEvent]`
@@ -61,9 +65,6 @@ supports the capability:
 - `start_observer(config, spec)` — observer mode; guard with `capabilities.supports_primary_observer`
 - `configure_primary_runtime_requests(policy, event_sink, request_handler)`
 - `inject_runtime_event(event)`
-- `inject_turn(message)` — compatibility wrapper that delegates to
-  `resident_backend.begin_followup_turn`; transports should implement follow-up
-  turns through the resident backend seam instead of overriding this directly.
 - `respond_request(request_id, decision, payload)` — Codex only
 - `respond_user_input(request_id, answers)` — Codex only
 

{meridian_cli-0.3.2 → meridian_cli-0.3.4}/src/meridian/lib/harness/connections/AGENTS.md

@@ -11,12 +11,13 @@ Each transport wraps a long-lived process and turns its output into a stream of
 `HarnessEvent` objects consumed by the drain loop. The drain loop calls
 `terminal_outcome(event)` on each event; when that returns non-None, it breaks.
 
-Three transports exist, each different at the wire level:
+Transports differ at the wire level:
 - **Claude** (`claude_ws.py`): stdin/stdout NDJSON. No WebSocket despite the filename.
-- **Codex** (`codex_ws.py`): real WebSocket to `codex app-server`, JSON-RPC 2.0.
+- **Codex** (`codex_ws.py`): real WebSocket to a managed `codex app-server`, JSON-RPC 2.0.
   Codex's `requestApproval` and `requestUserInput` messages are dispatched to
   either `AutoAcceptHandler` (spawn paths) or `InteractiveHandler` (managed-primary attach).
-- **OpenCode** (`opencode_http.py`): HTTP+SSE to `opencode serve`.
+- **OpenCode** (`opencode_http.py`): HTTP+SSE to managed `opencode serve`.
+- **Cursor/Pi**: narrower spawned-session transports; no resident backend seam.
 
 ## Key Rules
 
@@ -31,6 +32,14 @@ distinction.
 implement all abstract methods, register in the bundle. Missing registration →
 `KeyError` at lookup time.
 
+**Resident control goes through `resident_backend`.** Do not add connection-level
+turn-injection or managed-backend shims. Codex/OpenCode return a
+`ResidentBackendControl`; callers use `begin_followup_turn()` through that seam.
+
+**Managed backend liveness belongs to `BackendLivenessPolicy`.** Adapters feed it
+activity, active turns, active requests, backend pid, and birth time; callers consume
+its structured decisions instead of inventing per-adapter alive checks.
+
 ## Entry Points
 
 - `base.py` — `HarnessConnection` ABC, `HarnessEvent`, `ConnectionCapabilities`,
@@ -39,6 +48,11 @@ implement all abstract methods, register in the bundle. Missing registration →
   `ResidentDrainCoordinator` for structured liveness, awaiting-done signaling,
   and follow-up turns. This seam's presence, not the harness id, selects the
   resident drain coordinator.
+- `liveness.py` — `BackendLivenessPolicy`, the shared managed-backend liveness
+  classifier for Codex/OpenCode.
+- `managed_backend.py` — single helper for launching managed backend subprocesses,
+  building `ProcessScopeSnapshot`, linking parent-death behavior when possible,
+  and recording `process_scopes.json`.
 - `__init__.py` — `get_connection_class(harness_id, transport_id)`.
 
 ## Depth

{meridian_cli-0.3.2 → meridian_cli-0.3.4}/src/meridian/lib/harness/projections/project_pi_native_tui.py

@@ -52,6 +52,7 @@ _DELEGATED_FIELDS: frozenset[str] = frozenset(
 
 _MANAGED_FLAG_ALIASES: dict[str, tuple[str, ...]] = {
     "--model": ("--model", "-m"),
+    "--thinking": ("--thinking",),
     "--append-system-prompt": ("--append-system-prompt",),
     "--session": ("--session",),
     "--fork": ("--fork",),
@@ -148,12 +149,13 @@ def _project_model_arg(spec: ResolvedLaunchSpec) -> str | None:
     if not model:
         return None
 
-    thinking = _EFFORT_TO_THINKING.get((spec.effort or "").strip().lower())
-    if thinking:
-        return f"{model}:{thinking}"
     return model
 
 
+def _project_thinking_level(spec: ResolvedLaunchSpec) -> str | None:
+    return _EFFORT_TO_THINKING.get((spec.effort or "").strip().lower())
+
+
 def project_pi_native_tui_spec_to_cli_args(
     spec: ResolvedLaunchSpec,
     *,
@@ -162,19 +164,26 @@ def project_pi_native_tui_spec_to_cli_args(
     """Project one ``ResolvedLaunchSpec`` into an ordered native Pi TUI command list."""
 
     command: list[str] = list(base_command)
+    passthrough_tail = spec.extra_args
 
     model_arg = _project_model_arg(spec)
     if model_arg is not None:
         command.extend(("--model", model_arg))
 
+    thinking_level = _project_thinking_level(spec)
+    model_override_in_passthrough = any(
+        _has_flag(passthrough_tail, alias) for alias in _MANAGED_FLAG_ALIASES["--model"]
+    )
+    emit_thinking = thinking_level is not None and not model_override_in_passthrough
+    if emit_thinking and thinking_level is not None:
+        command.extend(("--thinking", thinking_level))
+
     if spec.appended_system_prompt:
         command.extend(("--append-system-prompt", spec.appended_system_prompt))
 
     continue_session_id = (spec.continue_session_id or "").strip()
     has_continue_session = bool(continue_session_id)
     has_continue_fork = has_continue_session and spec.continue_fork
-
-    passthrough_tail = spec.extra_args
     _reject_mode_collisions(passthrough_tail)
     _reject_continue_collisions(passthrough_tail)
     _reject_extension_collisions(passthrough_tail)
@@ -184,6 +193,11 @@ def project_pi_native_tui_spec_to_cli_args(
         has_managed_value=model_arg is not None,
         passthrough_tail=passthrough_tail,
     )
+    _log_collision_if_needed(
+        managed_flag="--thinking",
+        has_managed_value=emit_thinking,
+        passthrough_tail=passthrough_tail,
+    )
     _log_collision_if_needed(
         managed_flag="--append-system-prompt",
         has_managed_value=bool(spec.appended_system_prompt),

{meridian_cli-0.3.2 → meridian_cli-0.3.4}/src/meridian/lib/harness/projections/project_pi_rpc.py

@@ -53,6 +53,7 @@ _DELEGATED_FIELDS: frozenset[str] = frozenset(
 
 _MANAGED_FLAG_ALIASES: dict[str, tuple[str, ...]] = {
     "--model": ("--model", "-m"),
+    "--thinking": ("--thinking",),
     "--append-system-prompt": ("--append-system-prompt",),
     "--session": ("--session",),
     "--fork": ("--fork",),
@@ -143,12 +144,13 @@ def _project_model_arg(spec: ResolvedLaunchSpec) -> str | None:
     if not model:
         return None
 
-    thinking = _EFFORT_TO_THINKING.get((spec.effort or "").strip().lower())
-    if thinking:
-        return f"{model}:{thinking}"
     return model
 
 
+def _project_thinking_level(spec: ResolvedLaunchSpec) -> str | None:
+    return _EFFORT_TO_THINKING.get((spec.effort or "").strip().lower())
+
+
 def _default_pi_session_dir() -> str:
     return str(resolve_pi_spawn_session_root())
 
@@ -161,19 +163,26 @@ def project_pi_spec_to_cli_args(
     """Project one ``ResolvedLaunchSpec`` into an ordered Pi RPC command list."""
 
     command: list[str] = list(base_command)
+    passthrough_tail = spec.extra_args
 
     model_arg = _project_model_arg(spec)
     if model_arg is not None:
         command.extend(("--model", model_arg))
 
+    thinking_level = _project_thinking_level(spec)
+    model_override_in_passthrough = any(
+        _has_flag(passthrough_tail, alias) for alias in _MANAGED_FLAG_ALIASES["--model"]
+    )
+    emit_thinking = thinking_level is not None and not model_override_in_passthrough
+    if emit_thinking and thinking_level is not None:
+        command.extend(("--thinking", thinking_level))
+
     if spec.appended_system_prompt:
         command.extend(("--append-system-prompt", spec.appended_system_prompt))
 
     continue_session_id = (spec.continue_session_id or "").strip()
     has_continue_session = bool(continue_session_id)
     has_continue_fork = has_continue_session and spec.continue_fork
-
-    passthrough_tail = spec.extra_args
     _reject_mode_collisions(passthrough_tail)
     _reject_extension_collisions(passthrough_tail)
     _reject_session_dir_collisions(passthrough_tail)
@@ -183,6 +192,11 @@ def project_pi_spec_to_cli_args(
         has_managed_value=model_arg is not None,
         passthrough_tail=passthrough_tail,
     )
+    _log_collision_if_needed(
+        managed_flag="--thinking",
+        has_managed_value=emit_thinking,
+        passthrough_tail=passthrough_tail,
+    )
     _log_collision_if_needed(
         managed_flag="--append-system-prompt",
         has_managed_value=bool(spec.appended_system_prompt),

{meridian_cli-0.3.2 → meridian_cli-0.3.4}/src/meridian/lib/launch/env.py

@@ -178,10 +178,10 @@ def merge_env_overrides(
     """
     forbidden: list[tuple[str, str]] = []
     for key in plan_overrides:
-        if key.startswith("MERIDIAN_"):
+        if key.upper().startswith("MERIDIAN_"):
             forbidden.append((key, "plan_overrides"))
     for key in preflight_overrides:
-        if key.startswith("MERIDIAN_"):
+        if key.upper().startswith("MERIDIAN_"):
             forbidden.append((key, "preflight_overrides"))
 
     if forbidden:

{meridian_cli-0.3.2 → meridian_cli-0.3.4}/src/meridian/lib/launch/policy_snapshot.py

@@ -95,6 +95,7 @@ def build_launch_policy_snapshot(
         tools=request.tools,
         mcp_tools=request.mcp_tools,
         extra_args=request.extra_args,
+        env=request.env,
         model_selection_requested_token=request.model_selection_requested_token,
         model_selection_selected_token=(
             model_selection.selected_model_token

{meridian_cli-0.3.2 → meridian_cli-0.3.4}/src/meridian/lib/launch/process/runner.py

@@ -990,6 +990,11 @@ def run_harness_process(
                     }
                 )
                 plan_overrides: dict[str, str] = {}
+                config_env = runtime.config_snapshot.get("env")
+                if isinstance(config_env, dict):
+                    for k, v in cast("dict[str, str]", config_env).items():
+                        if k.strip():
+                            plan_overrides[k] = v
                 if runtime_request.execution_policy.autocompact is not None:
                     plan_overrides["CLAUDE_AUTOCOMPACT_PCT_OVERRIDE"] = str(
                         runtime_request.execution_policy.autocompact

{meridian_cli-0.3.2 → meridian_cli-0.3.4}/src/meridian/lib/launch/request.py

@@ -90,6 +90,7 @@ class SpawnRequest(BaseModel):
     extra_args: tuple[str, ...] = ()
     mcp_tools: tuple[str, ...] = ()
     tools: ToolsField | None = None
+    env: dict[str, str] = Field(default_factory=dict)
 
     # Execution policy carrier (replaces flat effort/sandbox/approval/autocompact/autocompact_pct)
     execution_policy: ResolvedExecutionPolicy = Field(default_factory=ResolvedExecutionPolicy)

{meridian_cli-0.3.2 → meridian_cli-0.3.4}/src/meridian/lib/ops/config.py

@@ -500,6 +500,29 @@ def _dynamic_value_source(
     return "builtin"
 
 
+def _resolve_env_config_source(
+    *,
+    env_key: str,
+    project_dynamic_overrides: dict[str, object],
+    user_dynamic_overrides: dict[str, object],
+) -> Literal["file", "user-config", "builtin"]:
+    project_env = project_dynamic_overrides.get("env")
+    if isinstance(project_env, dict) and env_key in project_env:
+        return "file"
+    user_env = user_dynamic_overrides.get("env")
+    if isinstance(user_env, dict) and env_key in user_env:
+        return "user-config"
+    return "builtin"
+
+
+_SECRET_ENV_KEY_SUFFIXES = ("_TOKEN", "_KEY", "_SECRET")
+
+
+def _looks_like_secret_env_key(key: str) -> bool:
+    normalized = key.upper()
+    return any(normalized.endswith(suffix) for suffix in _SECRET_ENV_KEY_SUFFIXES)
+
+
 def _dynamic_config_values(inspection: _ConfigInspectionState) -> list[ConfigResolvedValue]:
     values: list[ConfigResolvedValue] = []
     resolved = inspection.resolved_dynamic_overrides
@@ -569,6 +592,24 @@ def _dynamic_config_values(inspection: _ConfigInspectionState) -> list[ConfigRes
                 )
             )
 
+    env_config = inspection.surface.resolved_config.env
+    if env_config:
+        for env_key, env_value in sorted(env_config.items()):
+            display_value: object = env_value
+            if _looks_like_secret_env_key(env_key):
+                display_value = "[redacted]"
+            values.append(
+                ConfigResolvedValue(
+                    key=f"env.{env_key}",
+                    value=display_value,
+                    source=_resolve_env_config_source(
+                        env_key=env_key,
+                        project_dynamic_overrides=inspection.project_dynamic_overrides,
+                        user_dynamic_overrides=inspection.user_dynamic_overrides,
+                    ),
+                )
+            )
+
     return values
 
 

{meridian_cli-0.3.2 → meridian_cli-0.3.4}/src/meridian/lib/ops/spawn/api.py

@@ -1868,6 +1868,8 @@ def _reject_continue_policy_overrides(payload: SpawnContinueInput) -> None:
         rejected.append("--autocompact-pct")
     if payload.passthrough_args:
         rejected.append("--")
+    if payload.env:
+        rejected.append("--env")
     if payload.work.strip():
         rejected.append("--work")
     if payload.task_dir is not None and payload.task_dir.strip():

{meridian_cli-0.3.2 → meridian_cli-0.3.4}/src/meridian/lib/ops/spawn/execute_runner.py

@@ -236,6 +236,10 @@ async def _prepare_execution_handoff(
             autocompact=request.execution_policy.autocompact,
             ctx=resolved_context,
         )
+        if runtime.config.env or request.env:
+            resolved_env = dict(runtime.config.env)
+            resolved_env.update(request.env)
+            run_env_overrides = {**resolved_env, **run_env_overrides}
         runtime_work_id = session_context.work_id or work_id
         final_request = resolved_request.model_copy(update={"work_id_hint": runtime_work_id})
         launch_runtime = runtime_request.model_copy(

{meridian_cli-0.3.2 → meridian_cli-0.3.4}/src/meridian/lib/ops/spawn/models.py

@@ -73,6 +73,7 @@ class SpawnLaunchOptionUpdates(TypedDict):
     debug: bool
     task_ping_interval: str | None
     task_ping_reset_on_activity: bool | None
+    env: tuple[str, ...]
 
 
 class SpawnLaunchOptions(BaseModel):
@@ -95,6 +96,7 @@ class SpawnLaunchOptions(BaseModel):
     debug: bool = False
     task_ping_interval: str | None = None
     task_ping_reset_on_activity: bool | None = None
+    env: tuple[str, ...] = ()
 
     def launch_option_updates(self) -> SpawnLaunchOptionUpdates:
         return {
@@ -115,6 +117,7 @@ class SpawnLaunchOptions(BaseModel):
             "debug": self.debug,
             "task_ping_interval": self.task_ping_interval,
             "task_ping_reset_on_activity": self.task_ping_reset_on_activity,
+            "env": self.env,
         }
 
 

{meridian_cli-0.3.2 → meridian_cli-0.3.4}/src/meridian/lib/ops/spawn/prepare.py

@@ -41,6 +41,32 @@ from .models import SpawnCreateInput
 _DRY_RUN_REPORT_PATH = "<spawn-report-path>"
 
 
+def _parse_env_assignments(raw: tuple[str, ...]) -> dict[str, str]:
+    parsed: dict[str, str] = {}
+    for item in raw:
+        if "=" not in item:
+            raise ValueError(
+                f"Invalid --env value {item!r}: expected KEY=VALUE format."
+            )
+        key, _, value = item.partition("=")
+        key = key.strip()
+        if not key:
+            raise ValueError(
+                f"Invalid --env value {item!r}: KEY is empty."
+            )
+        parsed[key] = value
+    return parsed
+
+
+def _resolve_spawn_env(payload: SpawnCreateInput) -> dict[str, str]:
+    cli_env = _parse_env_assignments(payload.env)
+    if cli_env:
+        return cli_env
+    if payload.launch_policy_snapshot is not None:
+        return dict(payload.launch_policy_snapshot.env)
+    return {}
+
+
 @dataclass(frozen=True)
 class SpawnCreateArtifacts:
     """Resolved spawn request plus expensive prepared surface for bind-only execute."""
@@ -171,6 +197,7 @@ def build_create_payload(
             launch_policy_snapshot=payload.launch_policy_snapshot,
             pi_task_ping_interval_seconds=parse_duration_seconds(payload.task_ping_interval),
             pi_task_ping_reset_on_activity=payload.task_ping_reset_on_activity,
+            env=_resolve_spawn_env(payload),
         )
 
         mars_runtime_source = runtime or build_runtime_from_root_and_config(
@@ -200,12 +227,15 @@ def build_create_payload(
             ),
         )
         if composition_dry_run:
+            plan_overrides = dict(config.env)
+            plan_overrides.update(raw_request.env)
             preview_context = bind_spawn_launch_context(
                 prepared=prepared_surface,
                 bindings=RuntimeBindings(
                     spawn_id="dry-run",
                     report_output_path=Path(_DRY_RUN_REPORT_PATH),
                     dry_run=True,
+                    plan_overrides=plan_overrides,
                 ),
                 runtime=preview_runtime,
                 harness_registry=harness_registry,