meridian-cli 0.2.18__tar.gz → 0.2.20__tar.gz

{meridian_cli-0.2.18 → meridian_cli-0.2.20}/PKG-INFO

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

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.2.18"
+__version__ = "0.2.20"

{meridian_cli-0.2.18 → meridian_cli-0.2.20}/src/meridian/cli/main.py

@@ -599,6 +599,7 @@ def _run_primary_launch(
 
     emit(
         primary_launch.run_primary_launch(
+            project_root=get_global_options().project_root,
             continue_ref=continue_ref,
             fork_ref=fork_ref,
             fork_fresh_ref=fork_fresh_ref,

{meridian_cli-0.2.18 → meridian_cli-0.2.20}/src/meridian/cli/primary_launch.py

@@ -14,11 +14,9 @@ from meridian.lib.core.util import FormatContext
 from meridian.lib.harness.registry import get_default_harness_registry
 from meridian.lib.launch import LaunchRequest, SessionMode, launch_primary
 from meridian.lib.launch.composition import PromptDocument
-from meridian.lib.launch.reference import validate_reference_paths
 from meridian.lib.launch.request import SessionRequest
 from meridian.lib.ops.reference import resolve_session_reference
 from meridian.lib.ops.spawn.models import normalize_goal
-from meridian.lib.state.paths import resolve_kb_dir
 
 
 class PrimaryLaunchOutput(BaseModel):
@@ -314,14 +312,6 @@ def run_primary_launch(
         if requested_work_id is None and resolved_fork.source_work_id is not None:
             requested_work_id = resolved_fork.source_work_id
 
-    validated_reference_files = tuple(
-        path.as_posix()
-        for path in validate_reference_paths(
-            reference_files,
-            reference_anchor=project_root,
-            kb_dir=resolve_kb_dir(project_root),
-        )
-    )
     resolved_goal = normalize_goal(goal)
 
     launch_result = launch_primary(
@@ -341,7 +331,7 @@ def run_primary_launch(
             supplemental_prompt_documents=supplemental_prompt_documents,
             include_bootstrap_documents=include_bootstrap_documents,
             context_from=fork_resolution.resolved_context_from,
-            reference_files=validated_reference_files,
+            reference_files=reference_files,
             prompt=prompt,
             skills=skills,
             goal=resolved_goal,

{meridian_cli-0.2.18 → meridian_cli-0.2.20}/src/meridian/lib/config/.context/CONTEXT.md

@@ -104,6 +104,20 @@ For `replace`, the entire section from the higher-precedence file wins.
 use `structlog` here. The launch diagnostic boundary (`capture_library_diagnostics()`)
 captures stdlib warnings during spawn; structlog bypasses it and leaks to stderr.
 
+## Launch-Time Harness Profile Resolution
+
+Some harness profile fields are resolved at launch time rather than at config load
+time. These follow the same pattern: ambient config snapshot → launch-time env override:
+
+- `resolve_pi_harness_profile_for_launch()` — resolves `[harness.pi]` (managed bash,
+  load_all_extensions, background_tasks, spawn_watch)
+- `resolve_claude_allow_builtin_agents_for_launch()` — resolves
+  `[harness.claude] allow_builtin_agents` from the launch config snapshot, falling
+  back to `load_config()` if the snapshot is absent or invalid
+
+Both are called from `bind_launch_context()` in `lib/launch/context.py` and threaded
+into the harness adapter's `resolve_launch_spec()`.
+
 ## Schema Metadata (`schema.py`)
 
 `config_field(canonical_key, value_kind=..., file_aliases=..., env_vars=...)` attaches

{meridian_cli-0.2.18 → meridian_cli-0.2.20}/src/meridian/lib/config/AGENTS.md

@@ -62,6 +62,18 @@ and formatting. Use `preserving_edit.py` when editing config programmatically.
 - `context_config.py` — `ContextConfig`, `ContextSourceType`: context path schema
 - `catalog.py` — `build_option_catalog()`: introspects `MeridianConfig` for CLI/docs
 
+### Harness Profile Config Settings
+
+Per-harness profile configs under `HarnessConfig` expose TOML-settable fields. The
+Claude profile includes:
+
+- `[harness.claude] model` — default model (string, env: `MERIDIAN_HARNESS_MODEL_CLAUDE`)
+- `[harness.claude] wait_yield_seconds` — polling interval (float, env:
+  `MERIDIAN_HARNESS_WAIT_YIELD_SECONDS_CLAUDE`)
+- `[harness.claude] allow_builtin_agents` — whether to permit Claude's built-in
+  subagents (Explore, Plan, general-purpose). Default `false` — Meridian denies them
+  so sessions use custom Meridian agents exclusively. Set `true` to opt out.
+
 ## Depth
 
 → [.context/CONTEXT.md](.context/CONTEXT.md) — ContextVar thread-local pattern,

{meridian_cli-0.2.18 → meridian_cli-0.2.20}/src/meridian/lib/config/settings.py

@@ -345,6 +345,15 @@ def _normalize_harness_table(
                         )
                     harness_values["wait_yield_seconds"] = float(harness_value)
                     continue
+                if key == "claude" and harness_key == "allow_builtin_agents":
+                    if not isinstance(harness_value, bool):
+                        raise ValueError(
+                            f"Invalid value for '{source}.{key}.allow_builtin_agents': "
+                            f"expected bool, got "
+                            f"{type(harness_value).__name__} ({harness_value!r})."
+                        )
+                    harness_values["allow_builtin_agents"] = harness_value
+                    continue
                 if key == "pi" and harness_key == "disable_managed_bash":
                     if not isinstance(harness_value, bool):
                         raise ValueError(
@@ -425,6 +434,9 @@ def _normalize_spawn_table(raw_value: object, *, source: str) -> dict[str, objec
 
     values: dict[str, object] = {}
     for key, value in cast("dict[str, object]", raw_value).items():
+        if key == "deny_headless_harnesses":
+            values[key] = _parse_toml_list(raw_value=value, source=f"{source}.{key}")
+            continue
         if key not in {"default_wait_yield_seconds", "min_wait_yield_seconds"}:
             logger.warning("Ignoring unknown Meridian config key '%s.%s'.", source, key)
             continue
@@ -1154,6 +1166,7 @@ class HarnessProfileConfig(BaseModel):
 
 
 class ClaudeHarnessProfileConfig(HarnessProfileConfig):
+    allow_builtin_agents: bool = False
     model: Annotated[
         str,
         config_field(
@@ -1354,6 +1367,14 @@ class MeridianConfig(BaseSettings):
             env_vars=("MERIDIAN_MIN_WAIT_YIELD_SECONDS",),
         ),
     ] = 30.0
+    deny_headless_harnesses: Annotated[
+        tuple[str, ...],
+        config_field(
+            "spawn.deny_headless_harnesses",
+            value_kind="str_list",
+            file_aliases=(file_alias("spawn", "deny_headless_harnesses"),),
+        ),
+    ] = ()
     harness: HarnessConfig = Field(default_factory=HarnessConfig)
     primary: PrimaryConfig = Field(default_factory=PrimaryConfig)
     output: OutputConfig = Field(default_factory=OutputConfig)
@@ -1560,6 +1581,23 @@ def resolve_pi_harness_profile_for_launch(
     )
 
 
+def resolve_claude_allow_builtin_agents_for_launch(
+    *,
+    config_snapshot: dict[str, object] | None,
+    project_root: Path,
+) -> bool:
+    """Resolve ``[harness.claude].allow_builtin_agents`` from a launch config snapshot."""
+
+    if config_snapshot:
+        try:
+            return bool(
+                MeridianConfig.model_validate(config_snapshot).harness.claude.allow_builtin_agents
+            )
+        except Exception:
+            pass
+    return bool(load_config(project_root).harness.claude.allow_builtin_agents)
+
+
 def resolve_pi_disable_managed_bash() -> bool:
     """Resolve whether Meridian should skip Pi's managed bash extension."""
 

{meridian_cli-0.2.18 → meridian_cli-0.2.20}/src/meridian/lib/harness/.context/CONTEXT.md

@@ -38,6 +38,10 @@ for streaming app server and `meridian chat`.
 Per-harness mapping:
 - Claude subprocess: `claude -p --output-format stream-json --verbose -`
 - Claude connection: `claude -p --input-format stream-json --output-format stream-json --verbose` (stdin/stdout NDJSON, not WebSocket despite `claude_ws.py` name)
+- **Claude built-in agent denial**: Meridian injects `--disallowedTools
+  Agent(Explore),Agent(Plan),Agent(general-purpose)` by default. Gated by
+  `[harness.claude] allow_builtin_agents` (bool, default `false`). The denials
+  merge into permission-derived `--disallowedTools` via `dedupe_nonempty()`.
 - Codex subprocess: `codex exec --json`; connection: `codex app-server` (real WebSocket, JSON-RPC 2.0)
 - OpenCode subprocess: `opencode run`; connection: `opencode serve` (HTTP+SSE)
 - Cursor subprocess: `cursor agent <prompt>` (stdout NDJSON, no connection path — subprocess-only)
@@ -184,6 +188,26 @@ it's captured. This is the minimum-intrusive mechanism for an otherwise unobserv
 value. Windows does not support PTY — Claude primary uses a fallback detection path
 (`session_detection.py`) on Windows.
 
+### Claude: Built-in Subagent Denial
+
+Claude Code ships with three built-in subagents: Explore, Plan, and general-purpose.
+These conflict with Meridian's own agent system. Meridian injects
+`--disallowedTools Agent(Explore),Agent(Plan),Agent(general-purpose)` by default
+so Claude sessions use custom Meridian agents exclusively. The behavior is gated by
+`[harness.claude] allow_builtin_agents` (bool, default `false`).
+
+The flag is resolved in `bind_launch_context()` via
+`resolve_claude_allow_builtin_agents_for_launch()`, threaded through
+`SpawnParams.claude_allow_builtin_agents` → `ResolvedLaunchSpec.disallowed_tools`,
+and projected by `project_claude.py`. The builtin denials merge into
+permission-derived `--disallowedTools` so exactly one flag is emitted.
+
+This is implemented as a Meridian platform policy (harness adapter injection),
+not as a per-agent `disallowed-tools` field. This means individual agent profiles
+no longer need to carry deny entries like
+`disallowed-tools: [Agent(Explore), Agent(Plan), Agent(general-purpose)]` —
+they're inherited from the harness adapter.
+
 ### Claude: System-Prompt File Channel
 
 `--append-system-prompt-file <path>` avoids `ARG_MAX` limits when skills and profile

{meridian_cli-0.2.18 → meridian_cli-0.2.20}/src/meridian/lib/harness/AGENTS.md

@@ -37,6 +37,12 @@ streaming and `meridian chat`.
 Per-harness commands:
 - Claude subprocess: `claude -p --output-format stream-json --verbose -`
 - Claude connection: stdin/stdout NDJSON (not WebSocket despite `claude_ws.py` name)
+- **Claude built-in agent denial**: Meridian injects
+  `--disallowedTools Agent(Explore),Agent(Plan),Agent(general-purpose)` by default
+  so sessions use custom Meridian agents instead of Claude's built-in subagents.
+  Gated by `[harness.claude] allow_builtin_agents` (bool, default `false`).
+  The builtin denials merge into permission-derived `--disallowedTools` via
+  `dedupe_nonempty()` so exactly one flag is emitted.
 - Codex subprocess: `codex exec --json`; connection: `codex app-server` (real WebSocket, JSON-RPC 2.0)
 - OpenCode subprocess: `opencode run`; connection: `opencode serve` (HTTP+SSE)
 - Cursor subprocess: `cursor agent <prompt>` (stdout NDJSON, no connection path — subprocess-only)
@@ -77,6 +83,8 @@ unique — always check `event.harness_id`. `turn/completed` is Codex; OpenCode
   Source of truth for what every adapter must implement.
 - `registry.py` — `HarnessRegistry`, `with_defaults()`. The global singleton.
 - `claude.py` / `codex.py` / `opencode.py` / `cursor.py` — concrete adapter implementations.
+  Claude adapter now threads `claude_allow_builtin_agents` from config → SpawnParams →
+  `ResolvedLaunchSpec.disallowed_tools`, mirroring the `pi.disable_managed_bash` pattern.
 - `__init__.py` — `HARNESS_EXTENSION_TOUCHPOINTS` and `ensure_bootstrap()`.
   Read before adding a harness — lists every file that must be touched.
 - `semantics.py` — `terminal_outcome()`, `activity_transition()`, `clears_signal()`.

{meridian_cli-0.2.18 → meridian_cli-0.2.20}/src/meridian/lib/harness/adapter.py

@@ -237,6 +237,7 @@ class SpawnParams(BaseModel):
     context_from_payload: tuple[str, ...] = ()
     reference_items: tuple[Any, ...] = ()
     pi_harness_profile: PiHarnessProfileConfig | None = None
+    claude_allow_builtin_agents: bool = False
 
 
 class McpConfig(BaseModel):

{meridian_cli-0.2.18 → meridian_cli-0.2.20}/src/meridian/lib/harness/claude.py

@@ -265,6 +265,7 @@ class ClaudeAdapter(BaseHarnessAdapter[ResolvedLaunchSpec]):
             "mcp_tools",
             "projected_roots",
             "user_turn_content",
+            "claude_allow_builtin_agents",
         }
     )
     _EXPLICITLY_IGNORED_FIELDS: ClassVar[frozenset[str]] = frozenset(
@@ -374,6 +375,9 @@ class ClaudeAdapter(BaseHarnessAdapter[ResolvedLaunchSpec]):
             prompt_file_path = str(Path(run.control_root) / "system-prompt.md")
         # Extract user_turn_content from run params if available
         user_turn_content = getattr(run, "user_turn_content", None)
+        disallowed_tools: tuple[str, ...] = ()
+        if not run.claude_allow_builtin_agents:
+            disallowed_tools = ("Agent(Explore),Agent(Plan),Agent(general-purpose)",)
         return ResolvedLaunchSpec(
             harness=HarnessId.CLAUDE,
             model=str(run.model).strip() if run.model else None,
@@ -391,6 +395,7 @@ class ClaudeAdapter(BaseHarnessAdapter[ResolvedLaunchSpec]):
             agent_name=run.agent,
             prompt_file_path=prompt_file_path,
             user_turn_content=user_turn_content,
+            disallowed_tools=disallowed_tools,
         )
 
     def preflight(

{meridian_cli-0.2.18 → meridian_cli-0.2.20}/src/meridian/lib/harness/codex.py

@@ -286,6 +286,7 @@ class CodexAdapter(BaseHarnessAdapter[ResolvedLaunchSpec]):
             "reference_items",
             "task_cwd",
             "pi_harness_profile",
+            "claude_allow_builtin_agents",
         }
     )
 

{meridian_cli-0.2.18 → meridian_cli-0.2.20}/src/meridian/lib/harness/cursor.py

@@ -75,6 +75,7 @@ class CursorAdapter(BaseHarnessAdapter[ResolvedLaunchSpec]):
             "continue_fork",
             "effort",
             "pi_harness_profile",
+            "claude_allow_builtin_agents",
         }
     )
 

{meridian_cli-0.2.18 → meridian_cli-0.2.20}/src/meridian/lib/harness/opencode.py

@@ -350,6 +350,7 @@ class OpenCodeAdapter(BaseHarnessAdapter[ResolvedLaunchSpec]):
             "reference_items",
             "task_cwd",
             "pi_harness_profile",
+            "claude_allow_builtin_agents",
         }
     )
 

{meridian_cli-0.2.18 → meridian_cli-0.2.20}/src/meridian/lib/harness/passthrough/codex.py

@@ -42,13 +42,16 @@ def _require_observer_endpoint_url(
 def _build_codex_attach_command(
     session_id: str,
     ws_url: str,
+    prompt: str | None,
     projected_roots: tuple[Path, ...],
 ) -> tuple[str, ...]:
-    """Build `codex resume {session_id} --remote {ws_url}`."""
+    """Build `codex resume {session_id} --remote {ws_url} [prompt]`."""
 
     command = ["codex", "resume", session_id, "--remote", ws_url]
     for root in projected_roots:
         command.extend(("--add-dir", root.as_posix()))
+    if prompt and prompt.strip():
+        command.append(prompt)
     return tuple(command)
 
 
@@ -85,6 +88,7 @@ class CodexPassthrough:
         return lambda session_id: _build_codex_attach_command(
             session_id=session_id,
             ws_url=_require_observer_endpoint_url(connection, transport="ws"),
+            prompt=spec.user_turn_content,
             projected_roots=spec.projected_roots,
         )
 

{meridian_cli-0.2.18 → meridian_cli-0.2.20}/src/meridian/lib/harness/pi.py

@@ -116,6 +116,7 @@ class PiAdapter(BaseHarnessAdapter[ResolvedLaunchSpec]):
             "context_from_payload",
             "reference_items",
             "task_cwd",
+            "claude_allow_builtin_agents",
         }
     )
 

{meridian_cli-0.2.18 → meridian_cli-0.2.20}/src/meridian/lib/harness/projections/project_claude.py

@@ -33,6 +33,7 @@ _PROJECTED_FIELDS: frozenset[str] = frozenset(
         "prompt",
         "prompt_file_path",
         "user_turn_content",
+        "disallowed_tools",
     }
 )
 
