mapify-cli 3.17.1__tar.gz → 3.19.0__tar.gz

{mapify_cli-3.17.1 → mapify_cli-3.19.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapify-cli
-Version: 3.17.1
+Version: 3.19.0
 Summary: MAP Framework installer - Modular Agentic Planner for Claude Code
 Project-URL: Homepage, https://github.com/azalio/map-framework
 Project-URL: Repository, https://github.com/azalio/map-framework.git
@@ -11,6 +11,7 @@ Requires-Python: >=3.11
 Requires-Dist: httpx>=0.25.0
 Requires-Dist: jinja2<4,>=3.1
 Requires-Dist: platformdirs>=4.0.0
+Requires-Dist: pyyaml>=6.0.0
 Requires-Dist: questionary>=2.0.0
 Requires-Dist: readchar>=4.0.0
 Requires-Dist: rich>=13.0.0
@@ -249,10 +250,10 @@ MAP is inspired by the [MAP cognitive architecture](https://github.com/Shanka123
 
 ```yaml
 # .map/config.yaml
-minimality: lite   # new installs default to lite; existing repos without the key stay off
+minimality: lite   # default for ALL projects incl. keyless configs (#183); set 'off' to opt out
 ```
 
-Allowed values: `off`, `lite`, `full`, `ultra`. Phase 1 ships conservative `lite` defaults: Actor prefers the fewest moving parts, Monitor blocks scope drift only when it affects required behavior, and Evaluator scores simplicity without letting it hide missing required work. `/map-review` also adds an advisory what-to-delete lens when minimality is not `off`; its `net: -N` estimate is informational, not a gate. In `full`/`ultra`, the decomposer may place speculative omissions in `blueprint.deferred_yagni`; those items must be shown during plan approval and can be restored before execution with `python3 .map/scripts/map_orchestrator.py restore_deferred_yagni YG-NNN`. Maintainers can inspect local rollout readiness with `mapify minimality-report --json`, which compares complete `off` and opt-in run-health samples before considering the Phase 3 default flip, reports missing sample gaps and cohort branch names, lists the next telemetry actions, and emits a candidate-only `manual_review_gate` with opt-in branches plus a clarity/underscope checklist before promotion.
+Allowed values: `off`, `lite`, `full`, `ultra`. The global default is `lite` (Phase 3 flip, #183 — keyless configs included; set `off` to opt out). `lite` is conservative: Actor prefers the fewest moving parts, Monitor blocks scope drift only when it affects required behavior, and Evaluator scores simplicity without letting it hide missing required work. `/map-review` also adds an advisory what-to-delete lens when minimality is not `off`; its `net: -N` estimate is informational, not a gate. In `full`/`ultra`, the decomposer may place speculative omissions in `blueprint.deferred_yagni`; those items must be shown during plan approval and can be restored before execution with `python3 .map/scripts/map_orchestrator.py restore_deferred_yagni YG-NNN`. Maintainers can still inspect local rollout telemetry with `mapify minimality-report --json`, which compares complete `off` and opt-in run-health cohorts, reports sample gaps and cohort branch names, lists next telemetry actions, and emits a candidate-only `manual_review_gate` with opt-in branches plus a clarity/underscope checklist.
 
 **Context-compression policy** (controls the `/compact` nudge; default `never` — opt-in):
 
@@ -263,7 +264,7 @@ mapify init . --compression aggressive            # nudge at 0.4 x threshold
 mapify init . --compression-threshold 250000      # Opus 1M / 50+ subtask plans
 ```
 
-Actor and reviewer prompts always carry the full bundled context — context-block truncation was removed. If the conversation grows beyond your model's window, opt into `/compact` via `--compression auto` or trigger it manually. See [docs/USAGE.md#context-budget-policy](docs/USAGE.md).
+Actor and reviewer prompts always carry the full bundled context — context-block truncation was removed. If the conversation grows beyond your model's window, opt into `/compact` via `--compression auto` or trigger it manually. When a policy other than `never` is active, MAP also offloads large tool outputs (grep/test/file-read results) to `.map/<branch>/compacted/` before `/compact` drops them, so a dropped output is re-read from its sidecar instead of re-running broad discovery (these sidecars can hold secrets — they are `0o600` and self-ignored from git; never push `.map/`). See [docs/USAGE.md#context-budget-policy](docs/USAGE.md).
 
 **Stack Overflow for Agents (SOFA)** read-only prior-art search — **off by default**, no network or credentials unless you enable it:
 
@@ -273,6 +274,15 @@ mapify init . --sofa            # opt-in: enable the map-so-search skill
 
 This writes `sofa.enabled: true` to `.map/config.yaml` and adds `.sofa/` to your `.gitignore`. Without the flag, no SOFA code path runs. See the [SOFA usage guide](docs/USAGE.md#stack-overflow-for-agents-sofa).
 
+**Autonomy posture** (`--autonomy`, claude provider) — **off by default**, opt-in "YOLO-minus-git":
+
+```bash
+mapify init . --autonomy        # auto-approve most tools; keep git commit/push for the human
+mapify init . --no-autonomy     # remove the autonomy posture
+```
+
+`--autonomy` writes a broad auto-approve allowlist plus a `git commit`/`push` deny into the **per-user, gitignored** `.claude/settings.local.json` (the committed team `.claude/settings.json` stays the secure baseline) and gitignores that file. The git block is enforced by the `safety-guardrails.py` PreToolUse hook (the permission deny alone is bypassable under a broad `Bash(*)` allow). Omit the flag to leave existing local settings untouched on re-init. See the [autonomy usage guide](docs/USAGE.md#autonomy-posture-yolo-minus-git).
+
 </details>
 
 ## Documentation

{mapify_cli-3.17.1 → mapify_cli-3.19.0}/README.md

@@ -205,10 +205,10 @@ MAP is inspired by the [MAP cognitive architecture](https://github.com/Shanka123
 
 ```yaml
 # .map/config.yaml
-minimality: lite   # new installs default to lite; existing repos without the key stay off
+minimality: lite   # default for ALL projects incl. keyless configs (#183); set 'off' to opt out
 ```
 
-Allowed values: `off`, `lite`, `full`, `ultra`. Phase 1 ships conservative `lite` defaults: Actor prefers the fewest moving parts, Monitor blocks scope drift only when it affects required behavior, and Evaluator scores simplicity without letting it hide missing required work. `/map-review` also adds an advisory what-to-delete lens when minimality is not `off`; its `net: -N` estimate is informational, not a gate. In `full`/`ultra`, the decomposer may place speculative omissions in `blueprint.deferred_yagni`; those items must be shown during plan approval and can be restored before execution with `python3 .map/scripts/map_orchestrator.py restore_deferred_yagni YG-NNN`. Maintainers can inspect local rollout readiness with `mapify minimality-report --json`, which compares complete `off` and opt-in run-health samples before considering the Phase 3 default flip, reports missing sample gaps and cohort branch names, lists the next telemetry actions, and emits a candidate-only `manual_review_gate` with opt-in branches plus a clarity/underscope checklist before promotion.
+Allowed values: `off`, `lite`, `full`, `ultra`. The global default is `lite` (Phase 3 flip, #183 — keyless configs included; set `off` to opt out). `lite` is conservative: Actor prefers the fewest moving parts, Monitor blocks scope drift only when it affects required behavior, and Evaluator scores simplicity without letting it hide missing required work. `/map-review` also adds an advisory what-to-delete lens when minimality is not `off`; its `net: -N` estimate is informational, not a gate. In `full`/`ultra`, the decomposer may place speculative omissions in `blueprint.deferred_yagni`; those items must be shown during plan approval and can be restored before execution with `python3 .map/scripts/map_orchestrator.py restore_deferred_yagni YG-NNN`. Maintainers can still inspect local rollout telemetry with `mapify minimality-report --json`, which compares complete `off` and opt-in run-health cohorts, reports sample gaps and cohort branch names, lists next telemetry actions, and emits a candidate-only `manual_review_gate` with opt-in branches plus a clarity/underscope checklist.
 
 **Context-compression policy** (controls the `/compact` nudge; default `never` — opt-in):
 
@@ -219,7 +219,7 @@ mapify init . --compression aggressive            # nudge at 0.4 x threshold
 mapify init . --compression-threshold 250000      # Opus 1M / 50+ subtask plans
 ```
 
-Actor and reviewer prompts always carry the full bundled context — context-block truncation was removed. If the conversation grows beyond your model's window, opt into `/compact` via `--compression auto` or trigger it manually. See [docs/USAGE.md#context-budget-policy](docs/USAGE.md).
+Actor and reviewer prompts always carry the full bundled context — context-block truncation was removed. If the conversation grows beyond your model's window, opt into `/compact` via `--compression auto` or trigger it manually. When a policy other than `never` is active, MAP also offloads large tool outputs (grep/test/file-read results) to `.map/<branch>/compacted/` before `/compact` drops them, so a dropped output is re-read from its sidecar instead of re-running broad discovery (these sidecars can hold secrets — they are `0o600` and self-ignored from git; never push `.map/`). See [docs/USAGE.md#context-budget-policy](docs/USAGE.md).
 
 **Stack Overflow for Agents (SOFA)** read-only prior-art search — **off by default**, no network or credentials unless you enable it:
 
@@ -229,6 +229,15 @@ mapify init . --sofa            # opt-in: enable the map-so-search skill
 
 This writes `sofa.enabled: true` to `.map/config.yaml` and adds `.sofa/` to your `.gitignore`. Without the flag, no SOFA code path runs. See the [SOFA usage guide](docs/USAGE.md#stack-overflow-for-agents-sofa).
 
+**Autonomy posture** (`--autonomy`, claude provider) — **off by default**, opt-in "YOLO-minus-git":
+
+```bash
+mapify init . --autonomy        # auto-approve most tools; keep git commit/push for the human
+mapify init . --no-autonomy     # remove the autonomy posture
+```
+
+`--autonomy` writes a broad auto-approve allowlist plus a `git commit`/`push` deny into the **per-user, gitignored** `.claude/settings.local.json` (the committed team `.claude/settings.json` stays the secure baseline) and gitignores that file. The git block is enforced by the `safety-guardrails.py` PreToolUse hook (the permission deny alone is bypassable under a broad `Bash(*)` allow). Omit the flag to leave existing local settings untouched on re-init. See the [autonomy usage guide](docs/USAGE.md#autonomy-posture-yolo-minus-git).
+
 </details>
 
 ## Documentation

{mapify_cli-3.17.1 → mapify_cli-3.19.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mapify-cli"
-version = "3.17.1"
+version = "3.19.0"
 description = "MAP Framework installer - Modular Agentic Planner for Claude Code"
 authors = [{ name = "MAP Framework Contributors" }]
 readme = "README.md"
@@ -12,7 +12,13 @@ dependencies = [
     "jinja2>=3.1,<4",
     "platformdirs>=4.0.0",
     "readchar>=4.0.0",
-    "questionary>=2.0.0"
+    "questionary>=2.0.0",
+    # mapify is a config-driven CLI: project_config.py loads .map/config.yaml via
+    # PyYAML on every config-dependent path (minimality-report, init overrides).
+    # It MUST be a hard runtime dep — a normal install (uv tool / pipx / pip
+    # without dev/test extras) otherwise ships without yaml, hits ImportError,
+    # and silently falls back to default config, ignoring the user's settings (#245).
+    "pyyaml>=6.0.0"
 ]
 
 [project.optional-dependencies]

{mapify_cli-3.17.1 → mapify_cli-3.19.0}/src/mapify_cli/__init__.py

@@ -23,7 +23,7 @@ Or install globally:
     mapify check
 """
 
-__version__ = "3.17.1"
+__version__ = "3.19.0"
 
 import os
 import subprocess
@@ -38,7 +38,7 @@ import typer
 import httpx
 
 try:
-    import truststore
+    import truststore  # pyright: ignore[reportMissingImports]
 
     HAS_TRUSTSTORE = True
 except ImportError:
@@ -691,6 +691,18 @@ def init(
             "See docs/USAGE.md."
         ),
     ),
+    autonomy: Optional[bool] = typer.Option(
+        None,
+        "--autonomy/--no-autonomy",
+        help=(
+            "Opt-in 'YOLO-minus-git' posture (claude provider only): auto-approve "
+            "most tools in the per-user, gitignored .claude/settings.local.json "
+            "while a PreToolUse hook keeps git commit/push blocked (you run them). "
+            "--no-autonomy removes it. Omit to leave existing local settings "
+            "untouched. The committed team settings.json stays the secure baseline. "
+            "See docs/USAGE.md."
+        ),
+    ),
 ):
     """
     Initialize a new MAP Framework project.
@@ -739,6 +751,14 @@ def init(
         )
         raise typer.Exit(1)
 
+    # Autonomy posture is delivered via .claude/settings.local.json + the Claude
+    # safety-guardrails hook, neither of which the codex provider installs.
+    if provider == "codex" and autonomy is not None:
+        console.print(
+            "[yellow]Note:[/yellow] --autonomy/--no-autonomy applies to the claude "
+            "provider only; ignored for --provider codex."
+        )
+
     # Validate compression policy & threshold only when the user actually
     # passed the flag — None means "leave existing config alone", which is
     # the correct behaviour on re-run in an existing project. The canonical
@@ -956,7 +976,7 @@ def init(
 
         tracker.add("project-permissions", "Configure project approvals")
         tracker.start("project-permissions")
-        create_or_merge_project_settings_local(project_path)
+        create_or_merge_project_settings_local(project_path, autonomy=autonomy)
         tracker.complete("project-permissions", ".claude/settings.local.json")
 
     # Initialize git (shared, provider-agnostic)

{mapify_cli-3.17.1 → mapify_cli-3.19.0}/src/mapify_cli/config/mcp.py

@@ -23,8 +23,6 @@ def create_mcp_config(project_path: Path, mcp_servers: List[str]) -> None:
             "evaluator": [],
             "reflector": [],
             "documentation-reviewer": [],
-            "debate-arbiter": [],
-            "synthesizer": [],
             "research-agent": [],
             "final-verifier": [],
         },
@@ -62,7 +60,6 @@ def create_mcp_config(project_path: Path, mcp_servers: List[str]) -> None:
             "monitor",
             "evaluator",
             "reflector",
-            "debate-arbiter",
         ]:
             if agent in config["agent_mcp_mappings"]:
                 config["agent_mcp_mappings"][agent].append("sequential-thinking")

{mapify_cli-3.17.1 → mapify_cli-3.19.0}/src/mapify_cli/config/project_config.py

@@ -16,6 +16,7 @@ except ImportError:
 logger = logging.getLogger(__name__)
 
 VALID_MINIMALITY = frozenset({"off", "lite", "full", "ultra"})
+VALID_PROMPT_LAYERING = frozenset({"docs_first", "stable_first"})
 
 
 @dataclass
@@ -79,9 +80,22 @@ class MapConfig:
     # Language preference for agent responses
     language: str = ""
 
-    # Minimality doctrine intensity. Existing projects that have no config key
-    # stay off; new generated configs opt into lite explicitly.
-    minimality: str = "off"
+    # Minimality doctrine intensity. Phase 3 (#183) flipped the global default
+    # off -> lite after the promotion gate (`mapify minimality-report`) reached
+    # `candidate` and the manual review gate passed: projects with no config key
+    # now default to `lite` (advisory complexity-lens; no behavior/verdict gating).
+    minimality: str = "lite"
+
+    # Agent-prompt layering for repeated same-workflow dispatches (#231).
+    # "docs_first"   (default) = variable <documents> first, stable contract
+    #                last — optimized for recency / "lost-in-the-middle".
+    # "stable_first" = stable contract first, variable <documents> last — a
+    #                byte-identical prefix across same-role dispatches. Resolved
+    #                cache-neutral at the Claude Code Task layer (the harness owns
+    #                cache_control and the seam is mid-block), but NOT a behavior
+    #                no-op: it changes token order / attention. Kept opt-in; never
+    #                remapped to docs_first. See docs/ARCHITECTURE.md (#231).
+    prompt_layering: str = "docs_first"
 
     # Context compression policy (see docs/context-compression-plan.md)
     # "never"      = never inject /compact nudge (default — user opts in by
@@ -167,6 +181,15 @@ def load_map_config(project_path: Path) -> MapConfig:
         if isinstance(data, dict) and "sofa.enabled" in data and "sofa_enabled" not in data:
             data["sofa_enabled"] = data.pop("sofa.enabled")
 
+        # YAML 1.1 parses bare ``off``/``on`` as booleans, so ``minimality: off``
+        # — the documented opt-out from the lite default (#183) — arrives as bool
+        # ``False``. Coerce it back to the string level before the type-check loop;
+        # otherwise the str field rejects the bool and silently falls back to the
+        # lite default, breaking opt-out. ``False`` -> ``"off"`` (valid opt-out);
+        # ``True`` -> ``"on"`` (not a real level -> rejected -> lite fallback).
+        if isinstance(data, dict) and isinstance(data.get("minimality"), bool):
+            data["minimality"] = "off" if data["minimality"] is False else "on"
+
         # Map YAML keys to MapConfig fields, filtering out unrecognized keys
         # and validating types against dataclass field annotations
         defaults = MapConfig()
@@ -216,12 +239,22 @@ def load_map_config(project_path: Path) -> MapConfig:
         if cfg.minimality not in VALID_MINIMALITY:
             logger.warning(
                 "Invalid minimality %r in %s (expected one of %s). "
-                "Using default 'off'.",
+                "Using default 'lite'.",
                 cfg.minimality,
                 config_file,
                 ", ".join(sorted(VALID_MINIMALITY)),
             )
-            cfg.minimality = "off"
+            cfg.minimality = "lite"
+
+        if cfg.prompt_layering not in VALID_PROMPT_LAYERING:
+            logger.warning(
+                "Invalid prompt_layering %r in %s (expected one of %s). "
+                "Using default 'docs_first'.",
+                cfg.prompt_layering,
+                config_file,
+                ", ".join(sorted(VALID_PROMPT_LAYERING)),
+            )
+            cfg.prompt_layering = "docs_first"
 
         return cfg
 
@@ -317,6 +350,16 @@ profile: full
 # Allowed: off, lite, full, ultra
 minimality: lite
 
+# Agent-prompt layering for repeated same-workflow dispatches (#231).
+# "docs_first" (default) orders the variable <documents> first and the stable
+# task/instructions/expected_output contract last — best for recency/attention.
+# "stable_first" puts the stable contract first (byte-identical prefix across
+# same-role dispatches). Resolved cache-neutral at the Claude Code Task layer
+# (harness owns cache_control; the seam is mid-block) but it still changes token
+# order/attention, so it is kept opt-in — see docs/ARCHITECTURE.md (#231).
+# Allowed: docs_first, stable_first
+# prompt_layering: docs_first
+
 # Context compression policy. Default is "never" — the /compact nudge is
 # opt-in. Uncomment and switch to "auto" or "aggressive" if you want the
 # meter to interrupt long workflows and ask Claude to compact.

{mapify_cli-3.17.1 → mapify_cli-3.19.0}/src/mapify_cli/config/settings.py

@@ -2,11 +2,76 @@
 
 import json
 from pathlib import Path
-from typing import Dict, Any
+from typing import Dict, Any, Optional
 
 from mapify_cli.cli_ui import console
 
 
+# ---------------------------------------------------------------------------
+# Autonomy posture (opt-in via `mapify init --autonomy`)
+# ---------------------------------------------------------------------------
+#
+# "YOLO-minus-git": auto-approve most tools locally while keeping the human in
+# control of commit/push. This is a *personal* risk preference, so it is written
+# ONLY to the per-user, gitignored .claude/settings.local.json — never to the
+# committed, team-shared .claude/settings.json baseline.
+#
+# The permission-level git deny below is documentation / defense-in-depth: under
+# a broad ``Bash(*)`` allow it is bypassable (``bash -c 'git commit'`` matches as
+# ``bash``). The actual hard block is the ``safety-guardrails.py`` PreToolUse
+# hook, which is gated on the ``mapify.autonomy`` sentinel this module writes.
+_AUTONOMY_ALLOW = [
+    "Bash(*)",
+    "Read(*)",
+    "Edit(*)",
+    "Write(*)",
+    "MultiEdit(*)",
+    "Glob(*)",
+    "Grep(*)",
+    "LS(*)",
+]
+_AUTONOMY_DENY = [
+    "Bash(git commit:*)",
+    "Bash(git push:*)",
+]
+
+_SETTINGS_LOCAL_GITIGNORE_MARKER = "# map:settings-local"
+_SETTINGS_LOCAL_GITIGNORE_BLOCK = (
+    "# map:settings-local — per-user Claude Code approvals / autonomy posture; "
+    "never commit\n"
+    ".claude/settings.local.json\n"
+)
+
+
+def ensure_settings_local_gitignored(project_path: Path) -> int:
+    """Idempotently add ``.claude/settings.local.json`` to the repo-root .gitignore.
+
+    A personal autonomy posture must not leak into the team via a committed
+    settings.local.json. Mirrors ``merge_sofa_gitignore``: the OR-guard skips the
+    append whenever our marker OR an active ignore line is already present, so the
+    entry is never duplicated regardless of how the user got it there.
+
+    Returns 1 when the file was created or modified, 0 when already up-to-date.
+    """
+    gitignore = project_path / ".gitignore"
+
+    if not gitignore.exists():
+        gitignore.write_text(_SETTINGS_LOCAL_GITIGNORE_BLOCK)
+        return 1
+
+    existing = gitignore.read_text()
+    ignored_lines = {line.strip() for line in existing.splitlines()}
+    if (
+        _SETTINGS_LOCAL_GITIGNORE_MARKER in existing
+        or ".claude/settings.local.json" in ignored_lines
+    ):
+        return 0
+
+    separator = "" if existing.endswith("\n") else "\n"
+    gitignore.write_text(existing + separator + _SETTINGS_LOCAL_GITIGNORE_BLOCK)
+    return 1
+
+
 def configure_global_permissions() -> None:
     """Configure global Claude Code permissions for read-only commands"""
     claude_dir = Path.home() / ".claude"
@@ -91,7 +156,9 @@ def configure_global_permissions() -> None:
     )
 
 
-def create_or_merge_project_settings_local(project_path: Path) -> None:
+def create_or_merge_project_settings_local(
+    project_path: Path, *, autonomy: Optional[bool] = None
+) -> None:
     """Create/merge .claude/settings.local.json with safe project allowlist.
 
     Claude Code supports per-project approvals via `.claude/settings.local.json`.
@@ -105,6 +172,16 @@ def create_or_merge_project_settings_local(project_path: Path) -> None:
 
     We keep this allowlist intentionally narrow and focused on common safe actions
     for local development workflows.
+
+    Args:
+        project_path: Target project root.
+        autonomy: Opt-in "YOLO-minus-git" posture.
+            - ``True``  → merge a broad tool allowlist + git commit/push deny and
+              write the ``mapify.autonomy`` sentinel (also gitignores the file).
+            - ``False`` → remove the autonomy allow/deny entries and the sentinel
+              (teardown for ``--no-autonomy``).
+            - ``None``  → leave any existing autonomy posture untouched (default on
+              re-run, so re-init never silently flips a user's choice).
     """
 
     settings_file = project_path / ".claude" / "settings.local.json"
@@ -167,4 +244,60 @@ def create_or_merge_project_settings_local(project_path: Path) -> None:
     permissions.setdefault("deny", [])
     permissions.setdefault("ask", [])
 
+    # Autonomy posture (opt-in). None = leave as-is.
+    if autonomy is True:
+        _apply_autonomy(existing_settings, permissions)
+    elif autonomy is False:
+        _remove_autonomy(existing_settings, permissions)
+
     settings_file.write_text(json.dumps(existing_settings, indent=2) + "\n")
+
+    if autonomy is True:
+        ensure_settings_local_gitignored(project_path)
+        console.print(
+            "[yellow]Autonomy mode:[/yellow] auto-allowing most tools in "
+            ".claude/settings.local.json (per-user, gitignored). git commit/push "
+            "stay blocked — you run them. The local deny overrides the team baseline."
+        )
+    elif autonomy is False:
+        console.print(
+            "[dim]Autonomy mode disabled: removed local broad-allow + git block "
+            "from .claude/settings.local.json.[/dim]"
+        )
+
+
+def _apply_autonomy(settings: Dict[str, Any], permissions: Dict[str, Any]) -> None:
+    """Add the broad allow + git deny entries and the autonomy sentinel."""
+    allow = permissions.setdefault("allow", [])
+    for entry in _AUTONOMY_ALLOW:
+        if entry not in allow:
+            allow.append(entry)
+
+    deny = permissions.setdefault("deny", [])
+    for entry in _AUTONOMY_DENY:
+        if entry not in deny:
+            deny.append(entry)
+
+    # Sentinel beside the permissions it governs so posture and permissions
+    # cannot drift apart; read by the safety-guardrails.py PreToolUse hook.
+    mapify_meta = settings.setdefault("mapify", {})
+    if isinstance(mapify_meta, dict):
+        mapify_meta["autonomy"] = True
+
+
+def _remove_autonomy(settings: Dict[str, Any], permissions: Dict[str, Any]) -> None:
+    """Remove the autonomy allow/deny entries and the sentinel (teardown)."""
+    if isinstance(permissions.get("allow"), list):
+        permissions["allow"] = [
+            e for e in permissions["allow"] if e not in _AUTONOMY_ALLOW
+        ]
+    if isinstance(permissions.get("deny"), list):
+        permissions["deny"] = [
+            e for e in permissions["deny"] if e not in _AUTONOMY_DENY
+        ]
+
+    mapify_meta = settings.get("mapify")
+    if isinstance(mapify_meta, dict):
+        mapify_meta.pop("autonomy", None)
+        if not mapify_meta:
+            settings.pop("mapify", None)

{mapify_cli-3.17.1 → mapify_cli-3.19.0}/src/mapify_cli/delivery/codex_copier.py

@@ -8,8 +8,11 @@ Never touches .claude/.
 
 from __future__ import annotations
 
+import json
 import shutil
+from copy import deepcopy
 from pathlib import Path
+from typing import Any
 
 from mapify_cli.delivery.file_copier import (
     _extract_requires_block,
@@ -20,7 +23,11 @@ from mapify_cli.delivery.file_copier import (
     _warn_requires_skills,
     get_templates_dir,
 )
-from mapify_cli.delivery.managed_file_copier import copy_managed_file
+from mapify_cli.delivery.managed_file_copier import (
+    _assert_safe_dest,
+    _atomic_write,
+    copy_managed_file,
+)
 
 
 def _install_managed_file(
@@ -81,6 +88,129 @@ def _copy_tree(
 
 
 _EXEC_SUFFIXES = frozenset((".py", ".sh"))
+_CODEX_WORKFLOW_GATE_PATH = ".codex/hooks/workflow-gate.py"
+
+
+def _is_codex_workflow_gate_hook(hook: Any) -> bool:
+    """Return True for MAP's managed Codex workflow-gate command hook."""
+    if not isinstance(hook, dict):
+        return False
+    command = hook.get("command")
+    return isinstance(command, str) and _CODEX_WORKFLOW_GATE_PATH in command
+
+
+def _merge_codex_hook_entries(
+    existing_entries: Any,
+    template_entries: Any,
+) -> list[Any]:
+    """Merge MAP hook entries into existing Codex hook entries.
+
+    Existing project hooks are preserved. MAP-owned workflow-gate command hooks
+    are refreshed from the template and de-duplicated.
+    """
+    merged_entries: list[Any] = []
+    if isinstance(existing_entries, list):
+        for raw_entry in deepcopy(existing_entries):
+            if not isinstance(raw_entry, dict):
+                merged_entries.append(raw_entry)
+                continue
+
+            raw_hooks = raw_entry.get("hooks")
+            if not isinstance(raw_hooks, list):
+                merged_entries.append(raw_entry)
+                continue
+
+            cleaned_hooks = [
+                hook for hook in raw_hooks if not _is_codex_workflow_gate_hook(hook)
+            ]
+            if not cleaned_hooks and len(cleaned_hooks) != len(raw_hooks):
+                continue
+
+            raw_entry["hooks"] = cleaned_hooks
+            merged_entries.append(raw_entry)
+
+    if not isinstance(template_entries, list):
+        return merged_entries
+
+    for template_entry in template_entries:
+        if not isinstance(template_entry, dict):
+            if template_entry not in merged_entries:
+                merged_entries.append(deepcopy(template_entry))
+            continue
+
+        matcher = template_entry.get("matcher")
+        template_hooks = template_entry.get("hooks")
+        target = None
+        if isinstance(matcher, str) and isinstance(template_hooks, list):
+            for entry in merged_entries:
+                if (
+                    isinstance(entry, dict)
+                    and entry.get("matcher") == matcher
+                    and isinstance(entry.get("hooks"), list)
+                ):
+                    target = entry
+                    break
+
+        if target is None:
+            if template_entry not in merged_entries:
+                merged_entries.append(deepcopy(template_entry))
+            continue
+
+        assert isinstance(template_hooks, list)
+        target_hooks = target["hooks"]
+        assert isinstance(target_hooks, list)
+        for hook in template_hooks:
+            if hook not in target_hooks:
+                target_hooks.append(deepcopy(hook))
+
+    return merged_entries
+
+
+def _merge_codex_hooks_json(
+    existing_data: dict[str, Any] | None,
+    template_data: dict[str, Any],
+) -> dict[str, Any]:
+    """Return Codex-valid hooks.json containing only the top-level hooks key."""
+    existing_hooks = existing_data.get("hooks") if existing_data else None
+    template_hooks = template_data.get("hooks")
+
+    merged_hooks: dict[str, Any] = (
+        deepcopy(existing_hooks) if isinstance(existing_hooks, dict) else {}
+    )
+
+    if isinstance(template_hooks, dict):
+        for event_name, template_entries in template_hooks.items():
+            merged_hooks[event_name] = _merge_codex_hook_entries(
+                merged_hooks.get(event_name),
+                template_entries,
+            )
+
+    return {"hooks": merged_hooks}
+
+
+def _load_json_object(path: Path) -> dict[str, Any] | None:
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return None
+    return data if isinstance(data, dict) else None
+
+
+def _install_codex_hooks_json(src: Path, dst: Path) -> None:
+    """Install .codex/hooks.json without MAP metadata and merge project hooks."""
+    template_data = _load_json_object(src)
+    if template_data is None:
+        raise ValueError(f"Invalid Codex hooks template JSON: {src}")
+
+    dst.parent.mkdir(parents=True, exist_ok=True)
+
+    existing_data: dict[str, Any] | None = None
+    if dst.exists():
+        _assert_safe_dest(dst)
+        existing_data = _load_json_object(dst)
+
+    merged = _merge_codex_hooks_json(existing_data, template_data)
+    _atomic_write(dst, json.dumps(merged, indent=2, ensure_ascii=False) + "\n")
 
 
 def create_codex_files(project_path: Path) -> dict[str, int]:
@@ -96,8 +226,8 @@ def create_codex_files(project_path: Path) -> dict[str, int]:
 
     Watched files (skills, agents, config, AGENTS.md, hooks) are installed
     fence-aware so a re-install preserves any user content below the fence;
-    hooks.json is JSON (fully-managed via _map_managed); .map/scripts is
-    MAP-owned (fenced=False, skip-if-exists).
+    hooks.json is merged without MAP metadata because Codex validates top-level
+    keys strictly; .map/scripts is MAP-owned (fenced=False, skip-if-exists).
 
     Skips .map/scripts/ if the directory already exists.
     Never creates or modifies any .claude/ path.
@@ -186,12 +316,13 @@ def create_codex_files(project_path: Path) -> dict[str, int]:
 
     # ------------------------------------------------------------------
     # 4. Hooks (hooks.json + hooks/*.py)
-    #    hooks.json is JSON (fully-managed via _map_managed, no fence);
+    #    hooks.json must remain Codex-schema-valid, so install it with a
+    #    Codex-specific merge instead of the generic _map_managed JSON copier.
     #    hooks/*.py are watched (fence-aware) with exec bits preserved.
     # ------------------------------------------------------------------
     hooks_json_src = codex_templates / "hooks.json"
     if hooks_json_src.exists():
-        _install_managed_file(hooks_json_src, codex_dir / "hooks.json", version)
+        _install_codex_hooks_json(hooks_json_src, codex_dir / "hooks.json")
         counts["hooks"] += 1
 
     hooks_dir_src = codex_templates / "hooks"