mapify-cli 3.32.0__tar.gz → 3.33.0__tar.gz

{mapify_cli-3.32.0 → mapify_cli-3.33.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: mapify-cli
-Version: 3.32.0
+Version: 3.33.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
@@ -72,6 +72,10 @@ Common failure modes MAP eliminates:
 
 MAP moves engineering judgment earlier: write down the behavior, split the work into small contracts, verify each stage, review against the spec, and save lessons for the next run.
 
+Skill maintainers can use `mapify skill-eval optimize <skill> --provider claude|codex --apply`
+to update only the selected provider's description in the shared template source;
+the opposite provider stays unchanged ([details](docs/USAGE.md#skill-description-optimization)).
+
 ## Quick Start
 
 <p align="center">
@@ -91,10 +95,16 @@ Requires Python 3.11+, and `python3` on your `PATH` must be that interpreter —
 installed hooks and `.map/scripts/` runners execute through a `#!/usr/bin/env
 python3` shebang, not through the interpreter that ran `mapify`. `mapify init`
 checks it up front and tells you what to fix ([details](docs/INSTALL.md#why-python3-on-path-matters)).
+For Go projects requiring build tags, set `checks.go.tags: integration,netgo` in
+`.map/config.yaml` for the Stop hook's build check ([configuration](docs/USAGE.md#end-of-turnsh-stop)).
 
 **2. Initialize your project**
 
-Claude Code is the default provider:
+Claude Code is the default provider. Cross-AI review compares explicit host and
+reviewer adapter vendors; same-vendor or unknown provenance is not labeled
+independent ([details](docs/USAGE.md#cross-ai-peer-review---cross-ai-runtime)).
+
+Claude Code:
 
 ```bash
 cd your-project
@@ -211,19 +221,21 @@ The DevOpsConf 2026 case study applies this process to a production Kubernetes P
 - **Daily-driver speed** — optimized for repeated use, not occasional demos. Structured enough to prevent chaos, lightweight enough to keep token and time cost under control.
 - **Reviewable diffs** — `/map-plan` and `/map-efficient` require per-subtask size, concern, and constraint metadata, then validate `blueprint.json` *before* implementation, so oversized or mixed-concern plans fail early.
 - **Gates that check the plan, not vibes** — `/map-check` and `/map-review` validate against the spec, tests, and diff instead of asking whether code "looks fine".
-- **Clean-room review** — `/map-review` auto-bundles spec, plan, tests, verification, and coverage evidence into a single durable input (`.map/<branch>/review-bundle.json`); `--detached` opens a read-only worktree for inspection without touching your branch.
+- **Clean-room review** — `/map-review` auto-bundles available spec, plan, tests, verification, and coverage evidence into a single durable input (`.map/<branch>/review-bundle.json`); standalone external-PR review needs no Actor blueprint. `--detached` opens a read-only worktree for inspection without touching your branch.
 - **Project memory** — `/map-learn` turns hard-won fixes and gotchas into reusable context, so the next session doesn't relearn them.
 
 <details>
 <summary><b>More under the hood</b> — calibrated effort, mutation boundaries, token budgets, retry quarantine, run-health diagnostics, skill IR audit</summary>
 
 - **Calibrated workflow effort** — each shipped slash skill declares a `thinking_policy` and `parallel_tool_policy`, so lightweight commands stay direct while planning, review, and release workflows reserve deeper reasoning and parallel fan-out for the stages that benefit.
-- **Mutation boundary constraints** — write-capable Claude and Codex surfaces tell agents not to edit unrelated files, add or upgrade dependencies, or refactor neighboring code unless the current subtask requires it.
+- **Mutation boundary constraints** — write-capable Claude and Codex surfaces tell agents not to edit unrelated files, add or upgrade dependencies, or refactor neighboring code unless the current subtask requires it. With `worktree.isolation: off`, Actor write checks inspect main even when a recovery worktree remains on disk.
+- **Live isolation dispatch gate** — before concurrent Actor fan-out, `auto` isolation falls back to sequential on dirty or unsupported checkouts; `required` isolation stops dispatch instead. Wave guidance forwards the live decision and warning.
 - **Context-first prompt envelopes** — high-context prompts wrap branch artifacts in XML-style `<documents>`, then state the `<task>` and `<expected_output>`, so specs, diffs, logs, and schemas stay separated for the model.
 - **Contract-sized subtasks** — blueprints require `expected_diff_size`, `concern_type`, `one_logical_step`, `hard_constraints`, `soft_constraints`, and `coverage_map`. Hard constraints must be owned in `coverage_map` and cited in the owning subtask.
 - **Token budget and research ROI reports** — Actor and review prompt builders append active-path budget decisions to `.map/<branch>/token_budget.json`, while `token_accounting.json` and `/map-tokenreport` separate research-agent/researcher cost from Actor/Monitor cost.
 - **Clean retry quarantine** — after repeated Monitor rejection, write-capable workflows switch the next attempt into clean-retry mode using `.map/<branch>/retry_quarantine.json` instead of raw failed-session context.
-- **Run health report** — workflows write `.map/<branch>/run_health_report.json` during closeout: terminal status, step progress, retry counters, artifact presence, hook-injection status, and advisory signals. CI can fail inconsistent closeouts with `python3 .map/scripts/map_step_runner.py validate_run_health_report`.
+- **Run health report** — workflows write `.map/<branch>/run_health_report.json` during closeout: terminal status, step progress, retry counters, artifact presence, hook-injection status, and advisory signals. CI can fail inconsistent closeouts with `python3 .map/scripts/map_step_runner.py validate_run_health_report`. All runner subcommands support read-only `--help` / `-h`; for example, `python3 .map/scripts/map_step_runner.py write_run_health_report --help`.
+- **Lossless serial blocker repair** — independently approved repairs run in a private checkout with their own Monitor and full gate, preserving the paused task's phase, results, retries and dirty files. Concurrent waves and overlapping repair paths fail closed; see [the repair protocol](docs/USAGE.md#independent-serial-blocker-repair).
 - **Compact recovery surface** — `/map-resume` keeps the active recovery flow short and moves low-frequency notes to `resume-reference.md`, so recovery after `/clear` or context exhaustion gives the next checkpoint action without loading the whole appendix.
 - **Skill IR audit** — release checks lower shipped Claude and Codex `SKILL.md` files into a typed `SkillIR`, verify content hashes, catch unsupported frontmatter, reject missing supporting-file links, and block injection-like instructions before `mapify init` copies surfaces into user repos.
 

{mapify_cli-3.32.0 → mapify_cli-3.33.0}/README.md

@@ -27,6 +27,10 @@ Common failure modes MAP eliminates:
 
 MAP moves engineering judgment earlier: write down the behavior, split the work into small contracts, verify each stage, review against the spec, and save lessons for the next run.
 
+Skill maintainers can use `mapify skill-eval optimize <skill> --provider claude|codex --apply`
+to update only the selected provider's description in the shared template source;
+the opposite provider stays unchanged ([details](docs/USAGE.md#skill-description-optimization)).
+
 ## Quick Start
 
 <p align="center">
@@ -46,10 +50,16 @@ Requires Python 3.11+, and `python3` on your `PATH` must be that interpreter —
 installed hooks and `.map/scripts/` runners execute through a `#!/usr/bin/env
 python3` shebang, not through the interpreter that ran `mapify`. `mapify init`
 checks it up front and tells you what to fix ([details](docs/INSTALL.md#why-python3-on-path-matters)).
+For Go projects requiring build tags, set `checks.go.tags: integration,netgo` in
+`.map/config.yaml` for the Stop hook's build check ([configuration](docs/USAGE.md#end-of-turnsh-stop)).
 
 **2. Initialize your project**
 
-Claude Code is the default provider:
+Claude Code is the default provider. Cross-AI review compares explicit host and
+reviewer adapter vendors; same-vendor or unknown provenance is not labeled
+independent ([details](docs/USAGE.md#cross-ai-peer-review---cross-ai-runtime)).
+
+Claude Code:
 
 ```bash
 cd your-project
@@ -166,19 +176,21 @@ The DevOpsConf 2026 case study applies this process to a production Kubernetes P
 - **Daily-driver speed** — optimized for repeated use, not occasional demos. Structured enough to prevent chaos, lightweight enough to keep token and time cost under control.
 - **Reviewable diffs** — `/map-plan` and `/map-efficient` require per-subtask size, concern, and constraint metadata, then validate `blueprint.json` *before* implementation, so oversized or mixed-concern plans fail early.
 - **Gates that check the plan, not vibes** — `/map-check` and `/map-review` validate against the spec, tests, and diff instead of asking whether code "looks fine".
-- **Clean-room review** — `/map-review` auto-bundles spec, plan, tests, verification, and coverage evidence into a single durable input (`.map/<branch>/review-bundle.json`); `--detached` opens a read-only worktree for inspection without touching your branch.
+- **Clean-room review** — `/map-review` auto-bundles available spec, plan, tests, verification, and coverage evidence into a single durable input (`.map/<branch>/review-bundle.json`); standalone external-PR review needs no Actor blueprint. `--detached` opens a read-only worktree for inspection without touching your branch.
 - **Project memory** — `/map-learn` turns hard-won fixes and gotchas into reusable context, so the next session doesn't relearn them.
 
 <details>
 <summary><b>More under the hood</b> — calibrated effort, mutation boundaries, token budgets, retry quarantine, run-health diagnostics, skill IR audit</summary>
 
 - **Calibrated workflow effort** — each shipped slash skill declares a `thinking_policy` and `parallel_tool_policy`, so lightweight commands stay direct while planning, review, and release workflows reserve deeper reasoning and parallel fan-out for the stages that benefit.
-- **Mutation boundary constraints** — write-capable Claude and Codex surfaces tell agents not to edit unrelated files, add or upgrade dependencies, or refactor neighboring code unless the current subtask requires it.
+- **Mutation boundary constraints** — write-capable Claude and Codex surfaces tell agents not to edit unrelated files, add or upgrade dependencies, or refactor neighboring code unless the current subtask requires it. With `worktree.isolation: off`, Actor write checks inspect main even when a recovery worktree remains on disk.
+- **Live isolation dispatch gate** — before concurrent Actor fan-out, `auto` isolation falls back to sequential on dirty or unsupported checkouts; `required` isolation stops dispatch instead. Wave guidance forwards the live decision and warning.
 - **Context-first prompt envelopes** — high-context prompts wrap branch artifacts in XML-style `<documents>`, then state the `<task>` and `<expected_output>`, so specs, diffs, logs, and schemas stay separated for the model.
 - **Contract-sized subtasks** — blueprints require `expected_diff_size`, `concern_type`, `one_logical_step`, `hard_constraints`, `soft_constraints`, and `coverage_map`. Hard constraints must be owned in `coverage_map` and cited in the owning subtask.
 - **Token budget and research ROI reports** — Actor and review prompt builders append active-path budget decisions to `.map/<branch>/token_budget.json`, while `token_accounting.json` and `/map-tokenreport` separate research-agent/researcher cost from Actor/Monitor cost.
 - **Clean retry quarantine** — after repeated Monitor rejection, write-capable workflows switch the next attempt into clean-retry mode using `.map/<branch>/retry_quarantine.json` instead of raw failed-session context.
-- **Run health report** — workflows write `.map/<branch>/run_health_report.json` during closeout: terminal status, step progress, retry counters, artifact presence, hook-injection status, and advisory signals. CI can fail inconsistent closeouts with `python3 .map/scripts/map_step_runner.py validate_run_health_report`.
+- **Run health report** — workflows write `.map/<branch>/run_health_report.json` during closeout: terminal status, step progress, retry counters, artifact presence, hook-injection status, and advisory signals. CI can fail inconsistent closeouts with `python3 .map/scripts/map_step_runner.py validate_run_health_report`. All runner subcommands support read-only `--help` / `-h`; for example, `python3 .map/scripts/map_step_runner.py write_run_health_report --help`.
+- **Lossless serial blocker repair** — independently approved repairs run in a private checkout with their own Monitor and full gate, preserving the paused task's phase, results, retries and dirty files. Concurrent waves and overlapping repair paths fail closed; see [the repair protocol](docs/USAGE.md#independent-serial-blocker-repair).
 - **Compact recovery surface** — `/map-resume` keeps the active recovery flow short and moves low-frequency notes to `resume-reference.md`, so recovery after `/clear` or context exhaustion gives the next checkpoint action without loading the whole appendix.
 - **Skill IR audit** — release checks lower shipped Claude and Codex `SKILL.md` files into a typed `SkillIR`, verify content hashes, catch unsupported frontmatter, reject missing supporting-file links, and block injection-like instructions before `mapify init` copies surfaces into user repos.
 

{mapify_cli-3.32.0 → mapify_cli-3.33.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mapify-cli"
-version = "3.32.0"
+version = "3.33.0"
 description = "MAP Framework installer - Modular Agentic Planner for Claude Code"
 authors = [{ name = "MAP Framework Contributors" }]
 readme = "README.md"

{mapify_cli-3.32.0 → mapify_cli-3.33.0}/src/mapify_cli/__init__.py

@@ -23,7 +23,7 @@ Or install globally:
     mapify check
 """
 
-__version__ = "3.32.0"
+__version__ = "3.33.0"
 
 # MUST stay the first import: it turns "this interpreter is older than 3.11" into
 # a message that says so, instead of the ImportError raised by `from datetime

mapify_cli-3.33.0/src/mapify_cli/skills_eval/apply_patcher.py

@@ -0,0 +1,277 @@
+"""Apply a provider-specific winner without modifying the opposite skill."""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import shutil
+import stat
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import TypedDict
+
+
+class _JournalEntry(TypedDict):
+    path: str
+    exists: bool
+    mode: int
+    backup: str
+
+
+def _plain_description(text: str, winner: str) -> str:
+    """Replace one complete, supported YAML description scalar."""
+    if not text.startswith("---\n") or "\n---" not in text:
+        raise ValueError("No YAML frontmatter found or no closing '---'")
+    end = text.index("\n---", 4)
+    lines = text[4:end].splitlines(keepends=True)
+    starts = [i for i, line in enumerate(lines) if line.startswith("description:")]
+    if len(starts) != 1:
+        raise ValueError("Expected exactly one description key")
+    i = starts[0]
+    scalar = lines[i].split(":", 1)[1].strip()
+    if not scalar or scalar.startswith(("[", "{", "&", "*")):
+        raise ValueError("Unsupported description scalar")
+    j = i + 1
+    while j < len(lines) and (not lines[j].strip() or lines[j].startswith((" ", "\t"))):
+        j += 1
+    if j > i + 1 and scalar not in ("|", "|-", "|+", ">", ">-", ">+"):
+        raise ValueError("Unsupported multiline description scalar")
+    while j > i + 1 and not lines[j - 1].strip():
+        j -= 1
+    replacement = "description: |-\n" + "".join("  " + line + "\n" for line in winner.split("\n"))
+    header = "".join(lines[:i]) + replacement + "".join(lines[j:])
+    return "---\n" + header.rstrip("\n") + text[end:]
+
+
+def patch_skill_description(skill_md_path: Path, new_description: str) -> None:
+    """Preserved plain YAML API; validate fully before the single write."""
+    text = skill_md_path.read_text(encoding="utf-8")
+    patched = _plain_description(text, new_description)
+    _atomic_bytes(skill_md_path, patched.encode(), stat.S_IMODE(skill_md_path.stat().st_mode))
+
+
+def _provider_description(text: str, winner: str, provider: str) -> str:
+    """Bounded provider-header contract, not a general Jinja source parser."""
+    from mapify_cli.delivery.template_renderer import get_environment
+    from mapify_cli.skill_ir import parse_frontmatter
+
+    if not text.startswith("---\n") or "\n---\n" not in text:
+        raise ValueError("Unsupported description structure: missing frontmatter")
+    header, body = text[4:].split("\n---\n", 1)
+    for directive in re.findall(r"\[%.*?%\]", header, flags=re.DOTALL):
+        token = directive[2:-2].strip().strip("-").strip()
+        if token not in ("else", "endif") and not re.fullmatch(
+            r"if PROVIDER == ([\"'])(?:claude|codex)\1|set cmd = \"/\" if PROVIDER == \"claude\" else \"\$\"", token
+        ):
+            raise ValueError(f"Unsupported description directive: {directive}")
+    if re.search(r"<%(?!\s*cmd\s*%>)|\[#", header):
+        raise ValueError("Unsupported description expression")
+    if any(t in winner for t in ("[%", "<%", "[#")) or not winner.strip():
+        raise ValueError("Unsupported winner description")
+    env = get_environment()
+    rendered = env.from_string("---\n" + header + "\n---\n").render(PROVIDER=provider)
+    parse_frontmatter(rendered.split("---", 2)[1])
+    patched = _plain_description(rendered, winner)
+    parsed = parse_frontmatter(patched.split("---", 2)[1])
+    if parsed.get("description") != winner:
+        raise ValueError("Unsupported description structure: winner did not round-trip")
+    opposite = "codex" if provider == "claude" else "claude"
+    original_other = env.from_string("---\n" + header + "\n---\n").render(PROVIDER=opposite)
+    # Independent provider descriptions have unambiguous scalar spans. Edit
+    # only the selected block, retaining every other source byte.
+    branches = list(re.finditer(r'\[% if PROVIDER == ([\"\'])(claude|codex)\1 %\]description:', header))
+    for branch in branches:
+        stop = header.find("[% endif", branch.end())
+        alternate = header.find("[% else %]description:", branch.end(), stop)
+        if alternate < 0:
+            continue
+        first = branch.end() - len("description:")
+        second = alternate + len("[% else %]")
+        start, limit = (first, alternate) if provider == branch.group(2) else (second, stop)
+        segment = header[start:limit]
+        patched_segment = _plain_description("---\n" + segment + "\n---\n", winner)[4:-5]
+        if segment.endswith("\n"):
+            patched_segment += "\n"
+        candidate_header = header[:start] + patched_segment + header[limit:]
+        result = "---\n" + candidate_header + "\n---\n" + body
+        if env.from_string("---\n" + candidate_header + "\n---\n").render(PROVIDER=opposite) != original_other:
+            raise ValueError("Unsupported conditional description whitespace")
+        return result
+    binding = '[% set cmd = "/" if PROVIDER == "claude" else "$" -%]'
+    combined = ("---\n" + binding + f'[% if PROVIDER == "{provider}" %]'
+                + patched[4:-4] + "[% else %]" + original_other[4:-4] + "[% endif -%]\n---\n")
+    if env.from_string(combined).render(PROVIDER=opposite) != original_other:
+        raise ValueError("Unsupported description whitespace structure")
+    return combined + body
+
+
+def _atomic_bytes(path: Path, data: bytes, mode: int) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    fd, name = tempfile.mkstemp(prefix=".mapify-apply-", dir=path.parent)
+    try:
+        with os.fdopen(fd, "wb") as stream:
+            stream.write(data)
+            stream.flush()
+            os.fsync(stream.fileno())
+        os.chmod(name, mode)
+        os.replace(name, path)
+        directory_fd = os.open(path.parent, os.O_RDONLY)
+        try:
+            os.fsync(directory_fd)
+        finally:
+            os.close(directory_fd)
+    finally:
+        Path(name).unlink(missing_ok=True)
+
+
+def _recover_transaction(root: Path) -> None:
+    journal = root / ".map/skill-eval-apply-transaction"
+    manifest = journal / "manifest.json"
+    if any(p.is_symlink() for p in (journal, journal.parent, manifest)):
+        raise ValueError(f"Unsafe apply recovery journal: {journal}")
+    if not manifest.exists():
+        return
+    entries = json.loads(manifest.read_text(encoding="utf-8"))
+    if not (journal / "complete").exists():
+        for entry in entries:
+            target = root / entry["path"]
+            backup = journal / entry["backup"]
+            if (not target.resolve().is_relative_to(root.resolve())
+                    or not backup.resolve().is_relative_to(journal.resolve())
+                    or any(p.is_symlink() for p in (target, *target.parents, backup))):
+                raise ValueError(f"Unsafe recovery path in {manifest}")
+            if entry["exists"]:
+                _atomic_bytes(target, (journal / entry["backup"]).read_bytes(), entry["mode"])
+            else:
+                target.unlink(missing_ok=True)
+    shutil.rmtree(journal)
+
+
+def _commit_transaction(root: Path, updates: dict[Path, bytes]) -> list[Path]:
+    journal = root / ".map/skill-eval-apply-transaction"
+    for path in updates:
+        if any(p.is_symlink() for p in (path, *path.parents) if p != root.parent):
+            raise ValueError(f"Refusing symlink output: {path}")
+    if journal.exists():
+        raise ValueError(f"Incomplete apply journal requires inspection: {journal}")
+    journal.mkdir(parents=True, exist_ok=False)
+    entries: list[_JournalEntry] = []
+    for i, (path, data) in enumerate(updates.items()):
+        exists = path.exists()
+        if exists and path.read_bytes() == data:
+            continue
+        mode = stat.S_IMODE(path.stat().st_mode) if exists else 0o644
+        entry: _JournalEntry = {"path": str(path.relative_to(root)), "exists": exists, "mode": mode, "backup": str(i)}
+        if exists:
+            _atomic_bytes(journal / str(i), path.read_bytes(), 0o600)
+        entries.append(entry)
+    _atomic_bytes(journal / "manifest.json", json.dumps(entries).encode(), 0o600)
+    fd = os.open(journal, os.O_RDONLY)
+    try:
+        os.fsync(fd)
+    finally:
+        os.close(fd)
+    try:
+        for entry in entries:
+            path = root / str(entry["path"])
+            _atomic_bytes(path, updates[path], int(entry["mode"]))
+        _atomic_bytes(journal / "complete", b"complete", 0o600)
+    except BaseException:
+        _recover_transaction(root)
+        raise
+    shutil.rmtree(journal)
+    return [root / str(entry["path"]) for entry in entries]
+
+
+def apply_optimized_description(
+    *, skill: str, winner: str, current_description: str, no_improvement: bool,
+    repo_root: Path, stage: bool = True, provider: str = "claude",
+) -> str:
+    """Serialize recovery/promotion across processes using the installer barrier."""
+    if no_improvement:
+        print("No improvement found: current description already optimal on held-out test")
+        return "no_improvement"
+    if winner == current_description:
+        print("Winner identical to current description; no file changes")
+        return "identical"
+    from mapify_cli.update_state import installer_process_lock
+
+    repo_root = repo_root.resolve()
+    with installer_process_lock(repo_root, timeout_s=30):
+        return _apply_optimized_description(
+            skill=skill, winner=winner, current_description=current_description,
+            no_improvement=no_improvement, repo_root=repo_root, stage=stage, provider=provider,
+        )
+
+
+def _apply_optimized_description(
+    *, skill: str, winner: str, current_description: str, no_improvement: bool,
+    repo_root: Path, stage: bool = True, provider: str = "claude",
+) -> str:
+    """Render in isolation, then transactionally promote only selected skill files."""
+    if no_improvement:
+        print("No improvement found: current description already optimal on held-out test")
+        return "no_improvement"
+    if winner == current_description:
+        print("Winner identical to current description; no file changes")
+        return "identical"
+    if provider not in ("claude", "codex"):
+        raise ValueError(f"Unsupported provider: {provider}")
+    source_root = (repo_root / "src/mapify_cli/templates_src").resolve()
+    jinja = source_root / "skills" / skill / "SKILL.md.jinja"
+    if not jinja.resolve().is_relative_to(source_root) or ".git" in jinja.resolve().parts:
+        raise ValueError(f"Path safety violation outside templates_src or under .git: {jinja}")
+    _recover_transaction(repo_root)
+    original = jinja.read_text(encoding="utf-8")
+    candidate = _provider_description(original, winner, provider)
+    from mapify_cli.delivery.template_renderer import get_environment, render_repo_trees
+
+    with tempfile.TemporaryDirectory(prefix="mapify-apply-") as tmp:
+        sandbox = Path(tmp)
+        source = sandbox / "src/mapify_cli/templates_src"
+        shutil.copytree(source_root, source)
+        target = source / jinja.relative_to(source_root)
+        target.write_text(candidate, encoding="utf-8")
+        env = get_environment(source)
+        name = jinja.relative_to(source_root).as_posix()
+        opposite = "codex" if provider == "claude" else "claude"
+        before_env = get_environment(source_root)
+        if env.get_template(name).render(PROVIDER=opposite) != before_env.get_template(name).render(PROVIDER=opposite):
+            raise ValueError("Unsupported description structure: opposite provider changed")
+        from mapify_cli.skill_ir import parse_frontmatter
+
+        selected = env.get_template(name).render(PROVIDER=provider)
+        if parse_frontmatter(selected.split("---", 2)[1]).get("description") != winner:
+            raise ValueError("Unsupported description structure: selected winner mismatch")
+        for runtime in ("claude", "codex"):
+            render_repo_trees(runtime, repo_root=sandbox, templates_src_root=source)
+        roots = (".claude/skills", "src/mapify_cli/templates/skills") if provider == "claude" else (
+            ".agents/skills", "src/mapify_cli/templates/codex/skills"
+        )
+        updates = {jinja: target.read_bytes()}
+        for root in roots:
+            rel = Path(root) / skill / "SKILL.md"
+            rendered_bytes = (sandbox / rel).read_bytes()
+            generated_text = rendered_bytes.decode()
+            if parse_frontmatter(generated_text.split("---", 2)[1]).get("description") != winner:
+                raise ValueError("Unsupported provider source: generated winner differs from common source")
+            provider_template = ("codex/" if provider == "codex" else "") + name
+            baseline = before_env.get_template(provider_template).render(PROVIDER=provider)
+            destination = repo_root / rel
+            if destination.exists() and destination.read_bytes() != baseline.encode():
+                raise ValueError(f"Refusing modified or stale generated skill: {destination}; preserve your edits and render explicitly first")
+            if _plain_description(baseline, winner) != generated_text:
+                raise ValueError("Unsupported provider source: non-description generated content changed")
+            updates[repo_root / rel] = rendered_bytes
+        changed = _commit_transaction(repo_root, updates)
+    if stage and changed:
+        result = subprocess.run(
+            ["git", "add", "--", *(str(p.relative_to(repo_root)) for p in changed)],
+            cwd=repo_root, capture_output=True, text=True, check=False,
+        )
+        if result.returncode:
+            print(f"Warning: 'git add' failed (exit {result.returncode}): {result.stderr.strip()}")
+    print(f"Applied new description for '{skill}'. Note: skill-rules.json description is NOT auto-patched")
+    return "applied"

{mapify_cli-3.32.0 → mapify_cli-3.33.0}/src/mapify_cli/templates/agents/monitor.md

@@ -40,6 +40,27 @@ You are a **validation agent**, NOT a code editor. Your role:
 
 ---
 
+## Review context (MANDATORY)
+
+- **Actor subtask validation:** When dispatched to validate an Actor subtask,
+  enforce its AAG contract and mutation boundary below. Missing or invalid
+  blueprint/subtask metadata is a blocking setup error, not a standalone review.
+- **Standalone /map-review:** When dispatched to review a diff/PR using a review
+  bundle rather than validate an Actor subtask, assess correctness, security,
+  tests, regressions, and any supplied requirements against that diff.
+  Do not require an Actor AAG contract, blueprint, or subtask ID, and do not run
+  the Actor mutation-boundary command. Missing planning artifacts are context
+  limitations, not defects in the reviewed PR. Continue all applicable build,
+  test, and quality gates; report concrete defects with source evidence.
+- Never infer standalone review from a missing blueprint. An explicit Actor
+  subtask validation assignment takes precedence over generic review wording.
+  If the assignment is ambiguous, ask the parent to clarify before a verdict.
+  Do not create a synthetic blueprint or reset/migrate workflow state to review.
+
+The Actor-specific sequence and rejection rules below (AAG, allowed scope,
+subtask metadata) apply only to Actor subtask validation, not standalone review.
+
+
 <Monitor_Contract_Verification_v2_9>
 
 ## Contract-Based Verification Protocol

{mapify_cli-3.32.0 → mapify_cli-3.33.0}/src/mapify_cli/templates/codex/agents/monitor.toml

@@ -31,6 +31,27 @@ Your output: JSON with valid: true|false and issues[] array.
 
 ---
 
+## Review context (MANDATORY)
+
+- **Actor subtask validation:** When dispatched to validate an Actor subtask,
+  enforce its AAG contract and mutation boundary below. Missing or invalid
+  blueprint/subtask metadata is a blocking setup error, not a standalone review.
+- **Standalone /map-review:** When dispatched to review a diff/PR using a review
+  bundle rather than validate an Actor subtask, assess correctness, security,
+  tests, regressions, and any supplied requirements against that diff.
+  Do not require an Actor AAG contract, blueprint, or subtask ID, and do not run
+  the Actor mutation-boundary command. Missing planning artifacts are context
+  limitations, not defects in the reviewed PR. Continue all applicable build,
+  test, and quality gates; report concrete defects with source evidence.
+- Never infer standalone review from a missing blueprint. An explicit Actor
+  subtask validation assignment takes precedence over generic review wording.
+  If the assignment is ambiguous, ask the parent to clarify before a verdict.
+  Do not create a synthetic blueprint or reset/migrate workflow state to review.
+
+The Actor-specific sequence and rejection rules below (AAG, allowed scope,
+subtask metadata) apply only to Actor subtask validation, not standalone review.
+
+
 # Contract-Based Verification Protocol
 
 Primary Mission: Verify that Actor's implementation exactly matches the AAG contract
@@ -52,8 +73,19 @@ Verification sequence (execute in order):
 
 3. Verify Goal is achieved -- trace code path to confirm the stated outcome
 4. Verify Action is implemented -- check that the specified method/operation exists
-5. Verify scope -- confirm changes stay within Actor's allowed_scope
-6. Run quality gates below
+5. Verify mutation boundary (MANDATORY): Run
+   python3 .map/scripts/map_step_runner.py validate_mutation_boundary <branch> <subtask_id>
+   to compare the actual git diff against the subtask's declared affected_files.
+   - status="clean" -> continue.
+   - status="warning" -> record the unexpected files; do NOT auto-reject.
+     The CLI also appends to .map/<branch>/scope-violations.log for audit.
+   - status="violation" (MAP_STRICT_SCOPE=1) -> valid: false with the unexpected
+     list. The Actor must re-scope.
+   - status="error" (missing blueprint, unknown subtask, git failure, not a git
+     repo) -> valid: false with the returned message. The CLI exits non-zero;
+     repair the setup before re-running Monitor. Never silently skip this gate.
+6. Verify scope -- confirm changes stay within Actor's allowed_scope
+7. Run quality gates below
 
 Deterministic REJECT rule:
 If implementation deviates from the AAG contract -> valid: false -- regardless of how

{mapify_cli-3.32.0 → mapify_cli-3.33.0}/src/mapify_cli/templates/codex/hooks/end-of-turn.sh

@@ -65,7 +65,7 @@ import re, sys
 key, default = sys.argv[1], sys.argv[2]
 try:
     text = open('.map/config.yaml', encoding='utf-8').read()
-    m = re.search(r'^\s*' + re.escape(key) + r'\s*:\s*(\S+)', text, re.MULTILINE)
+    m = re.search(r'^[ \t]*' + re.escape(key) + r'[ \t]*:[ \t]*(\S+)', text, re.MULTILINE)
     print(m.group(1).strip() if m else default)
 except Exception:
     print(default)
@@ -281,12 +281,20 @@ if command -v go &>/dev/null && [[ -f "go.mod" ]]; then
                 # developed on macOS (e.g. projects using cgroups/eBPF/netlink).
                 #   Example config:  checks.go.goos: linux
                 _go_goos="${GOOS:-$(_read_map_config_value 'checks.go.goos' '')}"
+                # Optional comma-separated build tags; keep the entire value
+                # in one argv entry, never evaluate it as shell syntax.
+                _go_tags=$(_read_map_config_value 'checks.go.tags' '')
+                _go_build_args=(build)
+                if [[ -n "$_go_tags" ]]; then
+                    _go_build_args+=(-tags "$_go_tags")
+                fi
+                _go_build_args+=(-o /dev/null ./...)
                 _go_build_ok=true
                 if [[ -n "$_go_goos" ]]; then
-                    GOOS="$_go_goos" go build -o /dev/null ./... 2>/dev/null \
+                    GOOS="$_go_goos" go "${_go_build_args[@]}" 2>/dev/null \
                         || _go_build_ok=false
                 else
-                    go build -o /dev/null ./... 2>/dev/null || _go_build_ok=false
+                    go "${_go_build_args[@]}" 2>/dev/null || _go_build_ok=false
                 fi
                 if [[ "$_go_build_ok" == "false" ]]; then
                     add_critical "Go build errors detected (run 'go build ./...' for details)"

{mapify_cli-3.32.0 → mapify_cli-3.33.0}/src/mapify_cli/templates/codex/hooks/workflow-gate.py

@@ -486,6 +486,77 @@ def get_branch_name() -> str:
     return "default"
 
 
+def _has_active_interruption(branch: str) -> bool:
+    """The parent marker suspends writes; only the engine validates its journal."""
+    try:
+        state = json.loads(
+            (PROJECT_DIR / ".map" / branch / "step_state.json").read_text(encoding="utf-8")
+        )
+    except (OSError, UnicodeError, json.JSONDecodeError):
+        state = None  # Ordinary corrupt state remains fail-open without repair evidence.
+    if isinstance(state, dict) and state.get("active_interruption") is not None:
+        return True
+    # Intent: durable repair intent still protects the parent after state corruption.
+    try:
+        for journal in (PROJECT_DIR / ".git/map-repairs").glob("repair-*/journal.json"):
+            if not re.fullmatch(r"repair-[0-9a-f]{24}", journal.parent.name):
+                continue
+            record = json.loads(journal.read_text(encoding="utf-8"))
+            if not isinstance(record, dict) or not all(
+                isinstance(record.get(key), str) and record[key] for key in ("branch", "stage")
+            ):
+                return True
+            if record.get("branch") == branch and record.get("stage") != "done":
+                return True
+    except (OSError, UnicodeError, json.JSONDecodeError):
+        return True
+    return False
+
+
+def _interruption_allows_bash(command: str) -> bool:
+    """Accept explicit inspection/checks or the canonical runner, not a prefix."""
+    # Intent: opaque expansion and compound shell commands cannot prove read-only intent.
+    if _bash_write_targets(command) or any(character in command for character in "$`\n\r"):
+        return False
+    try:
+        lexer = shlex.shlex(command, posix=True, punctuation_chars=";&|<>()")
+        lexer.whitespace_split = True
+        lexer.commenters = ""
+        tokens = list(lexer)
+    except ValueError:
+        return False
+    if not tokens or any(token and all(character in ";&|<>()" for character in token)
+                         for token in tokens):
+        return False
+    executable, args = tokens[0], tokens[1:]
+    if executable in {"python", "python3"}:
+        if not args:
+            return False
+        script = args[0]
+        for name in ("map_step_runner.py", "map_orchestrator.py"):
+            canonical = Path(".map/scripts") / name
+            if script in {str(canonical), str(PROJECT_DIR / canonical)}:
+                return len(args) > 1 and args[1] in {
+                    "begin_repair", "verify_repair", "finish_repair", "repair_status",
+                    "get_interruption_status",
+                }
+        return False
+    if executable == "git":
+        if not args:
+            return False
+        if args[0] in {"status", "rev-parse", "ls-files"}:
+            return not any(arg.startswith("--output") for arg in args)
+        if args == ["branch", "--show-current"]:
+            return True
+        if args[:2] == ["--no-pager", "diff"]:
+            options = args[:args.index("--")] if "--" in args else args
+            return {"--no-ext-diff", "--no-textconv"}.issubset(options) and not any(
+                arg.startswith(("--output", "--ext-diff", "--textconv")) for arg in args
+            )
+        return False
+    return executable in {"cat", "ls", "pwd", "grep", "head", "tail", "wc", "true"}
+
+
 def _current_phase_is_research(branch: str) -> bool:
     """Return True iff step_state's current phase is RESEARCH (2.2)."""
     step_file = PROJECT_DIR / ".map" / branch / "step_state.json"
@@ -866,13 +937,23 @@ def main() -> None:
             allow()
 
         target_paths = extract_target_file_paths(tool_call)
+        branch = get_branch_name()
+        interrupted = _has_active_interruption(branch)
+        if interrupted:
+            if tool_name == "Bash":
+                tool_input = tool_call.get("tool_input") or {}
+                command = tool_input.get("command") if isinstance(tool_input, dict) else None
+                if isinstance(command, str) and _interruption_allows_bash(command):
+                    allow()
+                deny("Workflow suspended for blocker repair: main-checkout Bash writes are denied.")
+            if not target_paths or any(not is_exempt_path(p) for p in target_paths):
+                deny("Workflow suspended for blocker repair: edit application files in the private checkout.")
         # Opaque Bash (no extractable write target) is not gated — parity with
         # the Claude twin and the known #164 limitation. Denying it fail-closed
         # would also deny the orchestrator's own `VAR=$(...)` captures.
         if tool_name == "Bash" and not target_paths:
             allow()
 
-        branch = get_branch_name()
         phase_allowed, phase_error = is_editing_phase(branch)  # one state read
         if (
             tool_name == "Bash"
@@ -895,7 +976,7 @@ def main() -> None:
         # protected path alongside ordinary ones) denies as a whole — fail
         # closed on any protected target.
         tamper_paths = [p for p in target_paths if is_state_tamper_path(p)]
-        if tamper_paths and _is_workflow_active(branch):
+        if tamper_paths and (interrupted or _is_workflow_active(branch)):
             attempted = tamper_paths[0]
             try:
                 attempted = _to_repo_relative(tamper_paths[0]) or tamper_paths[0]