meridian-cli 0.2.3__tar.gz → 0.2.4__tar.gz

{meridian_cli-0.2.3 → meridian_cli-0.2.4}/.gitignore

@@ -27,6 +27,7 @@ plan/
 err
 out
 .mars/
+mars.lock
 mars.local.toml
 *.log
 .claude/scheduled_tasks.lock

{meridian_cli-0.2.3 → meridian_cli-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meridian-cli
-Version: 0.2.3
+Version: 0.2.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.2.3 → meridian_cli-0.2.4}/src/meridian/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.2.3"
+__version__ = "0.2.4"

{meridian_cli-0.2.3 → meridian_cli-0.2.4}/src/meridian/lib/harness/connections/codex_ws.py

@@ -312,6 +312,7 @@ class CodexConnection(HarnessConnection[ResolvedLaunchSpec]):
 
         env = inherit_child_env(os.environ, config.env_overrides)
         self._codex_home = resolve_codex_home(env)
+        effective_cwd = self._effective_project_root()
         spawn_dir = resolve_spawn_log_dir(config.control_root, config.spawn_id)
         spawn_dir.mkdir(parents=True, exist_ok=True)
         self._stderr_log_path = spawn_dir / "stderr.log"
@@ -329,7 +330,7 @@ class CodexConnection(HarnessConnection[ResolvedLaunchSpec]):
                 self._emit_startup_phase(StartupPhase.LAUNCHING_SUBPROCESS)
                 self._process = await asyncio.create_subprocess_exec(
                     *appserver_command,
-                    cwd=str(config.control_root),
+                    cwd=str(effective_cwd),
                     env=env,
                     stdout=asyncio.subprocess.DEVNULL,
                     stderr=self._stderr_handle,
@@ -1109,6 +1110,14 @@ class CodexConnection(HarnessConnection[ResolvedLaunchSpec]):
         """Check if this is a fresh session (not resume or fork)."""
         return not (spec.continue_session_id or "").strip()
 
+    def _effective_project_root(self) -> Path:
+        """Project root Codex should bind the app-server/thread/rollout to."""
+
+        config = self._config
+        if config is None:
+            raise RuntimeError("Codex connection config is unavailable")
+        return config.task_cwd or config.control_root
+
     async def _send_bootstrap_turn_and_wait(self) -> None:
         """Send a minimal bootstrap turn and wait for completion.
 
@@ -1149,7 +1158,7 @@ class CodexConnection(HarnessConnection[ResolvedLaunchSpec]):
             if (
                 find_attachable_rollout_session_id(
                     codex_home=codex_home,
-                    project_root=config.control_root,
+                    project_root=self._effective_project_root(),
                     session_id=thread_id,
                 )
                 == thread_id
@@ -1182,7 +1191,7 @@ class CodexConnection(HarnessConnection[ResolvedLaunchSpec]):
         projected = project_managed_primary_bootstrap(
             self.harness_id,
             spec,
-            project_root=config.control_root,
+            project_root=self._effective_project_root(),
         )
         if not isinstance(projected, tuple):
             raise TypeError("Codex managed-primary bootstrap must be (method, payload)")

{meridian_cli-0.2.3 → meridian_cli-0.2.4}/src/meridian/lib/launch/.context/CONTEXT.md

@@ -196,11 +196,13 @@ to `logical_task_cwd` but may differ — Claude harness forces it to `authority_
 when `has_distinct_task_cwd` is true, because Claude's `--add-dir` grants access
 without needing the process to start in the task directory.
 
-**Task CWD instruction injection.** When `actual_process_cwd != logical_task_cwd`,
-the launch composition adds a prompt instruction telling the agent to `cd` into
-the task cwd before any filesystem operations. This is the fallback mechanism —
-the agent is informed of the intended working directory when the process didn't
-start there. Controlled by `LaunchDirectoryContext.requires_task_cwd_instruction`.
+**Task CWD instruction injection.** For non-primary child spawns with a distinct
+`logical_task_cwd`, launch composition always adds a prompt instruction telling
+the agent to `cd` into the task cwd before filesystem operations. This is a
+conservative child-spawn safety contract: harnesses may bind tools differently
+than Meridian's requested process cwd. Primary sessions stay quiet unless a
+future primary flow explicitly needs task-cwd steering. Controlled by
+`LaunchDirectoryContext.should_inject_task_cwd_instruction(surface)`.
 
 Resolution priority in `resolve_task_cwd()`:
 1. `--no-worktree` → authority root
@@ -263,11 +265,13 @@ Two steps inside `bind_launch_context()`:
    `--add-dir` args; OpenCode gets `OPENCODE_CONFIG_CONTENT` env override (deep-merged).
 
 Roots include workspace roots, git context clone roots, context projection roots
-(work, kb, extras), runtime root, and system temp dir — deduplicated in order.
-Extra args remain user-owned passthrough; they are not a workspace projection channel.
+(work, kb, extras), task cwd when task cwd is external, runtime root, and system
+temp dir — deduplicated in order. Extra args remain user-owned passthrough; they
+are not a workspace projection channel.
 
 **Task CWD projection gap.** When `task_cwd` is outside both `control_root` and
-all projected workspace roots, and workspace projection is not active, a
+all projected workspace roots, launch composition projects the exact task cwd
+for active projection harnesses. If workspace projection is not active, a
 `task_cwd_not_projected` warning is emitted. The launch continues but the agent
 doesn't automatically get access to the task directory — harness-specific
 configuration would be needed.

{meridian_cli-0.2.3 → meridian_cli-0.2.4}/src/meridian/lib/launch/context.py

@@ -1549,6 +1549,9 @@ def bind_launch_context(
             )
 
     is_primary_launch = runtime.composition_surface == LaunchCompositionSurface.PRIMARY
+    inject_task_cwd_instruction = directory_context.should_inject_task_cwd_instruction(
+        runtime.composition_surface
+    )
     materialized = materialize_launch_artifacts(
         harness=harness,
         prompt=resolved_request.prompt,
@@ -1560,7 +1563,7 @@ def bind_launch_context(
         extra_args=projected_extra_args,
         control_root=resolved_control_root.as_posix(),
         task_cwd=(task_cwd.as_posix() if task_cwd is not None else None),
-        inject_task_cwd_instruction=directory_context.requires_task_cwd_instruction,
+        inject_task_cwd_instruction=inject_task_cwd_instruction,
         mcp_tools=resolved_request.mcp_tools,
         projected_roots=projected_roots,
         interactive=is_primary_launch,

{meridian_cli-0.2.3 → meridian_cli-0.2.4}/src/meridian/lib/launch/cwd.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from dataclasses import dataclass, replace
 from pathlib import Path
 
+from meridian.lib.launch.request import LaunchCompositionSurface
 from meridian.lib.state import work_store
 
 
@@ -56,9 +57,16 @@ class LaunchDirectoryContext:
     def has_distinct_task_cwd(self) -> bool:
         return self.logical_task_cwd != self.authority_root
 
-    @property
-    def requires_task_cwd_instruction(self) -> bool:
-        return self.actual_process_cwd != self.logical_task_cwd
+    def should_inject_task_cwd_instruction(self, surface: LaunchCompositionSurface) -> bool:
+        """Whether launch composition should tell the agent to cd into task cwd.
+
+        Child spawn tool cwd can vary by harness even when Meridian requests the
+        task cwd. Be conservative for all non-primary child launches with a
+        distinct task cwd; keep primary sessions quiet unless a future primary
+        flow needs explicit task-cwd steering.
+        """
+
+        return self.has_distinct_task_cwd and surface != LaunchCompositionSurface.PRIMARY
 
 
 def _active_worktree_path_for_item(

{meridian_cli-0.2.3 → meridian_cli-0.2.4}/src/meridian/lib/ops/.context/CONTEXT.md

@@ -85,6 +85,11 @@ concerns and returns structured results for callers to persist elsewhere.
 by `work_worktree.py` and spawn logic. The split is: lifecycle owns raw git operations,
 ensure owns state management and idempotency.
 
+Managed worktree creation writes a `mars.local.toml` guard with
+`[settings] targets = []` when the worktree is newly created. This prevents
+repo-local `meridian mars sync` from materializing harness targets inside each
+worktree. Existing `mars.local.toml` files are user-owned and preserved.
+
 **Destructive operations guard against three conditions:**
 
 1. **Manual worktrees** (`managed=False`): paths set via `work set-worktree` are never

{meridian_cli-0.2.3 → meridian_cli-0.2.4}/src/meridian/lib/ops/worktree_ensure.py

@@ -11,6 +11,7 @@ from meridian.lib.core.context import RuntimeContext
 from meridian.lib.ops.runtime import runtime_context
 from meridian.lib.ops.worktree_lifecycle import (
     default_worktree_branch,
+    ensure_worktree_mars_local_guard,
     provision_for_start,
     recover_pending,
 )
@@ -367,6 +368,8 @@ def ensure_work_item_worktree(
                     f"'{resolved_path}' is non-canonical; expected '{canonical_path}'. "
                     "Clear or migrate the assignment before ensuring."
                 )
+            if not dry_run:
+                ensure_worktree_mars_local_guard(resolved_path)
             was_pending = item.worktree_pending
             if not dry_run and (
                 was_pending or item.worktree_branch != canonical_metadata.branch
@@ -479,6 +482,8 @@ def ensure_work_item_worktree(
         and item.worktree_managed
         and Path(item.worktree_path).is_dir()
     ):
+        if not dry_run:
+            ensure_worktree_mars_local_guard(Path(item.worktree_path).expanduser().resolve())
         if (
             item.worktree_repo_path != canonical_metadata.repo_path
             or item.worktree.name != canonical_metadata.name
@@ -623,6 +628,8 @@ def ensure_temporary_worktree(
                 "or clear/recreate the temp worktree."
             )
         if recorded_path.is_dir():
+            if not dry_run:
+                ensure_worktree_mars_local_guard(recorded_path)
             if record.status == "pending" and not dry_run:
                 temp_worktree_store.put_temporary_worktree(
                     runtime_root,

{meridian_cli-0.2.3 → meridian_cli-0.2.4}/src/meridian/lib/ops/worktree_lifecycle.py

@@ -27,6 +27,7 @@ from meridian.lib.ops.worktree_ops import (
     resolve_main_repo_root,
     worktree_exists,
 )
+from meridian.lib.state.atomic import atomic_write_text
 from meridian.lib.state.work_store import WorkItem, WorktreeMetadata
 
 logger = structlog.get_logger(__name__)
@@ -121,6 +122,15 @@ def _target_metadata(
     )
 
 
+def ensure_worktree_mars_local_guard(worktree_path: Path) -> None:
+    """Prevent managed worktrees from syncing repo-local harness targets."""
+
+    guard_path = worktree_path / "mars.local.toml"
+    if guard_path.exists():
+        return
+    atomic_write_text(guard_path, "[settings]\ntargets = []\n")
+
+
 def provision_for_start(
     project_root: Path,
     work_slug: str,
@@ -153,6 +163,7 @@ def provision_for_start(
         Path(target_path),
         target.branch or default_worktree_branch(work_slug),
     )
+    ensure_worktree_mars_local_guard(result.path)
     return WorktreeProvisionResult(
         status="provisioned",
         metadata=WorktreeMetadata(
@@ -179,6 +190,7 @@ def restore_for_reopen(project_root: Path, item: WorkItem) -> WorktreeRestoreRes
         return WorktreeRestoreResult(status="manual_missing", metadata=item.worktree)
 
     if worktree_path.is_dir():
+        ensure_worktree_mars_local_guard(worktree_path)
         return WorktreeRestoreResult(status="available", metadata=item.worktree)
 
     if not item.worktree_branch:
@@ -199,6 +211,8 @@ def restore_for_reopen(project_root: Path, item: WorkItem) -> WorktreeRestoreRes
         )
         return WorktreeRestoreResult(status="failed", metadata=item.worktree, error=str(exc))
 
+    ensure_worktree_mars_local_guard(result.path)
+
     return WorktreeRestoreResult(
         status="restored",
         metadata=WorktreeMetadata(