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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meridian-cli
-Version: 0.3.3
+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

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

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

{meridian_cli-0.3.3 → 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.3 → 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.3 → 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.3 → 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.3 → 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.3 → 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.3 → 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.3 → 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.3 → 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.3 → 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.3 → 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.3 → 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.3 → 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.3 → 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,