duet-cli 0.2.16__tar.gz → 0.2.17__tar.gz

{duet_cli-0.2.16/duet_cli.egg-info → duet_cli-0.2.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: duet-cli
-Version: 0.2.16
+Version: 0.2.17
 Summary: Two CLI agents in conversation. One Python file. Stdlib only.
 Author: Volkan Altan
 License-Expression: MIT
@@ -29,7 +29,8 @@ and you get a saved transcript to inspect.
 
 Run **two different models through a single agent harness (CLI)**, such as
 Codex or OpenCode. You can also pair different CLIs, such as Claude Code and
-Codex. Gemini and Copilot are also supported.
+Codex. Gemini and Copilot are also supported. A native ZCode account can
+provide a [read-only review peer](https://github.com/volkan/duet/blob/main/docs/ZCODE.md).
 [See examples using one CLI](https://github.com/volkan/duet/blob/main/docs/USAGE.md#same-backend-peering).
 
 [![Watch the 80-second review workflow demo](https://raw.githubusercontent.com/volkan/duet/main/docs/demos/finding-review.png)](https://github.com/volkan/duet/blob/main/docs/demos/finding-review.mp4)
@@ -63,19 +64,21 @@ This starts a review and fix loop with the coder in a separate Git worktree.
 Inspect the changes before merging; agent agreement does not prove correctness.
 
 Already working inside an agent? Install the **same Duet skill** for Claude
-Code, Codex, and OpenCode (requires Node.js/npm; choose **Symlink**):
+Code, Codex, OpenCode, and ZCode (requires Node.js/npm; choose **Symlink**):
 
 ```bash
 npx skills add volkan/duet --skill duet --global \
-  --agent claude-code --agent codex --agent opencode
+  --agent claude-code --agent codex --agent opencode --agent zcode
 ```
 
-Start a new session, then use `/duet` in Claude Code, `$duet` in Codex, or ask
-OpenCode to use the `duet` skill.
+Start a new session. Use `/duet` in Claude Code, `$duet` in Codex, or `/skill duet` in ZCode.
+Ask OpenCode to use the `duet` skill.
 [Installation details](https://github.com/volkan/duet/blob/main/docs/INSTALLATION.md)
 cover `~/.agents/skills`, prerequisites, and alternative installers. See the
 [OpenCode guide](https://github.com/volkan/duet/blob/main/docs/OPENCODE_PLUGIN.md)
 for its native skill and optional command wrapper.
+The [ZCode guide](https://github.com/volkan/duet/blob/main/docs/ZCODE.md#host-shortcuts)
+provides its `/duet` shortcut and native peer setup.
 
 ## Native plugin installation
 

{duet_cli-0.2.16 → duet_cli-0.2.17}/README.md

@@ -8,7 +8,8 @@ and you get a saved transcript to inspect.
 
 Run **two different models through a single agent harness (CLI)**, such as
 Codex or OpenCode. You can also pair different CLIs, such as Claude Code and
-Codex. Gemini and Copilot are also supported.
+Codex. Gemini and Copilot are also supported. A native ZCode account can
+provide a [read-only review peer](https://github.com/volkan/duet/blob/main/docs/ZCODE.md).
 [See examples using one CLI](https://github.com/volkan/duet/blob/main/docs/USAGE.md#same-backend-peering).
 
 [![Watch the 80-second review workflow demo](https://raw.githubusercontent.com/volkan/duet/main/docs/demos/finding-review.png)](https://github.com/volkan/duet/blob/main/docs/demos/finding-review.mp4)
@@ -42,19 +43,21 @@ This starts a review and fix loop with the coder in a separate Git worktree.
 Inspect the changes before merging; agent agreement does not prove correctness.
 
 Already working inside an agent? Install the **same Duet skill** for Claude
-Code, Codex, and OpenCode (requires Node.js/npm; choose **Symlink**):
+Code, Codex, OpenCode, and ZCode (requires Node.js/npm; choose **Symlink**):
 
 ```bash
 npx skills add volkan/duet --skill duet --global \
-  --agent claude-code --agent codex --agent opencode
+  --agent claude-code --agent codex --agent opencode --agent zcode
 ```
 
-Start a new session, then use `/duet` in Claude Code, `$duet` in Codex, or ask
-OpenCode to use the `duet` skill.
+Start a new session. Use `/duet` in Claude Code, `$duet` in Codex, or `/skill duet` in ZCode.
+Ask OpenCode to use the `duet` skill.
 [Installation details](https://github.com/volkan/duet/blob/main/docs/INSTALLATION.md)
 cover `~/.agents/skills`, prerequisites, and alternative installers. See the
 [OpenCode guide](https://github.com/volkan/duet/blob/main/docs/OPENCODE_PLUGIN.md)
 for its native skill and optional command wrapper.
+The [ZCode guide](https://github.com/volkan/duet/blob/main/docs/ZCODE.md#host-shortcuts)
+provides its `/duet` shortcut and native peer setup.
 
 ## Native plugin installation
 

{duet_cli-0.2.16 → duet_cli-0.2.17}/duet.py

@@ -32,6 +32,8 @@ Each agent keeps its own session across turns:
     `gemini --resume <session_id>` from the JSON response.
   - Copilot: `copilot -p ... --output-format json`; subsequent turns use
     `copilot --resume=<sessionId>` from the JSONL result event.
+  - ZCode: official headless JSON summaries and explicit --resume sess_ IDs;
+    private credential-free profiles select the account model and reasoning.
   - OpenCode: `opencode run --format json`; subsequent turns use
     `opencode run -s <sessionID>` from the JSONL event stream.
 
@@ -65,11 +67,12 @@ import threading
 import time
 import traceback
 import uuid
+import urllib.parse
 from typing import Callable, Iterable, Optional
 
 # ---------- defaults ----------
 
-__version__ = "0.2.16"
+__version__ = "0.2.17"
 
 DEFAULT_SENTINEL = "<<<LGTM>>>"
 DEFAULT_SANDBOX = "workspace-write"
@@ -422,6 +425,7 @@ class Agent:
     # stays out of Agent's repr and serialized config/state shape; the run
     # lifecycle records it alongside the turn when metrics are enabled.
     last_call_metrics: dict = dataclasses.field(default_factory=dict, repr=False)
+    zcode_selection: Optional[dict] = None  # native resume cannot change model/effort
 
     def __post_init__(self) -> None:
         # Pin Claude to its stable Sonnet alias instead of inheriting a
@@ -462,6 +466,8 @@ def agent_state(a: Agent) -> dict:
         data["extra_args"] = a.extra_args
     if a.reasoning_effort is not None:
         data["reasoning_effort"] = a.reasoning_effort
+    if a.zcode_selection is not None:
+        data["zcode_selection"] = a.zcode_selection
     return data
 
 
@@ -594,6 +600,11 @@ def validate_config(cfg: DuetConfig,
                 f"expected {choices}",
                 parser,
             )
+        if agent.backend == "zcode":
+            try:
+                _zcode_requested_selection(agent, effective_reasoning(agent, cfg.reasoning))
+            except ValueError as exc:
+                _config_error(str(exc), parser)
         if agent.name in seen_names:
             _config_error(
                 f"duplicate agent name {agent.name!r}; agent names must be unique",
@@ -1598,6 +1609,8 @@ def _metrics_reasoning_profile(agent: Agent, cfg: DuetConfig) -> tuple[
             return requested, None, None, "native_default", fast
         transport = "prompt"
         backend_value = None
+    elif agent.backend == "zcode":
+        transport = "config_file"
     elif agent.backend == "codex":
         transport = "config_flag"
     else:
@@ -2470,6 +2483,335 @@ def _call_opencode_backend(agent: Agent, system_prompt: str, message: str,
     )
 
 
+
+_ZCODE_DESKTOP_RESOURCES = pathlib.Path("/Applications/ZCode.app/Contents/Resources")
+_ZCODE_SESSION_ID_RE = re.compile(r"^sess_[A-Za-z0-9_-]+$")
+_ZCODE_REVIEW_DENIED_TOOLS = CLAUDE_DENIED_DELEGATION_TOOLS + (
+    "Bash", "Write", "Edit", "NotebookEdit", "ApplyPatch", "CreateWorkflow",
+    "AmendWorkflow", "FillWorkflowHole", "ResumeWorkflowRun", "SaveWorkflow",
+    "OffPeakCreate", "CronCreate", "CronUpdate", "CronDelete",
+    "WebSearch", "WebFetch", "AskUserQuestion",
+    "EnterPlanMode", "ExitPlanMode", "ReplyToChannel",
+)
+
+
+def _zcode_command() -> tuple[list[str], dict[str, str]]:
+    """Use the official CLI, or the installed macOS app's headless runtime."""
+    cli = shutil.which("zcode")
+    if cli:
+        key = "ZCODE_BUILTIN_PROVIDER_CONFIG_FILE"
+        source = os.environ.get(key, "").strip()
+        if not source:
+            directory = pathlib.Path(cli).resolve().parent
+            candidates = (directory / "provider/zcode-builtin.json",
+                          (directory / "../../../../../config/provider/zcode-builtin.json").resolve())
+            source = next((str(path) for path in candidates if path.is_file()), "")
+        if not source:
+            raise ValueError("Cannot locate the PATH ZCode CLI's catalog; set "
+                             "ZCODE_BUILTIN_PROVIDER_CONFIG_FILE to that installation's JSON catalog")
+        return [cli], {key: source}
+    entry = _ZCODE_DESKTOP_RESOURCES / "glm" / "zcode.cjs"
+    builtin = _ZCODE_DESKTOP_RESOURCES / "config" / "provider" / "zcode-builtin.json"
+    node = shutil.which("node")
+    if sys.platform != "darwin" or not node or not entry.is_file() or not builtin.is_file():
+        raise ValueError("ZCode CLI is not on PATH and no installed macOS ZCode runtime was found")
+    return [node, str(entry)], {
+        "ZCODE_BUILTIN_PROVIDER_CONFIG_FILE": str(builtin),
+    }
+
+
+def _zcode_requested_selection(agent: Agent, reasoning: Optional[str]) -> dict:
+    if agent.extra_args:
+        raise ValueError("ZCode review backend does not accept extra_args; native policy must stay fixed")
+    if agent.role not in {"reviewer", "triage-reviewer", "planner"}:
+        raise ValueError("ZCode currently supports read-only reviewer/planner roles, not coder roles")
+    provider, separator, model = (agent.model or "").partition("/")
+    if not separator or not provider.startswith("account:") or not model:
+        raise ValueError("ZCode requires its native account provider/model ID, e.g. "
+                         "account:zai-individual-coding-plan/GLM-5.3")
+    pin = {"model": agent.model, "reasoning": reasoning}
+    if agent.session_id:
+        if not _ZCODE_SESSION_ID_RE.fullmatch(agent.session_id):
+            raise ValueError("ZCode requires an explicit sess_ session ID; cwd-based resume is unsafe")
+        if agent.zcode_selection != pin:
+            raise ValueError("ZCode resume requires its original model/effort pin; start a fresh peer to change them")
+    return {"providerId": provider, "modelId": model,
+            **({"options": {"reasoningLevel": reasoning}} if reasoning else {})}
+
+
+
+def _reject_zcode_json_constant(value: str):
+    raise ValueError("ZCode configuration must use strict JSON")
+
+
+def _zcode_resolved_provider(config: dict, provider: dict) -> dict:
+    concrete = provider["config"]
+    template_id = provider.get("templateId")
+    if not template_id:
+        return concrete
+    templates = [row for row in config["providerConfigRules"].get("templateRules", [])
+                 if row["templateId"] == template_id]
+    if len(templates) != 1:
+        raise ValueError("ZCode catalog has no unique provider template")
+    base = templates[0]["config"]
+    resolved = {**base, **concrete}
+    if isinstance(base.get("api"), dict) and isinstance(concrete.get("api"), dict):
+        resolved["api"] = {**base["api"], **concrete["api"]}
+    return resolved
+
+
+def _zcode_catalog(selection: dict, launch_env: dict[str, str]) -> dict:
+    source = launch_env.get("ZCODE_BUILTIN_PROVIDER_CONFIG_FILE") or os.environ.get(
+        "ZCODE_BUILTIN_PROVIDER_CONFIG_FILE")
+    if not source:
+        raise ValueError("ZCode needs ZCODE_BUILTIN_PROVIDER_CONFIG_FILE for its selected runtime; "
+                         "a PATH CLI must not use another installation's catalog")
+    data = json.loads(pathlib.Path(source).read_text(encoding="utf-8"),
+                      parse_constant=_reject_zcode_json_constant)
+    config = data["config"]
+    providers = config["providerConfigRules"]["providerRules"]
+    matches = [row for row in providers if row["providerId"] == selection["providerId"]]
+    if len(matches) != 1:
+        raise ValueError("Requested ZCode account model is absent from its native catalog")
+    provider = {**matches[0], "config": _zcode_resolved_provider(config, matches[0])}
+    if selection["modelId"] not in provider["config"].get("builtinModelIds", []):
+        raise ValueError("Requested ZCode account model is absent from its native catalog")
+    levels = _zcode_catalog_reasoning(config["modelConfigRules"], provider, selection["modelId"])
+    requested = selection.get("options", {}).get("reasoningLevel")
+    if requested is not None and requested not in levels:
+        raise ValueError("Requested ZCode reasoning level is absent from its native model catalog")
+    return data
+
+
+def _zcode_rule_url(value: str) -> str:
+    # Match native URL normalization for canonical HTTP(S) endpoints. Reject
+    # exotic forms rather than validate an effort against a different site.
+    if not re.fullmatch(r"[A-Za-z0-9:/?&#_~!$()*+,;=@.\[\]-]+", value):
+        raise ValueError("Unsupported ZCode catalog API URL")
+    url = urllib.parse.urlsplit(value)
+    host = url.hostname or ""
+    if (url.scheme not in {"http", "https"} or not host or url.username is not None
+            or ":" in host or host.rstrip(".").rsplit(".", 1)[-1].isdigit()
+            or host.rstrip(".").rsplit(".", 1)[-1].lower().startswith("0x")
+            or re.search(r"(?:^|/)\.{1,2}(?:/|$)", url.path)
+            or value.endswith(("?", "#")) or "?#" in value):
+        raise ValueError("Unsupported ZCode catalog API URL")
+    port = url.port
+    authority = host.lower()
+    if port is not None and port != {"http": 80, "https": 443}[url.scheme]:
+        authority += ":" + str(port)
+    endpoint = f"{url.scheme}://{authority}{url.path}".rstrip("/")
+    return endpoint + ("?" + url.query if url.query else "") + ("#" + url.fragment if url.fragment else "")
+
+
+def _zcode_catalog_reasoning(rules: dict, provider: dict, model: str) -> list[str]:
+    levels = []
+    api = provider["config"].get("api") or {}
+    subjects = {"modelMatch": model, "apiTypeMatch": api.get("type", ""),
+                "baseUrlMatch": _zcode_rule_url(api["baseUrl"]) if api.get("baseUrl") else ""}
+    for layer in ("modelRules", "modelApiRules", "providerSiteRules",
+                  "templateModelRules", "builtinProviderModelRules"):
+        for row in rules.get(layer, []):
+            if any(key in row and (not value or not re.fullmatch(
+                    row[key], value, re.IGNORECASE if key == "modelMatch" else 0))
+                   for key, value in subjects.items()):
+                continue
+            if row.get("modelId", model) != model:
+                continue
+            if row.get("providerId", provider["providerId"]) != provider["providerId"]:
+                continue
+            if "templateId" in row and row["templateId"] != provider.get("templateId"):
+                continue
+            specs = row.get("config", {}).get("optionSpecs", {})
+            if specs is None or ("reasoningLevel" in specs and specs["reasoningLevel"] is None):
+                levels = []
+                continue
+            reasoning = specs.get("reasoningLevel", {})
+            values = reasoning.get("values")
+            if "values" in reasoning and values is None:
+                levels = []
+                continue
+            if values is not None:
+                if not isinstance(values, list) or not all(isinstance(item, str) for item in values):
+                    raise ValueError("Unsupported ZCode native reasoning catalog shape")
+                levels = values
+    return levels
+
+
+def _zcode_permission_paths(cwd: pathlib.Path) -> list[pathlib.Path]:
+    directory = pathlib.Path(os.path.abspath(cwd))
+    ancestors = [directory, *directory.parents]
+    directories = [directory]
+    for index, parent in enumerate(ancestors):
+        if (parent / ".git").exists():
+            directories = list(reversed(ancestors[:index + 1]))
+            break
+    return [pathlib.Path.home() / ".zcode/cli/config.json", *[
+        path for folder in directories for path in (folder / "zcode.json", folder / ".zcode/config.json")]]
+
+
+def _zcode_permission_denials(cwd: pathlib.Path) -> tuple[list[str], dict]:
+    denied = list(_ZCODE_REVIEW_DENIED_TOOLS)
+    fingerprints = {}
+    mcp_disabled = False
+    for path in _zcode_permission_paths(cwd):
+        try:
+            raw = path.read_bytes()
+        except FileNotFoundError:
+            fingerprints[path] = None
+            continue
+        except OSError:
+            raise ValueError("Cannot read a native ZCode permission configuration") from None
+        fingerprints[path] = hashlib.sha256(raw).hexdigest()
+        try:
+            data = json.loads(raw.decode("utf-8"), parse_constant=_reject_zcode_json_constant)
+            permission = data.get("permission", {})
+            rules = permission.get("disallowedTools", [])
+            if (not isinstance(data, dict) or not isinstance(permission, dict)
+                    or not isinstance(rules, list) or not all(isinstance(rule, str) for rule in rules)
+                    or permission.get("allowedTools")):
+                raise ValueError()
+            if "features" in data:
+                if not isinstance(data["features"], dict):
+                    raise ValueError()
+                # Native ignores a whole invalid document. Certify only the
+                # minimal schema we validate completely, not a richer file
+                # whose unrelated fields could cause MCP=false to be skipped.
+                mcp_disabled = (set(data) == {"features"}
+                                and set(data["features"]) == {"mcp"}
+                                and data["features"]["mcp"] is False)
+            # CLI accepts comma/space-separated whole-tool names. Normalize
+            # native command-pattern denials conservatively to the whole tool.
+            for rule in rules:
+                name = rule.strip().split("(", 1)[0].strip()
+                if not name or re.search(r"[\s,]", name):
+                    raise ValueError()
+                denied.append(name)
+        except (ValueError, AttributeError, TypeError):
+            raise ValueError("Unsupported native ZCode permission configuration; refusing to replace it") from None
+    if not mcp_disabled:
+        raise ValueError("ZCode review requires native features.mcp=false; plan mode permits some MCP writes")
+    return list(dict.fromkeys(denied)), fingerprints
+
+
+def _zcode_check_permission_inputs(cwd: pathlib.Path, expected: dict) -> None:
+    _, current = _zcode_permission_denials(cwd)
+    if current != expected:
+        raise ValueError("Native ZCode permission configuration changed before launch")
+
+
+@contextlib.contextmanager
+def _zcode_peer_profile(selection: dict, launch_env: dict[str, str]):
+    # Native headless CLI has no model/effort flags. Its supported provider
+    # profile carries only this peer's choice; auth stays in ZCode's store.
+    catalog = _zcode_catalog(selection, launch_env)
+    config = catalog["config"]
+    providers = config["providerConfigRules"]["providerRules"]
+    # Native defaults may fall back. Expose only the requested account/model;
+    # an unavailable selection must fail before any other model is invoked.
+    hidden = [{"providerId": row["providerId"], "config": {"visibility": "hidden"}}
+              for row in providers if row["providerId"] != selection["providerId"]]
+    disabled = [{"providerId": row["providerId"], "modelId": model,
+                 "config": {"enabled": False}}
+                for row in providers
+                for model in [*_zcode_resolved_provider(config, row).get("builtinModelIds", []),
+                              *_zcode_resolved_provider(config, row).get("personalModelIds", [])]
+                if (row["providerId"], model) != (selection["providerId"], selection["modelId"])]
+    reasoning = selection.get("options", {}).get("reasoningLevel")
+    if reasoning is not None:
+        # Narrow only after native-catalog validation. A session edited outside
+        # Duet must not resume with another still-supported effort silently.
+        disabled.append({"providerId": selection["providerId"], "modelId": selection["modelId"],
+                         "config": {"optionSpecs": {"reasoningLevel": {"values": [reasoning]}}}})
+    with tempfile.TemporaryDirectory(prefix="duet-zcode-") as directory:
+        profile = pathlib.Path(directory) / "provider.json"
+        config = {"schemaVersion": 1, "config": {
+            "providerConfigRules": {"providerRules": hidden},
+            "modelConfigRules": {"providerModelRules": disabled, "manualProviderModelRules": []},
+            "defaultModelSelection": selection,
+        }}
+        write_text_atomic(profile, json.dumps(config))
+        profile.chmod(0o600)
+        builtin = pathlib.Path(directory) / "builtin.json"
+        write_text_atomic(builtin, json.dumps(catalog))
+        builtin.chmod(0o600)
+        yield {**launch_env, "ZCODE_PERSONAL_PROVIDER_CONFIG_FILE": str(profile),
+               "ZCODE_BUILTIN_PROVIDER_CONFIG_FILE": str(builtin),
+               "ZCODE_BUILTIN_PROVIDER_BUNDLED_CONFIG_FILE": ""}
+
+
+def _parse_zcode_reply(stdout: str) -> tuple[str, str]:
+    try:
+        result = json.loads(stdout)
+    except (ValueError, TypeError) as exc:
+        raise ValueError("ZCode did not return a JSON summary") from exc
+    if not isinstance(result, dict):
+        raise ValueError("ZCode JSON summary must be an object")
+    session = result.get("sessionId")
+    response = result.get("response")
+    if not isinstance(session, str) or not _ZCODE_SESSION_ID_RE.fullmatch(session):
+        raise ValueError("ZCode JSON summary has no valid sessionId")
+    if not isinstance(response, str) or not response.strip():
+        raise ValueError("ZCode JSON summary has no assistant response")
+    projection = result.get("projection") or {}
+    if result.get("error") or not isinstance(projection, dict) or projection.get("status") in {"error", "failed"}:
+        raise ValueError("ZCode reported a failed turn")
+    return response, session
+
+
+def call_zcode(agent: Agent, system_prompt: str, message: str,
+               cwd: pathlib.Path, timeout: int, dry: bool,
+               reasoning: Optional[str] = None,
+               stderr_log_path: Optional[pathlib.Path] = None,
+               pid_file_path: Optional[pathlib.Path] = None) -> tuple[str, Optional[str]]:
+    selection = _zcode_requested_selection(agent, reasoning)
+    pin = {"model": agent.model, "reasoning": reasoning}
+    if dry:
+        session = agent.session_id or "sess_dry_" + agent.name
+        agent.zcode_selection = pin
+        return (f"[dry-run zcode/{agent.name} reasoning={reasoning}] received {len(message)} chars\n"
+                "LGTM rationale: dry-run validates the launch only, not a model response.\n"
+                + DEFAULT_SENTINEL), session
+    try:
+        command, launch_env = _zcode_command()
+        native_cwd = pathlib.Path(agent.cwd_override or cwd)
+        denied, permission_inputs = _zcode_permission_denials(native_cwd)
+        command += ["--cwd", str(native_cwd), "--mode", "plan",
+                    "--workflow-mode", "disabled", "--json", "--no-color",
+                    "--disallowed-tools", ",".join(denied)]
+        if agent.session_id:
+            command += ["--resume", agent.session_id]
+        command += ["--prompt", f"=== ROLE ===\n{system_prompt}\n\n=== MESSAGE FROM PARTNER ===\n{message}"]
+        with _zcode_peer_profile(selection, launch_env) as env:
+            _zcode_check_permission_inputs(native_cwd, permission_inputs)
+            rc, out, err = _run(command, cwd=agent.cwd_override or cwd, stdin=None,
+                                timeout=timeout, stderr_log_path=stderr_log_path,
+                                pid_file_path=pid_file_path, env_overrides=env)
+        if rc != 0:
+            reason = FINISHED_TIMEOUT if rc == 124 else FINISHED_AGENT_ERROR
+            raise AgentRunError(reason, _agent_exit_error("zcode", rc, out, err))
+        response, session = _parse_zcode_reply(out)
+        if agent.session_id and session != agent.session_id:
+            raise ValueError("ZCode changed its pinned sessionId; refusing an unrelated conversation")
+    except AgentRunError:
+        raise
+    except Exception as exc:
+        raise AgentRunError(FINISHED_AGENT_ERROR, f"ZCode invocation failed: {exc}") from exc
+    agent.zcode_selection = pin
+    _metrics_record_raw_output(agent, out)
+    return response, session
+
+
+def _call_zcode_backend(agent: Agent, system_prompt: str, message: str,
+                        cfg: DuetConfig, first_turn: bool,
+                        stderr_log_path: Optional[pathlib.Path],
+                        pid_file_path: Optional[pathlib.Path],
+                        reasoning: Optional[str]) -> tuple[str, Optional[str]]:
+    return call_zcode(agent, system_prompt, message, cfg.cwd,
+                      cfg.per_turn_timeout, cfg.dry_run, reasoning,
+                      stderr_log_path, pid_file_path)
+
+
 BACKENDS = {
     "claude": BackendAdapter(
         name="claude",
@@ -2500,6 +2842,10 @@ BACKENDS = {
         reasoning_map=COPILOT_REASONING_MAP,
         reasoning_prompt_prefix=COPILOT_REASONING_PROMPT_PREFIX,
     ),
+    "zcode": BackendAdapter(
+        name="zcode", binary="zcode", call=_call_zcode_backend,
+        reasoning_map={level: level for level in REASONING_LEVELS}, reasoning_prompt_prefix={},
+    ),
     "opencode": BackendAdapter(
         name="opencode",
         binary="opencode",
@@ -6386,6 +6732,7 @@ def _agents_from_state(state: dict,
             role_prompt=(str(raw["role_prompt"]) if raw.get("role_prompt") else None),
             model=(str(raw["model"]) if raw.get("model") else None),
             session_id=(str(raw["session_id"]) if raw.get("session_id") else None),
+            zcode_selection=raw.get("zcode_selection"),
             extra_args=[str(x) for x in raw_extra_args],
             reasoning_effort=(str(raw["reasoning_effort"])
                               if raw.get("reasoning_effort") else None),
@@ -7119,9 +7466,9 @@ def _build_arg_parser() -> argparse.ArgumentParser:
     ap.add_argument("--task-from-cmd", metavar="CMD",
                     help="run shell command with cwd=--cwd and use stdout as the task")
     ap.add_argument("--partner", default=None,
-                    help="partner agent spec, e.g. codex:coder, claude:reviewer, gemini:coder, copilot:coder, opencode:coder (default codex:coder)")
+                    help="partner agent spec, e.g. codex:coder, claude:reviewer, gemini:coder, copilot:coder, opencode:coder, zcode:reviewer (default codex:coder)")
     ap.add_argument("--lead", default=None,
-                    help="lead agent spec, e.g. claude:planner, gemini:reviewer, copilot:planner, opencode:planner (default; ignored if --resume-claude given)")
+                    help="lead agent spec, e.g. claude:planner, gemini:reviewer, copilot:planner, opencode:planner, zcode:reviewer (default; ignored if --resume-claude given)")
     ap.add_argument("--lead-model", metavar="MODEL", default=None,
                     help="lead backend model via --model; Claude defaults to 'sonnet'")
     ap.add_argument("--partner-model", metavar="MODEL", default=None,
@@ -7153,9 +7500,9 @@ def _build_arg_parser() -> argparse.ArgumentParser:
                     help="atomically write the new run's schema-v1 launch JSON; "
                          "refuses to overwrite FILE")
     ap.add_argument("--sandbox", default=None,
-                    help="codex --sandbox: read-only|workspace-write|danger-full-access. No-op for claude/gemini/copilot/opencode.")
+                    help="codex --sandbox: read-only|workspace-write|danger-full-access. No-op for claude/gemini/copilot/opencode/zcode.")
     ap.add_argument("--permission-mode", default=None,
-                    help="claude --permission-mode; gemini maps default/acceptEdits/plan/bypassPermissions to --approval-mode. No-op for copilot/opencode.")
+                    help="claude --permission-mode; gemini maps default/acceptEdits/plan/bypassPermissions to --approval-mode. No-op for copilot/opencode/zcode.")
     ap.add_argument("--config", help="optional YAML/JSON config (overrides flags except --resume-*)")
     worktree_group = ap.add_mutually_exclusive_group()
     worktree_group.add_argument(
@@ -7637,6 +7984,12 @@ def _warn_missing_backends(cfg: DuetConfig) -> None:
         return
     for backend in {a.backend for a in cfg.agents}:
         binary = backend_adapter(backend).binary
+        if backend == "zcode":
+            try:
+                _zcode_command()
+                continue
+            except ValueError:
+                pass
         if shutil.which(binary) is None:
             print(
                 f"[duet] WARNING: '{binary}' not on PATH — this run will fail. "

{duet_cli-0.2.16 → duet_cli-0.2.17/duet_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: duet-cli
-Version: 0.2.16
+Version: 0.2.17
 Summary: Two CLI agents in conversation. One Python file. Stdlib only.
 Author: Volkan Altan
 License-Expression: MIT
@@ -29,7 +29,8 @@ and you get a saved transcript to inspect.
 
 Run **two different models through a single agent harness (CLI)**, such as
 Codex or OpenCode. You can also pair different CLIs, such as Claude Code and
-Codex. Gemini and Copilot are also supported.
+Codex. Gemini and Copilot are also supported. A native ZCode account can
+provide a [read-only review peer](https://github.com/volkan/duet/blob/main/docs/ZCODE.md).
 [See examples using one CLI](https://github.com/volkan/duet/blob/main/docs/USAGE.md#same-backend-peering).
 
 [![Watch the 80-second review workflow demo](https://raw.githubusercontent.com/volkan/duet/main/docs/demos/finding-review.png)](https://github.com/volkan/duet/blob/main/docs/demos/finding-review.mp4)
@@ -63,19 +64,21 @@ This starts a review and fix loop with the coder in a separate Git worktree.
 Inspect the changes before merging; agent agreement does not prove correctness.
 
 Already working inside an agent? Install the **same Duet skill** for Claude
-Code, Codex, and OpenCode (requires Node.js/npm; choose **Symlink**):
+Code, Codex, OpenCode, and ZCode (requires Node.js/npm; choose **Symlink**):
 
 ```bash
 npx skills add volkan/duet --skill duet --global \
-  --agent claude-code --agent codex --agent opencode
+  --agent claude-code --agent codex --agent opencode --agent zcode
 ```
 
-Start a new session, then use `/duet` in Claude Code, `$duet` in Codex, or ask
-OpenCode to use the `duet` skill.
+Start a new session. Use `/duet` in Claude Code, `$duet` in Codex, or `/skill duet` in ZCode.
+Ask OpenCode to use the `duet` skill.
 [Installation details](https://github.com/volkan/duet/blob/main/docs/INSTALLATION.md)
 cover `~/.agents/skills`, prerequisites, and alternative installers. See the
 [OpenCode guide](https://github.com/volkan/duet/blob/main/docs/OPENCODE_PLUGIN.md)
 for its native skill and optional command wrapper.
+The [ZCode guide](https://github.com/volkan/duet/blob/main/docs/ZCODE.md#host-shortcuts)
+provides its `/duet` shortcut and native peer setup.
 
 ## Native plugin installation
 

{duet_cli-0.2.16 → duet_cli-0.2.17}/duet_cli.egg-info/SOURCES.txt

@@ -15,9 +15,11 @@ tests/test_duet.py
 tests/test_feedback_concurrency.py
 tests/test_finding_reports.py
 tests/test_finding_workflow.py
+tests/test_loop_run_info.py
 tests/test_metrics_cli.py
 tests/test_metrics_collection.py
 tests/test_metrics_lifecycle.py
 tests/test_metrics_reporting.py
 tests/test_no_subagents.py
-tests/test_stop_control_plane.py
+tests/test_stop_control_plane.py
+tests/test_zcode_backend.py

duet_cli-0.2.17/tests/test_loop_run_info.py

@@ -0,0 +1,51 @@
+"""The live loop driver must not discover runs from human-readable output."""
+import importlib.util
+import json
+import pathlib
+import sys
+import tempfile
+import unittest
+
+
+_SPEC = importlib.util.spec_from_file_location(
+    "duet_loop_driver_test", pathlib.Path(__file__).parents[1] / "scripts/duet_loop_e2e.py",
+)
+DRIVER = importlib.util.module_from_spec(_SPEC)
+sys.modules[_SPEC.name] = DRIVER
+_SPEC.loader.exec_module(DRIVER)
+
+
+class TestLoopRunInfo(unittest.TestCase):
+    def test_accepts_schema_one_handoff(self):
+        with tempfile.TemporaryDirectory() as directory:
+            path = pathlib.Path(directory) / "run-info.json"
+            payload = self.payload(path.parent)
+            path.write_text(json.dumps(payload), encoding="utf-8")
+            self.assertEqual(DRIVER.extract_run_dir(path), pathlib.Path(payload["run_dir"]))
+
+    def test_banner_cannot_replace_launch_document(self):
+        with tempfile.TemporaryDirectory() as directory:
+            path = pathlib.Path(directory) / "run-info.json"
+            self.assertIsNone(DRIVER.extract_run_dir(path))
+            path.write_text("[duet] run: /tmp/spoofed\n", encoding="utf-8")
+            self.assertIsNone(DRIVER.extract_run_dir(path))
+
+    def test_rejects_incompatible_or_incomplete_handoffs(self):
+        with tempfile.TemporaryDirectory() as directory:
+            path = pathlib.Path(directory) / "run-info.json"
+            overrides = [
+                {"schema_version": 2}, {"schema_version": True}, {"kind": "duet.status"},
+                {"run_id": ""}, {"pid": True}, {"pid": "42"},
+                {"run_dir": "relative"}, {"state_path": "relative"}, {"run_dir": None},
+            ]
+            for override in overrides:
+                with self.subTest(override=override):
+                    path.write_text(json.dumps({**self.payload(path.parent), **override}), encoding="utf-8")
+                    self.assertIsNone(DRIVER.extract_run_dir(path))
+            path.write_text("[]", encoding="utf-8")
+            self.assertIsNone(DRIVER.extract_run_dir(path))
+
+    @staticmethod
+    def payload(root):
+        return {"schema_version": 1, "kind": "duet.run", "run_id": "test-run", "pid": 42,
+                "run_dir": str(root / "run"), "state_path": str(root / "run/state.json")}

duet_cli-0.2.17/tests/test_zcode_backend.py

@@ -0,0 +1,439 @@
+"""Native ZCode profile, resume, and failure contracts; no provider requests."""
+from __future__ import annotations
+
+import argparse
+import json
+import importlib.util
+import types
+import os
+import pathlib
+import sys
+import tempfile
+import unittest
+from unittest import mock
+
+ROOT = pathlib.Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+import duet
+
+
+class ZCodeBackendTests(unittest.TestCase):
+    def setUp(self):
+        self.directory = tempfile.TemporaryDirectory()
+        self.addCleanup(self.directory.cleanup)
+        self.cwd = pathlib.Path(self.directory.name)
+        (self.cwd / "zcode.json").write_text(json.dumps({"features": {"mcp": False}}))
+        self.home = self.cwd / "home"
+        home_patch = mock.patch.object(pathlib.Path, "home", return_value=self.home)
+        home_patch.start()
+        self.addCleanup(home_patch.stop)
+        self.agent = duet.Agent(name="glm", backend="zcode", role="reviewer",
+                                model="account:zai-individual-coding-plan/GLM-5.3")
+        self.catalog = self.cwd / "catalog.json"
+        self.catalog.write_text(json.dumps({"schemaVersion": 1, "config": {
+            "providerConfigRules": {"providerRules": [
+                {"providerId": "account:zai-individual-coding-plan", "config": {
+                    "builtinModelIds": ["GLM-5.3", "GLM-5.3-Flash"],
+                    "api": {"type": "anthropic-messages", "baseUrl": "https://api.example"}}},
+                {"providerId": "account:other", "config": {"builtinModelIds": ["other"]}},
+            ]},
+            "modelConfigRules": {"modelRules": [
+                {"modelMatch": ".*glm-5.*", "config": {"optionSpecs": {
+                    "reasoningLevel": {"values": ["low", "high", "max"]}}}}],
+                "modelApiRules": [], "providerSiteRules": [],
+                "templateModelRules": [], "builtinProviderModelRules": []},
+        }}))
+        self.launch = mock.patch.object(duet, "_zcode_command", return_value=(
+            ["zcode"], {"ZCODE_BUILTIN_PROVIDER_CONFIG_FILE": str(self.catalog)}))
+        self.launch.start()
+        self.addCleanup(self.launch.stop)
+
+    def invoke(self, **overrides):
+        args = dict(agent=self.agent, system_prompt="system {literal}", message="peer message",
+                    cwd=self.cwd, timeout=60, dry=False, reasoning="max")
+        args.update(overrides)
+        return duet.call_zcode(**args)
+
+    @staticmethod
+    def result(session="sess_abc", response="review complete", **kwargs):
+        return 0, json.dumps(dict(sessionId=session, response=response, **kwargs)), ""
+
+    def test_fresh_call_uses_private_profile_and_native_read_only_policy(self):
+        seen = {}
+
+        def run(command, **kwargs):
+            profile = pathlib.Path(kwargs["env_overrides"]["ZCODE_PERSONAL_PROVIDER_CONFIG_FILE"])
+            seen["profile"] = profile
+            data = json.loads(profile.read_text())
+            self.assertEqual(0o600, profile.stat().st_mode & 0o777)
+            self.assertEqual([{ "providerId": "account:other", "config": {"visibility": "hidden"}}],
+                             data["config"]["providerConfigRules"]["providerRules"])
+            self.assertEqual([
+                {"providerId": "account:zai-individual-coding-plan", "modelId": "GLM-5.3-Flash",
+                 "config": {"enabled": False}},
+                {"providerId": "account:zai-individual-coding-plan", "modelId": "GLM-5.3",
+                 "config": {"optionSpecs": {"reasoningLevel": {"values": ["max"]}}}},
+                {"providerId": "account:other", "modelId": "other", "config": {"enabled": False}},
+            ], sorted(data["config"]["modelConfigRules"]["providerModelRules"],
+                      key=lambda row: (row["providerId"] == "account:other", row["modelId"] == "GLM-5.3")))
+            self.assertEqual({"providerId": "account:zai-individual-coding-plan",
+                              "modelId": "GLM-5.3", "options": {"reasoningLevel": "max"}},
+                             data["config"]["defaultModelSelection"])
+            self.assertNotIn("apiKey", profile.read_text())
+            self.assertEqual("plan", command[command.index("--mode") + 1])
+            self.assertEqual("disabled", command[command.index("--workflow-mode") + 1])
+            denied = command[command.index("--disallowed-tools") + 1].split(",")
+            for tool in ("Task", "Agent", "Skill", "Bash", "Write", "Edit", "CreateWorkflow",
+                         "AmendWorkflow", "FillWorkflowHole", "ResumeWorkflowRun", "SaveWorkflow",
+                         "OffPeakCreate", "CronCreate", "CronUpdate", "CronDelete"):
+                self.assertIn(tool, denied)
+            self.assertNotIn("OffPeakTask", denied)
+            self.assertNotIn("RunWorkflow", denied)
+            self.assertNotIn("--resume", command)
+            self.assertIn("system {literal}", command[-1])
+            self.assertIsNone(kwargs["stdin"])
+            return self.result()
+
+        with mock.patch.object(duet, "_run", side_effect=run), mock.patch.dict(os.environ, {"TEST_SECRET": "not-in-profile"}):
+            before = dict(os.environ)
+            reply, session = self.invoke()
+            self.assertEqual(before, dict(os.environ))
+        self.assertEqual(("review complete", "sess_abc"), (reply, session))
+        self.assertFalse(seen["profile"].exists())
+        self.assertEqual({"model": self.agent.model, "reasoning": "max"}, self.agent.zcode_selection)
+
+    def test_resume_is_pinned_and_reasserts_policy(self):
+        with mock.patch.object(duet, "_run", return_value=self.result()) as run:
+            _, self.agent.session_id = self.invoke()
+            self.invoke()
+        command = run.call_args.args[0]
+        self.assertEqual("sess_abc", command[command.index("--resume") + 1])
+        self.assertIn("--disallowed-tools", command)
+        self.assertNotIn("--continue", command)
+
+    def test_resume_rejects_model_or_effort_change_before_start(self):
+        self.agent.session_id = "sess_abc"
+        self.agent.zcode_selection = {"model": self.agent.model, "reasoning": "high"}
+        with mock.patch.object(duet, "_run") as run:
+            with self.assertRaisesRegex(ValueError, "original model/effort"):
+                self.invoke()
+            run.assert_not_called()
+
+    def test_untracked_native_session_cannot_be_resumed(self):
+        self.agent.session_id = "sess_external"
+        with self.assertRaisesRegex(ValueError, "original model/effort"):
+            self.invoke()
+
+    def test_cwd_resume_and_extra_args_are_rejected(self):
+        self.agent.session_id = "latest"
+        with self.assertRaisesRegex(ValueError, "explicit sess_"):
+            self.invoke()
+        self.agent.session_id = None
+        self.agent.extra_args = ["--mode", "yolo"]
+        with self.assertRaisesRegex(ValueError, "extra_args"):
+            self.invoke()
+
+    def test_only_native_account_model_ids_are_accepted(self):
+        for model in (None, "GLM-5.3", "opencode/glm-5.3", "account:zai/"):
+            with self.subTest(model=model):
+                self.agent.model = model
+                with self.assertRaisesRegex(ValueError, "native account"):
+                    self.invoke()
+
+    def test_coder_role_is_rejected(self):
+        self.agent.role = "coder"
+        with self.assertRaisesRegex(ValueError, "read-only"):
+            self.invoke()
+
+    def test_profile_is_removed_on_failure_and_does_not_publish_pin(self):
+        paths = []
+
+        def run(command, **kwargs):
+            paths.append(pathlib.Path(kwargs["env_overrides"]["ZCODE_PERSONAL_PROVIDER_CONFIG_FILE"]))
+            return 1, "", "Select a model before continuing"
+
+        with mock.patch.object(duet, "_run", side_effect=run):
+            with self.assertRaises(duet.AgentRunError) as caught:
+                self.invoke()
+        self.assertEqual(duet.FINISHED_AGENT_ERROR, caught.exception.finished_reason)
+        self.assertFalse(paths[0].exists())
+        self.assertIsNone(self.agent.zcode_selection)
+
+    def test_timeout_has_the_existing_timeout_contract(self):
+        with mock.patch.object(duet, "_run", return_value=(124, "", "timeout")):
+            with self.assertRaises(duet.AgentRunError) as caught:
+                self.invoke()
+        self.assertEqual(duet.FINISHED_TIMEOUT, caught.exception.finished_reason)
+
+    def test_session_change_is_not_accepted(self):
+        self.agent.session_id = "sess_expected"
+        self.agent.zcode_selection = {"model": self.agent.model, "reasoning": "max"}
+        with mock.patch.object(duet, "_run", return_value=self.result("sess_different")):
+            with self.assertRaisesRegex(duet.AgentRunError, "changed its pinned"):
+                self.invoke()
+
+    def test_json_failure_and_missing_reply_are_not_success(self):
+        cases = ["not json", "[]", '{}', json.dumps({"sessionId": "sess_a", "response": ""}),
+                 json.dumps({"sessionId": "sess_a", "response": "partial", "projection": {"status": "error"}})]
+        for output in cases:
+            with self.subTest(output=output), mock.patch.object(duet, "_run", return_value=(0, output, "")):
+                with self.assertRaises(duet.AgentRunError):
+                    self.invoke()
+
+    def test_supported_reasoning_levels_are_native_profile_values(self):
+        for level in ("low", "high", "max"):
+            with self.subTest(level=level):
+                def run(command, **kwargs):
+                    profile = json.loads(pathlib.Path(kwargs["env_overrides"]["ZCODE_PERSONAL_PROVIDER_CONFIG_FILE"]).read_text())
+                    self.assertEqual(level, profile["config"]["defaultModelSelection"]["options"]["reasoningLevel"])
+                    return self.result()
+                with mock.patch.object(duet, "_run", side_effect=run):
+                    self.invoke(reasoning=level)
+
+    def test_invalid_catalog_selection_never_starts_a_model(self):
+        for level in ("minimal", "medium", "xhigh"):
+            with self.subTest(level=level), mock.patch.object(duet, "_run") as run:
+                with self.assertRaisesRegex(duet.AgentRunError, "reasoning level is absent"):
+                    self.invoke(reasoning=level)
+                run.assert_not_called()
+        self.agent.model = "account:zai-individual-coding-plan/missing-model"
+        with mock.patch.object(duet, "_run") as run:
+            with self.assertRaisesRegex(duet.AgentRunError, "account model is absent"):
+                self.invoke()
+            run.assert_not_called()
+
+    def test_catalog_layers_preserve_provider_specific_effort_values(self):
+        data = json.loads(self.catalog.read_text())
+        data["config"]["modelConfigRules"]["modelApiRules"] = [
+            {"modelMatch": "glm-5\\.3", "apiTypeMatch": "anthropic-messages",
+             "config": {"optionSpecs": {"reasoningLevel": {"values": ["high"]}}}},
+        ]
+        self.catalog.write_text(json.dumps(data))
+        with mock.patch.object(duet, "_run") as run:
+            with self.assertRaisesRegex(duet.AgentRunError, "reasoning level is absent"):
+                self.invoke(reasoning="max")
+            run.assert_not_called()
+
+    def test_catalog_patterns_are_anchored_and_api_case_is_preserved(self):
+        data = json.loads(self.catalog.read_text())
+        data["config"]["modelConfigRules"]["modelApiRules"] = [
+            {"modelMatch": "glm-5", "apiTypeMatch": "anthropic-messages",
+             "config": {"optionSpecs": {"reasoningLevel": {"values": ["low"]}}}},
+            {"modelMatch": "glm-5\\.3", "apiTypeMatch": "ANTHROPIC-MESSAGES",
+             "config": {"optionSpecs": {"reasoningLevel": {"values": ["low"]}}}},
+        ]
+        self.catalog.write_text(json.dumps(data))
+        with mock.patch.object(duet, "_run", return_value=self.result()):
+            self.invoke(reasoning="max")
+
+    def test_path_cli_does_not_borrow_desktop_catalog(self):
+        selection = {"providerId": "account:zai-individual-coding-plan", "modelId": "GLM-5.3"}
+        with mock.patch.dict(os.environ, {}, clear=True):
+            with self.assertRaisesRegex(ValueError, "another installation's catalog"):
+                duet._zcode_catalog(selection, {})
+
+    def test_path_cli_resolves_catalog_from_its_real_installation(self):
+        self.launch.stop()
+        for bundled in (True, False):
+            with self.subTest(bundled=bundled):
+                installation = self.cwd / str(bundled)
+                entry = installation / "apps/zcode-cli/packages/cli/dist/zcode.cjs"
+                entry.parent.mkdir(parents=True)
+                entry.write_text("// native entry")
+                catalog = (entry.parent / "provider/zcode-builtin.json" if bundled else
+                           installation / "config/provider/zcode-builtin.json")
+                catalog.parent.mkdir(parents=True)
+                catalog.write_text(self.catalog.read_text())
+                link = installation / "zcode"
+                link.symlink_to(entry)
+                with mock.patch.object(duet.shutil, "which", return_value=str(link)), \
+                        mock.patch.dict(os.environ, {"ZCODE_BUILTIN_PROVIDER_CONFIG_FILE": ""}):
+                    command, env = duet._zcode_command()
+                self.assertEqual([str(link)], command)
+                self.assertEqual(str(catalog.resolve()), env["ZCODE_BUILTIN_PROVIDER_CONFIG_FILE"])
+                selection = {"providerId": "account:zai-individual-coding-plan", "modelId": "GLM-5.3"}
+                self.assertEqual(json.loads(catalog.read_text()), duet._zcode_catalog(selection, env))
+
+    def test_path_cli_honors_explicit_catalog(self):
+        self.launch.stop()
+        with mock.patch.object(duet.shutil, "which", return_value="/runtime/zcode"), \
+                mock.patch.dict(os.environ, {"ZCODE_BUILTIN_PROVIDER_CONFIG_FILE": str(self.catalog)}):
+            command, env = duet._zcode_command()
+        self.assertEqual(["/runtime/zcode"], command)
+        self.assertEqual(str(self.catalog), env["ZCODE_BUILTIN_PROVIDER_CONFIG_FILE"])
+
+    def test_missing_path_catalog_does_not_borrow_desktop_catalog(self):
+        self.launch.stop()
+        desktop = self.cwd / "desktop"
+        catalog = desktop / "config/provider/zcode-builtin.json"
+        catalog.parent.mkdir(parents=True)
+        catalog.write_text(self.catalog.read_text())
+        entry = desktop / "glm/zcode.cjs"
+        entry.parent.mkdir()
+        entry.write_text("// desktop entry")
+        with mock.patch.object(duet, "_ZCODE_DESKTOP_RESOURCES", desktop), \
+                mock.patch.object(duet.shutil, "which", return_value=str(self.cwd / "cli/zcode")), \
+                mock.patch.dict(os.environ, {"ZCODE_BUILTIN_PROVIDER_CONFIG_FILE": ""}):
+            with self.assertRaisesRegex(ValueError, "PATH ZCode CLI's catalog"):
+                duet._zcode_command()
+
+    def test_catalog_snapshot_freezes_validation_and_disables_remote_refresh(self):
+        before = json.loads(self.catalog.read_text())
+        snapshots = []
+
+        def run(command, **kwargs):
+            env = kwargs["env_overrides"]
+            snapshot = pathlib.Path(env["ZCODE_BUILTIN_PROVIDER_CONFIG_FILE"])
+            snapshots.append(snapshot)
+            self.catalog.write_text('{"changed":true}')
+            self.assertEqual(before, json.loads(snapshot.read_text()))
+            self.assertEqual(0o600, snapshot.stat().st_mode & 0o777)
+            self.assertEqual("", env["ZCODE_BUILTIN_PROVIDER_BUNDLED_CONFIG_FILE"])
+            return self.result()
+
+        with mock.patch.dict(os.environ, {"ZCODE_BUILTIN_PROVIDER_BUNDLED_CONFIG_FILE": "elsewhere"}), \
+                mock.patch.object(duet, "_run", side_effect=run):
+            self.invoke()
+            self.assertEqual("elsewhere", os.environ["ZCODE_BUILTIN_PROVIDER_BUNDLED_CONFIG_FILE"])
+        self.assertFalse(snapshots[0].exists())
+
+    def test_native_site_url_normalization_and_template_api_inheritance(self):
+        data = json.loads(self.catalog.read_text())
+        provider = data["config"]["providerConfigRules"]["providerRules"][0]
+        provider["templateId"] = "native-template"
+        del provider["config"]["api"]
+        data["config"]["providerConfigRules"]["templateRules"] = [{
+            "templateId": "native-template", "config": {"api": {
+                "type": "anthropic-messages", "baseUrl": "https://API.Example:443/"}}}]
+        data["config"]["modelConfigRules"]["providerSiteRules"] = [{
+            "modelMatch": "glm-5\\.3", "apiTypeMatch": "anthropic-messages",
+            "baseUrlMatch": "https://api\\.example",
+            "config": {"optionSpecs": {"reasoningLevel": {"values": ["high"]}}}}]
+        self.catalog.write_text(json.dumps(data))
+        with mock.patch.object(duet, "_run") as run:
+            with self.assertRaisesRegex(duet.AgentRunError, "reasoning level is absent"):
+                self.invoke(reasoning="max")
+            run.assert_not_called()
+        with mock.patch.object(duet, "_run", return_value=self.result()):
+            self.invoke(reasoning="high")
+        self.assertEqual("https://api.example/Path?q=Value#Section",
+                         duet._zcode_rule_url("https://API.Example:443/Path/?q=Value#Section"))
+        for unsupported in ("https://api.example/%2e/", "https://api.example/../", "https://api.example/?",
+                            "https://user@api.example", "https://127.1", "https://0x7f000001/a",
+                            "https://127.1./a", "https://api.example/a b"):
+            with self.subTest(url=unsupported), self.assertRaises(ValueError):
+                duet._zcode_rule_url(unsupported)
+
+    def test_native_null_option_spec_clears_inherited_reasoning(self):
+        data = json.loads(self.catalog.read_text())
+        data["config"]["modelConfigRules"]["builtinProviderModelRules"] = [{
+            "providerId": "account:zai-individual-coding-plan", "modelId": "GLM-5.3",
+            "config": {"optionSpecs": {"reasoningLevel": None}}}]
+        self.catalog.write_text(json.dumps(data))
+        with mock.patch.object(duet, "_run") as run:
+            with self.assertRaisesRegex(duet.AgentRunError, "reasoning level is absent"):
+                self.invoke()
+            run.assert_not_called()
+
+    def test_native_null_reasoning_values_clear_inherited_levels(self):
+        provider = {"providerId": "account:a", "config": {}}
+        rules = {"modelRules": [
+            {"modelMatch": ".*", "config": {"optionSpecs": {"reasoningLevel": {"values": ["high", "max"]}}}},
+            {"modelMatch": ".*", "config": {"optionSpecs": {"reasoningLevel": {"values": None}}}},
+        ]}
+        self.assertEqual([], duet._zcode_catalog_reasoning(rules, provider, "GLM-5.3"))
+
+    def test_mcp_must_be_disabled_by_native_config_before_review(self):
+        path = self.cwd / "zcode.json"
+        for data in ({}, {"features": {"mcp": True}}, {"features": {"skill": False}},
+                     {"features": {"mcp": False, "skill": "false"}},
+                     {"features": {"mcp": False}, "network": {"timeout": "bad"}},
+                     {"features": {"mcp": 0}}):
+            with self.subTest(data=data), mock.patch.object(duet, "_run") as run:
+                path.write_text(json.dumps(data))
+                with self.assertRaisesRegex(duet.AgentRunError, "native features.mcp=false"):
+                    self.invoke()
+                run.assert_not_called()
+
+    def test_utf16_policy_cannot_certify_native_utf8_configuration(self):
+        (self.cwd / "zcode.json").write_bytes('{"features":{"mcp":false}}'.encode("utf-16"))
+        with mock.patch.object(duet, "_run") as run:
+            with self.assertRaisesRegex(duet.AgentRunError, "Unsupported native ZCode permission"):
+                self.invoke()
+            run.assert_not_called()
+
+    def test_native_user_and_project_denials_survive_cli_overrides(self):
+        (self.cwd / ".git").mkdir()
+        child = self.cwd / "subdir"
+        child.mkdir()
+        paths = duet._zcode_permission_paths(child)
+        self.assertEqual([self.home / ".zcode/cli/config.json", self.cwd / "zcode.json",
+                          self.cwd / ".zcode/config.json", child / "zcode.json", child / ".zcode/config.json"], paths)
+        for path, data in [(paths[0], {"permission": {"disallowedTools": ["Read", "mcp__private__mutate"]}}),
+                           (paths[1], {"permission": {"disallowedTools": ["Grep", "Bash(git *)"]}}),
+                           (paths[2], {"features": {"mcp": False}}),
+                           (paths[-1], {"permission": {"mode": "yolo"}})]:
+            path.parent.mkdir(parents=True, exist_ok=True)
+            path.write_text(json.dumps(data))
+        with mock.patch.object(duet, "_run", return_value=self.result()) as run:
+            self.invoke(cwd=child)
+        command = run.call_args.args[0]
+        denied = command[command.index("--disallowed-tools") + 1].split(",")
+        self.assertTrue({"Read", "Grep", "Bash", "mcp__private__mutate"}.issubset(denied))
+        self.assertEqual("plan", command[command.index("--mode") + 1])
+        _, fingerprints = duet._zcode_permission_denials(child)
+        paths[-1].write_text('{"permission":{"disallowedTools":["Glob"]}}')
+        with self.assertRaisesRegex(ValueError, "changed before launch"):
+            duet._zcode_check_permission_inputs(child, fingerprints)
+
+    def test_unsupported_native_permission_config_fails_before_model_start(self):
+        path = self.home / ".zcode/cli/config.json"
+        path.parent.mkdir(parents=True)
+        for value in ('{"permission": {"allowedTools":["Read"]}}', '{"permission":{"disallowedTools":"Read"}}',
+                      '{"permission":null}', '[]', '// JSONC unsupported', '{"network":{"timeout":NaN}}', '{"permission":{"disallowedTools":["Read,Write"]}}'):
+            with self.subTest(value=value), mock.patch.object(duet, "_run") as run:
+                path.write_text(value)
+                with self.assertRaisesRegex(duet.AgentRunError, "Unsupported native ZCode permission"):
+                    self.invoke()
+                run.assert_not_called()
+
+    def test_loop_prerequisite_accepts_desktop_runtime_without_path_cli(self):
+        spec = importlib.util.spec_from_file_location("duet_loop_e2e", ROOT / "scripts/duet_loop_e2e.py")
+        loop = importlib.util.module_from_spec(spec)
+        sys.modules[spec.name] = loop
+        self.addCleanup(sys.modules.pop, spec.name, None)
+        spec.loader.exec_module(loop)
+        args = ["loop", "--lead-backend", "zcode", "--partner-backend", "codex", "--base-dir", str(self.cwd / "loop")]
+        runtime = mock.Mock()
+        with mock.patch.object(sys, "argv", args), mock.patch.object(loop.shutil, "which", side_effect=lambda name: None if name == "zcode" else name), \
+                mock.patch.object(loop, "load_duet_module", return_value=runtime), mock.patch.object(loop, "scenarios", side_effect=RuntimeError("prerequisites passed")):
+            with self.assertRaisesRegex(RuntimeError, "prerequisites passed"):
+                loop.main()
+        runtime._zcode_command.assert_called_once()
+        fixture = self.cwd / "native-fixture"
+        fixture.mkdir()
+        (fixture / "LOCKED.md").write_text("Preserve this fixture.")
+        loop.init_git_repo(fixture)
+        loop.seed_zcode_review_policy(fixture)
+        self.assertEqual({"features": {"mcp": False}}, json.loads((fixture / "zcode.json").read_text()))
+        self.assertEqual("", loop.run_cmd(["git", "status", "--porcelain"], fixture).stdout)
+
+    def test_pin_survives_state_restore(self):
+        with mock.patch.object(duet, "_run", return_value=self.result()):
+            _, self.agent.session_id = self.invoke()
+        state = duet.agent_state(self.agent)
+        partner = duet.agent_state(duet.Agent(name="gpt", backend="codex"))
+        restored = duet._agents_from_state({"agents": [state, partner]},
+                                            argparse.ArgumentParser(), "--continue")[0]
+        self.assertEqual(self.agent.zcode_selection, restored.zcode_selection)
+
+    def test_dry_run_does_not_start_zcode(self):
+        with mock.patch.object(duet, "_run") as run:
+            reply, session = self.invoke(dry=True)
+        run.assert_not_called()
+        self.assertTrue(session.startswith("sess_"))
+        self.assertIn("dry-run", reply)
+
+
+if __name__ == "__main__":
+    unittest.main()