@@ -179,6 +180,10 @@ def project_claude_spec_to_cli_args(
 
     permission_flags = resolve_permission_flags(spec.permission_resolver, HarnessId.CLAUDE)
     permission_tail, allowed_tools, disallowed_tools = _extract_claude_tool_flags(permission_flags)
+    spec_disallowed: list[str] = []
+    for entry in spec.disallowed_tools:
+        spec_disallowed.extend(split_csv_entries(entry))
+    disallowed_tools = dedupe_nonempty((*disallowed_tools, *spec_disallowed))
     allowed_tools = dedupe_nonempty((*allowed_tools, *parent_allowed_tools))
     command.extend(permission_tail)
     if allowed_tools:

{meridian_cli-0.2.18 → meridian_cli-0.2.20}/src/meridian/lib/harness/projections/project_codex_streaming.py

@@ -75,6 +75,7 @@ _DELEGATED_FIELDS: frozenset[str] = frozenset(
         "harness",
         "pi_extension_entrypoints",
         "load_all_pi_extensions",
+        "disallowed_tools",
         "prompt_file_path",
         "reference_items",
         "skills",

{meridian_cli-0.2.18 → meridian_cli-0.2.20}/src/meridian/lib/harness/projections/project_codex_subprocess.py

@@ -43,6 +43,7 @@ _DELEGATED_FIELDS: frozenset[str] = frozenset(
         "harness",
         "pi_extension_entrypoints",
         "load_all_pi_extensions",
+        "disallowed_tools",
         "prompt_file_path",
         "reference_items",
         "skills",

{meridian_cli-0.2.18 → meridian_cli-0.2.20}/src/meridian/lib/harness/projections/project_cursor.py

@@ -43,6 +43,7 @@ _DELEGATED_FIELDS: frozenset[str] = frozenset(
         "reference_items",
         "pi_extension_entrypoints",
         "load_all_pi_extensions",
+        "disallowed_tools",
     }
 )
 

{meridian_cli-0.2.18 → meridian_cli-0.2.20}/src/meridian/lib/harness/projections/project_opencode_streaming.py

@@ -50,6 +50,7 @@ _DELEGATED_FIELDS: frozenset[str] = frozenset(
         "harness",
         "pi_extension_entrypoints",
         "load_all_pi_extensions",
+        "disallowed_tools",
         "prompt_file_path",
         "report_output_path",
         "task_cwd",

{meridian_cli-0.2.18 → meridian_cli-0.2.20}/src/meridian/lib/harness/projections/project_opencode_subprocess.py

@@ -42,6 +42,7 @@ _DELEGATED_FIELDS: frozenset[str] = frozenset(
         "harness",
         "pi_extension_entrypoints",
         "load_all_pi_extensions",
+        "disallowed_tools",
         "prompt_file_path",
         "reference_items",
         "report_output_path",

{meridian_cli-0.2.18 → meridian_cli-0.2.20}/src/meridian/lib/harness/projections/project_pi_native_tui.py

@@ -45,6 +45,7 @@ _DELEGATED_FIELDS: frozenset[str] = frozenset(
         "mcp_tools",
         "projected_roots",
         "task_cwd",
+        "disallowed_tools",
     }
 )
 

{meridian_cli-0.2.18 → meridian_cli-0.2.20}/src/meridian/lib/harness/projections/project_pi_rpc.py

@@ -46,6 +46,7 @@ _DELEGATED_FIELDS: frozenset[str] = frozenset(
         "skills",
         "reference_items",
         "task_cwd",
+        "disallowed_tools",
     }
 )
 

{meridian_cli-0.2.18 → meridian_cli-0.2.20}/src/meridian/lib/launch/AGENTS.md

@@ -38,6 +38,12 @@ bind_launch_context()                 ← env, cwd, spec, argv, permissions
 LaunchContext                         ← complete at construction; ready to run
 ```
 
+Before callers enter this pipeline, they must resolve the shared launch-input
+surface with `resolution.py:resolve_launch_inputs()`. That seam owns work
+precedence, `--from` work inheritance, task cwd selection, reference anchoring,
+and `-f` validation. Primary and spawn may differ in prompt/session projection,
+but they should not hand-roll directory or reference resolution.
+
 **Why the split?** The primary CLI path calls `bind_launch_context()` twice: once
 with `dry_run=True` for `--dry-run` display, then again with real spawn ID and paths.
 `prepare_launch_surface()` is expensive and safe to call once. `bind_launch_context()`

{meridian_cli-0.2.18 → meridian_cli-0.2.20}/src/meridian/lib/launch/__init__.py

@@ -6,6 +6,7 @@ from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
 from meridian.lib.launch.launch_types import summarize_composition_warnings
+from meridian.lib.launch.resolution import resolve_launch_inputs
 from meridian.lib.state import work_store
 from meridian.lib.state.paths import resolve_project_paths, resolve_work_scratch_dir_for_project
 
@@ -78,7 +79,9 @@ def launch_primary(
     """Launch the primary agent process and wait for exit."""
 
     from meridian.lib.catalog.catalog_session import CatalogSession
+    from meridian.lib.config.project_root import resolve_project_root_resolution
     from meridian.lib.core.context import resolve_runtime_context
+    from meridian.lib.ops.runtime import resolve_runtime_root_for_read
 
     from .context import (
         RuntimeBindings,
@@ -90,11 +93,31 @@ def launch_primary(
     from .process import run_harness_process
     from .types import LaunchResult
 
-    runtime = build_primary_launch_runtime(project_root=project_root, execution_cwd=project_root)
+    resolved_project_root = resolve_project_root_resolution(project_root).project_root
+    preview_work_id = _preview_work_id_for_launch(request)
+    runtime_root_for_context = resolve_runtime_root_for_read(resolved_project_root)
+    runtime_context = resolve_runtime_context(
+        project_root=resolved_project_root,
+        runtime_root=runtime_root_for_context,
+    )
+    ambient_work_id = None if preview_work_id is not None else runtime_context.work_id
+    project_state_dir = resolve_project_paths(resolved_project_root).root_dir
+    launch_resolution = resolve_launch_inputs(
+        authority_root=resolved_project_root,
+        project_state_dir=project_state_dir,
+        context_from=request.context_from,
+        reference_files=request.reference_files,
+        explicit_work_id=preview_work_id,
+        ambient_work_id=ambient_work_id,
+    )
+
+    runtime = build_primary_launch_runtime(
+        project_root=resolved_project_root,
+        execution_cwd=resolved_project_root,
+    )
     if request.include_bootstrap_documents:
         from meridian.lib.catalog.bootstrap import BootstrapRegistry
 
-        resolved_project_root = Path(runtime.resolved_config_root)
         request = request.model_copy(
             update={
                 "supplemental_prompt_documents": (
@@ -106,23 +129,24 @@ def launch_primary(
     resolved_work_id = (
         _preview_work_id_for_launch(request)
         if request.dry_run
-        else _resolve_work_id_for_launch(project_root, request)
+        else _resolve_work_id_for_launch(resolved_project_root, request)
     )
 
-    resolved_project_root = Path(runtime.resolved_config_root).expanduser().resolve()
-    runtime_root = Path(runtime.runtime_root).expanduser().resolve()
+    runtime = runtime.model_copy(update=launch_resolution.runtime_updates)
+    effective_work_id = resolved_work_id or launch_resolution.effective_work_id
     active_work_dir = (
         resolve_work_scratch_dir_for_project(
             resolved_project_root,
-            resolved_work_id,
+            effective_work_id,
         )
-        if resolved_work_id is not None
-        else resolve_runtime_context(
-            project_root=resolved_project_root,
-            runtime_root=runtime_root,
-        ).work_dir
+        if effective_work_id is not None
+        else runtime_context.work_dir
+    )
+    request_updates = dict(launch_resolution.request_updates)
+    request_updates["work_id_hint"] = effective_work_id
+    spawn_request = build_primary_spawn_request(request=request).model_copy(
+        update=request_updates
     )
-    spawn_request = build_primary_spawn_request(request=request)
     prepared_policy = compile_prepared_policy_surface(
         request=spawn_request,
         runtime=runtime,
@@ -142,7 +166,7 @@ def launch_primary(
         bindings=RuntimeBindings(
             spawn_id="dry-run-primary",
             report_output_path=Path(runtime.report_output_path or "report.md"),
-            runtime_work_id=resolved_work_id,
+            runtime_work_id=effective_work_id,
             dry_run=True,
         ),
         runtime=runtime,