mapify-cli 3.34.2__tar.gz → 3.35.0__tar.gz

{mapify_cli-3.34.2 → mapify_cli-3.35.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: mapify-cli
-Version: 3.34.2
+Version: 3.35.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
@@ -221,7 +221,7 @@ The DevOpsConf 2026 case study applies this process to a production Kubernetes P
 | `/map-auto` | Single-entry autonomous autopilot: routes a task through existing MAP workflows and drives the chain to a committed branch |
 | `/map-plan` | **Start here** for non-trivial work; clarify behavior and decompose tasks |
 | `/map-prd-review` | Review a PRD with a 0-10 readiness score, strengths, risks, and uncovered edge cases |
-| `/map-wayfind` | Too foggy to plan? Resolve design decisions on a durable map *before* `/map-plan` |
+| `/map-wayfind` | Too foggy to plan? Resolve design decisions on a durable map *before* `/map-plan`; cite HTTP(S) docs, repo sources or hashed ticket-local observations |
 | `/map-efficient` | **Implement** an approved plan or already-scoped task |
 | `/map-fast` | Small, low-risk changes where full planning is overhead |
 | `/map-check` | Quality gates, verification, and artifact checks |
@@ -236,6 +236,8 @@ The DevOpsConf 2026 case study applies this process to a production Kubernetes P
 
 For stacked PRs, use `/map-review --base-ref runtime` (Codex: `$map-review --base-ref runtime`) to review only the child branch's changes against its parent's merge-base, including dirty work. Trusted review policy still comes from the default branch.
 
+Large `/map-review` bundles are delivered in bounded portions by the parent to the same reviewer. The full admitted evidence remains available within the 512 KiB message limit, including for Codex reviewers without shell or MCP access; missing or stale context keeps the review incomplete. Durable delivery acknowledgments and a post-delivery finalization token prevent premature final captures.
+
 [Detailed usage and options →](docs/USAGE.md)
 
 ## Why Engineers Stick With It
@@ -245,9 +247,10 @@ For stacked PRs, use `/map-review --base-ref runtime` (Codex: `$map-review --bas
 - **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 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.
 - **Bounded review/fix cycles** — `/map-review` retains round history and unresolved findings across restarts, suppresses acknowledged repeat publications, and stops after three unsuccessful attempts for reconsideration—not approval. Explicit abandonment recovers stale pending rounds without resetting that budget. Incremental re-review falls back to full review when baseline or dependency coverage is uncertain.
-- **Snapshot-bound review receipts** — review completeness, code approval, runner-executed checks and human consent are separate records. Missing reviewers, scope gaps or stale evidence cannot approve a changed snapshot. Read-only reviewers receive base/current source and attribution in the bundle; Codex findings remain available with explicit `INCOMPLETE` status until capability enforcement is verified.
+- **Snapshot-bound review receipts** — review completeness, code approval, runner-executed checks and human consent are separate records. Role-reviewer schemas require coverage receipts, and malformed receipts are rejected before capture. Missing reviewers, scope gaps or stale evidence cannot approve a changed snapshot. Incomplete or blocked collection stays pending in the same round until evidence is completed or the operator explicitly abandons it. Read-only reviewers receive base/current source and attribution in the bundle; Codex findings remain available with explicit `INCOMPLETE` status until capability enforcement is verified.
 - **Trusted review policy (shadow rollout)** — root and applicable ancestor `REVIEW.md` guidance comes from pinned default-branch Git objects, not proposed head content. Its hash joins the existing runtime/capability fingerprint; unknown authority prevents approval. New security/consent gates default to **shadow**: record diagnostics and pending snapshot/policy/action-bound holds without new blockers or weakening existing checks. Opt into **strict** with `review: {security_gates: strict}` in trusted-default `.map/config.yaml`; sensitive/unknown changes then require full coverage and independent security receipts regardless of auto/quick or disabled ledger enforcement. Human provenance is not yet verifiable: holds never become consent, and strict review-ready stays blocked. Corpus and evaluated promotion remain later #523 stages.
 - **Evidence-backed findings** — the existing Step A.3 separates confirmed defects, refuted claims and insufficient evidence. Validation checks the failure scenario, reachability and baseline; remediation searches a bounded scope for the same bug class. Adversarial agreement requires independent evidence-backed validations, not votes. Author reactions cannot close findings on their own.
+- **Comment cleanup at workflow close** — internal IDs are removed from run-changed comments while preserving documentation delimiters and surrounding code. Ambiguous prose stays intact for manual review; cleanup is left unstaged for your normal commit process ([details](docs/USAGE.md)).
 - **Project memory** — `/map-learn` turns hard-won fixes and gotchas into reusable context, so the next session doesn't relearn them. Automatic session memory also records bounded, redacted prompt topics and conservative tool observations, even outside a MAP workflow; observed references are not proof of successful outcomes. See [session memory](docs/USAGE.md#session-memory) for limits and recovery behavior.
 
 <details>
@@ -256,8 +259,9 @@ For stacked PRs, use `/map-review --base-ref runtime` (Codex: `$map-review --bas
 - **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. 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.
+- **Monitor in managed worktrees** — Actor gates read authoritative parent metadata while checking the registered candidate diff from its creation SHA. Dispatch carries explicit metadata and worktree paths; no mutable runtime snapshot needs to be copied into candidates.
 - **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.
+- **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. Soft constraints need coverage or a tradeoff rationale. File-drift checks recognize files that earlier dependencies explicitly create.
 - **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`. All runner subcommands support read-only `--help` / `-h`; for example, `python3 .map/scripts/map_step_runner.py write_run_health_report --help`.
@@ -288,12 +292,20 @@ command-driven dynamic status-line renderer. Codex supports project-level
 `[tui].status_line`, but only as an ordered list of built-in item identifiers,
 so MAP does not install the Claude renderer there.
 
+The shared iteration logger accepts textual tool responses from either provider
+without interrupting logging; effectiveness uses structured indicators when available.
+
 MAP is inspired by the [MAP cognitive architecture](https://github.com/Shanka123/MAP) (Nature Communications, 2025), which reported a 74% improvement on planning tasks. The CLI turns that idea into a practical software-development workflow.
 
 [Architecture deep-dive →](docs/ARCHITECTURE.md)
 
 ## What Success Looks Like
 
+Planning and handoff manifest registration work before the first commit: a branch such as `feat/new-project` uses `.map/feat-new-project/`. Isolated Actor worktrees still require an initial commit.
+
+`mapify init` keeps session logs, memory digests and Python bytecode out of Git
+by adding runtime ignore rules. Specs and planning artifacts remain shareable.
+
 After a good first workflow, you should see:
 
 - a written plan or spec before implementation starts;
@@ -304,6 +316,13 @@ After a good first workflow, you should see:
 
 MAP review is useful, but it is not a replacement for engineering judgment. Serious changes still need human review. The goal is to make that review smaller, earlier, and better grounded.
 
+Concurrent worktree groups must fit `execution.max_actors` (default 4, maximum 8).
+Create later batches after earlier batches merge. Aborting a group preserves
+recovery patches before deleting its worktrees.
+
+Candidate and acceptance commits run the project's Git hooks. A hook rejection
+blocks acceptance; configured verification checks also validate the merged result.
+
 ## Options
 
 <details>

{mapify_cli-3.34.2 → mapify_cli-3.35.0}/README.md

@@ -176,7 +176,7 @@ The DevOpsConf 2026 case study applies this process to a production Kubernetes P
 | `/map-auto` | Single-entry autonomous autopilot: routes a task through existing MAP workflows and drives the chain to a committed branch |
 | `/map-plan` | **Start here** for non-trivial work; clarify behavior and decompose tasks |
 | `/map-prd-review` | Review a PRD with a 0-10 readiness score, strengths, risks, and uncovered edge cases |
-| `/map-wayfind` | Too foggy to plan? Resolve design decisions on a durable map *before* `/map-plan` |
+| `/map-wayfind` | Too foggy to plan? Resolve design decisions on a durable map *before* `/map-plan`; cite HTTP(S) docs, repo sources or hashed ticket-local observations |
 | `/map-efficient` | **Implement** an approved plan or already-scoped task |
 | `/map-fast` | Small, low-risk changes where full planning is overhead |
 | `/map-check` | Quality gates, verification, and artifact checks |
@@ -191,6 +191,8 @@ The DevOpsConf 2026 case study applies this process to a production Kubernetes P
 
 For stacked PRs, use `/map-review --base-ref runtime` (Codex: `$map-review --base-ref runtime`) to review only the child branch's changes against its parent's merge-base, including dirty work. Trusted review policy still comes from the default branch.
 
+Large `/map-review` bundles are delivered in bounded portions by the parent to the same reviewer. The full admitted evidence remains available within the 512 KiB message limit, including for Codex reviewers without shell or MCP access; missing or stale context keeps the review incomplete. Durable delivery acknowledgments and a post-delivery finalization token prevent premature final captures.
+
 [Detailed usage and options →](docs/USAGE.md)
 
 ## Why Engineers Stick With It
@@ -200,9 +202,10 @@ For stacked PRs, use `/map-review --base-ref runtime` (Codex: `$map-review --bas
 - **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 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.
 - **Bounded review/fix cycles** — `/map-review` retains round history and unresolved findings across restarts, suppresses acknowledged repeat publications, and stops after three unsuccessful attempts for reconsideration—not approval. Explicit abandonment recovers stale pending rounds without resetting that budget. Incremental re-review falls back to full review when baseline or dependency coverage is uncertain.
-- **Snapshot-bound review receipts** — review completeness, code approval, runner-executed checks and human consent are separate records. Missing reviewers, scope gaps or stale evidence cannot approve a changed snapshot. Read-only reviewers receive base/current source and attribution in the bundle; Codex findings remain available with explicit `INCOMPLETE` status until capability enforcement is verified.
+- **Snapshot-bound review receipts** — review completeness, code approval, runner-executed checks and human consent are separate records. Role-reviewer schemas require coverage receipts, and malformed receipts are rejected before capture. Missing reviewers, scope gaps or stale evidence cannot approve a changed snapshot. Incomplete or blocked collection stays pending in the same round until evidence is completed or the operator explicitly abandons it. Read-only reviewers receive base/current source and attribution in the bundle; Codex findings remain available with explicit `INCOMPLETE` status until capability enforcement is verified.
 - **Trusted review policy (shadow rollout)** — root and applicable ancestor `REVIEW.md` guidance comes from pinned default-branch Git objects, not proposed head content. Its hash joins the existing runtime/capability fingerprint; unknown authority prevents approval. New security/consent gates default to **shadow**: record diagnostics and pending snapshot/policy/action-bound holds without new blockers or weakening existing checks. Opt into **strict** with `review: {security_gates: strict}` in trusted-default `.map/config.yaml`; sensitive/unknown changes then require full coverage and independent security receipts regardless of auto/quick or disabled ledger enforcement. Human provenance is not yet verifiable: holds never become consent, and strict review-ready stays blocked. Corpus and evaluated promotion remain later #523 stages.
 - **Evidence-backed findings** — the existing Step A.3 separates confirmed defects, refuted claims and insufficient evidence. Validation checks the failure scenario, reachability and baseline; remediation searches a bounded scope for the same bug class. Adversarial agreement requires independent evidence-backed validations, not votes. Author reactions cannot close findings on their own.
+- **Comment cleanup at workflow close** — internal IDs are removed from run-changed comments while preserving documentation delimiters and surrounding code. Ambiguous prose stays intact for manual review; cleanup is left unstaged for your normal commit process ([details](docs/USAGE.md)).
 - **Project memory** — `/map-learn` turns hard-won fixes and gotchas into reusable context, so the next session doesn't relearn them. Automatic session memory also records bounded, redacted prompt topics and conservative tool observations, even outside a MAP workflow; observed references are not proof of successful outcomes. See [session memory](docs/USAGE.md#session-memory) for limits and recovery behavior.
 
 <details>
@@ -211,8 +214,9 @@ For stacked PRs, use `/map-review --base-ref runtime` (Codex: `$map-review --bas
 - **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. 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.
+- **Monitor in managed worktrees** — Actor gates read authoritative parent metadata while checking the registered candidate diff from its creation SHA. Dispatch carries explicit metadata and worktree paths; no mutable runtime snapshot needs to be copied into candidates.
 - **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.
+- **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. Soft constraints need coverage or a tradeoff rationale. File-drift checks recognize files that earlier dependencies explicitly create.
 - **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`. All runner subcommands support read-only `--help` / `-h`; for example, `python3 .map/scripts/map_step_runner.py write_run_health_report --help`.
@@ -243,12 +247,20 @@ command-driven dynamic status-line renderer. Codex supports project-level
 `[tui].status_line`, but only as an ordered list of built-in item identifiers,
 so MAP does not install the Claude renderer there.
 
+The shared iteration logger accepts textual tool responses from either provider
+without interrupting logging; effectiveness uses structured indicators when available.
+
 MAP is inspired by the [MAP cognitive architecture](https://github.com/Shanka123/MAP) (Nature Communications, 2025), which reported a 74% improvement on planning tasks. The CLI turns that idea into a practical software-development workflow.
 
 [Architecture deep-dive →](docs/ARCHITECTURE.md)
 
 ## What Success Looks Like
 
+Planning and handoff manifest registration work before the first commit: a branch such as `feat/new-project` uses `.map/feat-new-project/`. Isolated Actor worktrees still require an initial commit.
+
+`mapify init` keeps session logs, memory digests and Python bytecode out of Git
+by adding runtime ignore rules. Specs and planning artifacts remain shareable.
+
 After a good first workflow, you should see:
 
 - a written plan or spec before implementation starts;
@@ -259,6 +271,13 @@ After a good first workflow, you should see:
 
 MAP review is useful, but it is not a replacement for engineering judgment. Serious changes still need human review. The goal is to make that review smaller, earlier, and better grounded.
 
+Concurrent worktree groups must fit `execution.max_actors` (default 4, maximum 8).
+Create later batches after earlier batches merge. Aborting a group preserves
+recovery patches before deleting its worktrees.
+
+Candidate and acceptance commits run the project's Git hooks. A hook rejection
+blocks acceptance; configured verification checks also validate the merged result.
+
 ## Options
 
 <details>

{mapify_cli-3.34.2 → mapify_cli-3.35.0}/pyproject.toml

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

{mapify_cli-3.34.2 → mapify_cli-3.35.0}/src/mapify_cli/__init__.py

@@ -23,7 +23,7 @@ Or install globally:
     mapify check
 """
 
-__version__ = "3.34.2"
+__version__ = "3.35.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
@@ -144,6 +144,7 @@ from mapify_cli.provider_registry import (
     SUPPORTED_PROVIDERS,
     skill_dir,
 )
+from mapify_cli.ralph_state import sanitize_branch_name
 
 if TYPE_CHECKING:
     from mapify_cli.install_manifest import InstallManifest
@@ -434,7 +435,7 @@ def _detect_provider(project_path: Path) -> str:
 def get_project_health(project_path: Path) -> dict[str, Any]:
     """Collect project health diagnostics for check/doctor commands."""
     agent_exclude = {"README.md", "CHANGELOG.md", "MCP-PATTERNS.md"}
-    current_branch = sanitize_identifier(get_current_branch_name())
+    current_branch = sanitize_branch_name(get_current_branch_name())
     branch_dir = project_path / ".map" / current_branch
     detected = _detect_provider(project_path)
 
@@ -548,7 +549,7 @@ def get_current_branch_name() -> str:
 
 def get_branch_workspace_dir(project_path: Path, branch: str | None = None) -> Path:
     """Return the branch-scoped MAP workspace directory."""
-    branch_name = sanitize_identifier(branch or get_current_branch_name())
+    branch_name = sanitize_branch_name(branch or get_current_branch_name())
     return project_path / ".map" / branch_name
 
 
@@ -563,7 +564,7 @@ def get_branch_artifact_templates() -> dict[str, str]:
 
 def initialize_branch_workspace(project_path: Path, branch: str | None = None) -> Path:
     """Create branch-scoped planning artifacts inside `.map/<branch>/`."""
-    branch_name = sanitize_identifier(branch or get_current_branch_name())
+    branch_name = sanitize_branch_name(branch or get_current_branch_name())
     workspace_dir = get_branch_workspace_dir(project_path, branch_name)
     workspace_dir.mkdir(parents=True, exist_ok=True)
 
@@ -579,7 +580,7 @@ def get_branch_workspace_status(
     project_path: Path, branch: str | None = None
 ) -> dict[str, Any]:
     """Collect status information for branch-scoped planning artifacts."""
-    branch_name = sanitize_identifier(branch or get_current_branch_name())
+    branch_name = sanitize_branch_name(branch or get_current_branch_name())
     workspace_dir = get_branch_workspace_dir(project_path, branch_name)
     expected_files = list(get_branch_artifact_templates().keys())
     existing_files = (

{mapify_cli-3.34.2 → mapify_cli-3.35.0}/src/mapify_cli/delivery/file_copier.py

@@ -511,6 +511,8 @@ _UPDATE_RUNTIME_GITIGNORE_PATHS = (
     ".map/provider-refresh.lock",
     ".map/installer.lock",
     ".map/gitignore.lock",
+    ".map/**/sessions/",
+    "**/__pycache__/",
     ".claude/worktrees/",
 )
 _WINDOWS_GITIGNORE_MUTEX_TIMEOUT_MS = 30_000
@@ -1135,6 +1137,48 @@ def _gitignore_pattern_matches(pattern: bytes, path: bytes) -> bool:
     return match(0, 0)
 
 
+def _gitignore_patterns_may_overlap(left: bytes, right: bytes) -> bool:
+    """Conservatively intersect patterns, including recursive directory rules.
+
+    Unlike matching a concrete path, either side can contain wildcards. Two
+    wildcard-bearing segments may overlap; literal segments still constrain the
+    result so unrelated negations do not cause repeated ignore-file growth.
+    """
+    def parts(pattern: bytes) -> list[bytes]:
+        stripped = pattern.rstrip(b"/")
+        segments = stripped.lstrip(b"/").split(b"/")
+        return [b"**", *segments] if b"/" not in stripped else segments
+
+    a, b = parts(left), parts(right)
+    pending = [(0, 0)]
+    seen: set[tuple[int, int]] = set()
+    while pending:
+        i, j = pending.pop()
+        if (i, j) in seen:
+            continue
+        seen.add((i, j))
+        if i == len(a) and j == len(b):
+            return True
+        if i < len(a) and a[i] == b"**":
+            pending.append((i + 1, j))
+            if j < len(b):
+                pending.append((i, j + 1))
+        elif j < len(b) and b[j] == b"**":
+            pending.append((i, j + 1))
+            if i < len(a):
+                pending.append((i + 1, j))
+        elif i < len(a) and j < len(b):
+            a_glob = any(char in a[i] for char in (b"*", b"?", b"["))
+            b_glob = any(char in b[j] for char in (b"*", b"?", b"["))
+            if (
+                (a_glob and b_glob)
+                or fnmatchcase(a[i], b[j])
+                or fnmatchcase(b[j], a[i])
+            ):
+                pending.append((i + 1, j + 1))
+    return False
+
+
 def _negation_targets_path(negation: bytes, required: bytes) -> bool:
     """Return whether a later ``!`` rule can plausibly re-include *required*.
 
@@ -1148,6 +1192,10 @@ def _negation_targets_path(negation: bytes, required: bytes) -> bool:
     if not pattern:
         return False
     base = required.rstrip(b"/")
+    if b"*" in base and _gitignore_patterns_may_overlap(
+        pattern, required
+    ):
+        return True
     if _gitignore_pattern_matches(pattern, base):
         return True
     pattern_base = pattern.rstrip(b"/")

{mapify_cli-3.34.2 → mapify_cli-3.35.0}/src/mapify_cli/memory/capture.py

@@ -55,7 +55,8 @@ def _sanitize_branch(name: str) -> str:
     rest of MAP (a path-traversal hardening applied there is inherited here).
     Behaviour: replaces every character not in [a-zA-Z0-9_.-] with '-',
     collapses consecutive '-', strips leading/trailing '-', and falls back to
-    "default" on empty result or path-traversal indicators.
+    "default" on empty input or path-traversal indicators. Non-empty names
+    stripped entirely by normalization use a deterministic SHA-256 scope.
     """
     return sanitize_branch_name(name)
 

{mapify_cli-3.34.2 → mapify_cli-3.35.0}/src/mapify_cli/ralph_state.py

@@ -10,6 +10,7 @@ State persisted to .map/<branch>/ralph_state.json
 Circuit breaker config source: .claude/ralph-loop-config.json
 """
 
+import hashlib
 import json
 import re
 from dataclasses import dataclass, field
@@ -299,7 +300,7 @@ def sanitize_branch_name(branch: str) -> str:
     # Prevent path traversal attempts
     if ".." in sanitized or sanitized.startswith("."):
         return "default"
-    return sanitized or "default"
+    return sanitized or ("branch-" + hashlib.sha256(branch.encode("utf-8")).hexdigest() if branch else "default")
 
 
 @dataclass

{mapify_cli-3.34.2 → mapify_cli-3.35.0}/src/mapify_cli/templates/agents/actor.md

@@ -289,6 +289,7 @@ Rules:
 8. Do NOT add temporal comments about test failure status (e.g., "currently FAILS",
    "expected to FAIL", "will PASS once fix is applied"). Write tests as permanent,
    clean code — the Red/Green state is transient and must not leak into comments.
+9. Every test must pass the vacuous-test check in section 5 (Testing Considerations).
 
 Output:
 - Test files created via Write tool
@@ -395,6 +396,31 @@ Document key decisions using this structure:
 - For each `VCn:` item in `validation_criteria`, implement or update at least one automated test that would fail without your change and pass with it.
 - Prefer naming tests with `vc<n>` (e.g., `test_vc1_*`, `TestVC1*`) so Monitor can deterministically confirm coverage.
 
+**Vacuous-test check (do-nothing implementation).** For every new or changed
+test, name the assertion that would FAIL if the code under test were replaced by
+a do-nothing implementation: each function returns the empty value of its return
+type (`None`, `[]`, `{}`, `""`, `0`, `False`) and performs no side effect (no
+write, no call, no state change). No such assertion means the test is
+**vacuous**: it stays green when the code does nothing, so it verifies no behavior.
+
+Typical vacuous shapes:
+- no assertion at all: `process(data)`
+- only a type/shape check an empty value satisfies: `assert isinstance(parse("a,b"), list)`
+- only `is not None` / truthiness of a value an empty implementation also returns: `assert load({"x": 1}) is not None`
+- only checks values the test set up itself, never calling the code under test: `repo.get.return_value = item; assert repo.get(1) == item`
+- expects an exception the test itself raises, not the code under test: `with pytest.raises(KeyError): load({"x": 1})["missing"]`
+
+Not vacuous: `assert parse("a,b") == ["a", "b"]`; expected-exception tests
+(`pytest.raises`, `assertRaises`, `toThrow`) whose exception is raised by the code
+under test, because a do-nothing implementation does not raise it; and, for code
+whose job is a side effect, assertions on that
+effect (written content, persisted row, a call with the expected arguments).
+This check catches tests that verify nothing; it does not prove a test checks the
+right thing (that needs mutation testing).
+
+Self-check before handoff: rewrite or drop any vacuous test. Monitor counts it as
+no coverage.
+
 **Format**:
 ```text
 1. test_[function]_[scenario]_[expected]
@@ -484,6 +510,7 @@ exhaustive test matrices by default.
 - [ ] Trade-offs documented with alternatives
 - [ ] Test cases cover happy + edge + error paths
 - [ ] Each `validation_criteria` item has at least one automated test (or explicit N/A with reason)
+- [ ] No vacuous tests: each new or changed test fails against a do-nothing implementation
 - [ ] Template variables `{{...}}` preserved in generated code
 
 ### Hallucination Guard

{mapify_cli-3.34.2 → mapify_cli-3.35.0}/src/mapify_cli/templates/agents/evaluator.md

@@ -624,6 +624,32 @@ Untested code is broken code waiting to happen. Testability indicates design qua
 - [ ] Happy path + error cases tested?
 - [ ] Edge cases covered?
 - [ ] Tests are deterministic (not flaky)?
+- [ ] Every new or changed test fails against a do-nothing implementation?
+
+**Vacuous-test check (do-nothing implementation).** For every new or changed
+test, name the assertion that would FAIL if the code under test were replaced by
+a do-nothing implementation: each function returns the empty value of its return
+type (`None`, `[]`, `{}`, `""`, `0`, `False`) and performs no side effect (no
+write, no call, no state change). No such assertion means the test is
+**vacuous**: it stays green when the code does nothing, so it verifies no behavior.
+
+Typical vacuous shapes:
+- no assertion at all: `process(data)`
+- only a type/shape check an empty value satisfies: `assert isinstance(parse("a,b"), list)`
+- only `is not None` / truthiness of a value an empty implementation also returns: `assert load({"x": 1}) is not None`
+- only checks values the test set up itself, never calling the code under test: `repo.get.return_value = item; assert repo.get(1) == item`
+- expects an exception the test itself raises, not the code under test: `with pytest.raises(KeyError): load({"x": 1})["missing"]`
+
+Not vacuous: `assert parse("a,b") == ["a", "b"]`; expected-exception tests
+(`pytest.raises`, `assertRaises`, `toThrow`) whose exception is raised by the code
+under test, because a do-nothing implementation does not raise it; and, for code
+whose job is a side effect, assertions on that
+effect (written content, persisted row, a call with the expected arguments).
+This check catches tests that verify nothing; it does not prove a test checks the
+right thing (that needs mutation testing).
+
+Score vacuous tests as absent: they add nothing to test coverage or test
+quality, and code covered only by vacuous tests is scored as untested.
 
 <example type="score_9">
 **Code**: Dependency injection, 95% coverage, tests for happy path + 5 error cases + 3 edge cases, mocked external APIs, isolated tests.

{mapify_cli-3.34.2 → mapify_cli-3.35.0}/src/mapify_cli/templates/agents/monitor.md

@@ -62,6 +62,26 @@ subtask metadata) apply only to Actor subtask validation, not standalone review.
 
 ### Actor runtime preflight in linked worktrees
 
+**Managed Actor worktree:** use the `monitor_instruction` returned by
+`create_subtask_worktree` (also included by `build_context_block` after creation).
+It names the parent metadata root, candidate checkout, and two absolute runner
+commands with **both** `--metadata-root <parent>` and `--worktree <candidate>`.
+Run those commands instead of the checkout-local commands below. The runner
+verifies the registered subtask/path and shared Git repository, reads the
+blueprint and prior results from the parent, and computes the candidate diff
+against its registered creation SHA. Parent dirty baselines never filter this
+diff. Read AAG/research/state from the supplied parent branch directory; run
+source inspection, builds, and tests in the candidate. Do not copy or symlink
+mutable `.map/` artifacts into managed candidates, and do not globally redirect
+`CLAUDE_PROJECT_DIR` to the parent. Explicit roots apply only to these gates.
+Missing/mismatched registration, metadata, or runner is a blocking setup error:
+report `valid: false`, `recommendation: "block"`; never fall back to the parent
+diff or silently use the checkout-local gates. Unset inherited Git directory
+and index variables for independent source/test commands as well.
+
+**Unmanaged checkout without explicit managed context:** use the existing
+checkout-local preflight below. A standalone `/map-review` skips both variants.
+
 Before invoking either Actor-specific `.map/scripts/map_step_runner.py` gate,
 clear inherited `GIT_DIR`, `GIT_WORK_TREE`, `GIT_COMMON_DIR`, and
 `GIT_INDEX_FILE` in a subshell before resolving the checkout being reviewed
@@ -1263,18 +1283,49 @@ for user in users:
 2. Check if external calls can be mocked
 3. Review included tests for coverage
 4. Validate test assertions are specific
+5. Apply the vacuous-test check below to every new or changed test
+
+**Vacuous-test check (do-nothing implementation).** For every new or changed
+test, name the assertion that would FAIL if the code under test were replaced by
+a do-nothing implementation: each function returns the empty value of its return
+type (`None`, `[]`, `{}`, `""`, `0`, `False`) and performs no side effect (no
+write, no call, no state change). No such assertion means the test is
+**vacuous**: it stays green when the code does nothing, so it verifies no behavior.
+
+Typical vacuous shapes:
+- no assertion at all: `process(data)`
+- only a type/shape check an empty value satisfies: `assert isinstance(parse("a,b"), list)`
+- only `is not None` / truthiness of a value an empty implementation also returns: `assert load({"x": 1}) is not None`
+- only checks values the test set up itself, never calling the code under test: `repo.get.return_value = item; assert repo.get(1) == item`
+- expects an exception the test itself raises, not the code under test: `with pytest.raises(KeyError): load({"x": 1})["missing"]`
+
+Not vacuous: `assert parse("a,b") == ["a", "b"]`; expected-exception tests
+(`pytest.raises`, `assertRaises`, `toThrow`) whose exception is raised by the code
+under test, because a do-nothing implementation does not raise it; and, for code
+whose job is a side effect, assertions on that
+effect (written content, persisted row, a call with the expected arguments).
+This check catches tests that verify nothing; it does not prove a test checks the
+right thing (that needs mutation testing).
+
+A vacuous test does not count as coverage: a `VCn` or requirement covered only
+by vacuous tests has `test_coverage != PASS` and falls under the contract
+Decision Rule. Report each one as a `testability` issue titled
+`Vacuous test: <test id>` that names the missing assertion; severity HIGH when it
+is the only test for a requirement, otherwise MEDIUM.
 
 #### Pass Criteria
 - Dependencies injected, not hardcoded
 - Tests cover happy path and errors
 - Tests are deterministic and isolated
 - Assertions validate specific behaviors
+- Every new or changed test fails against a do-nothing implementation
 
 #### Common Failures
 - Hardcoded external dependencies
 - Missing tests for error cases
 - Flaky tests (time-dependent, order-dependent)
 - Generic assertions (assertTrue without specifics)
+- Vacuous tests that stay green against a do-nothing implementation
 
 #### Severity Mapping
 - **Critical**: Untestable design blocking all testing

{mapify_cli-3.34.2 → mapify_cli-3.35.0}/src/mapify_cli/templates/agents/review-reader.md

@@ -28,7 +28,16 @@ changed-hunk attribution instead of shell commands. A line existing at base does
 not prove a behavioral defect is pre-existing; require supporting context or mark
 attribution unknown. Request missing bundle content from the parent, never shell.
 
-Return the role's envelope with an additional receipt object:
+When the prompt provides parent-served context, return its exact context_request
+JSON and consume context_chunk continuations in this same session. Follow
+next_offset through eof and check offsets, total size and hash metadata against the manifest before using it. Request
+permitted resources from the parent, never read context object paths directly.
+These intermediate responses are not findings or final review envelopes.
+Wait for the parent's post-delivery finalization request before returning a final
+review. In structured final envelopes, echo its session_id and finalization_token
+in a context_receipt object.
+Delivery is parent_acknowledged; it does not prove inspection or capability.
+After receiving needed evidence, return the role's envelope with an additional receipt object:
 `receipt={covered_files:[],skipped_files:[],denied_access:[],check_evidence:[check_id]}`.
 List only paths actually inspected in covered_files; report skipped scope and denied
 required access honestly. Reading claims are self_reported, not tool_witnessed.

{mapify_cli-3.34.2 → mapify_cli-3.35.0}/src/mapify_cli/templates/codex/agents/actor.toml

@@ -22,6 +22,32 @@ changes, never revert unrelated work, and adapt to concurrent edits.
 6. Never edit generated MAP trees directly when repository instructions designate a
    template source; edit the source and run the documented renderer.
 7. Do not commit, publish, delete broad paths, or expand scope without explicit authority.
+8. Before reporting, apply the vacuous-test check below to every test you wrote or
+   changed; rewrite or drop any vacuous test. Monitor counts it as no coverage.
+
+# Vacuous tests
+
+**Vacuous-test check (do-nothing implementation).** For every new or changed
+test, name the assertion that would FAIL if the code under test were replaced by
+a do-nothing implementation: each function returns the empty value of its return
+type (`None`, `[]`, `{}`, `""`, `0`, `False`) and performs no side effect (no
+write, no call, no state change). No such assertion means the test is
+**vacuous**: it stays green when the code does nothing, so it verifies no behavior.
+
+Typical vacuous shapes:
+- no assertion at all: `process(data)`
+- only a type/shape check an empty value satisfies: `assert isinstance(parse("a,b"), list)`
+- only `is not None` / truthiness of a value an empty implementation also returns: `assert load({"x": 1}) is not None`
+- only checks values the test set up itself, never calling the code under test: `repo.get.return_value = item; assert repo.get(1) == item`
+- expects an exception the test itself raises, not the code under test: `with pytest.raises(KeyError): load({"x": 1})["missing"]`
+
+Not vacuous: `assert parse("a,b") == ["a", "b"]`; expected-exception tests
+(`pytest.raises`, `assertRaises`, `toThrow`) whose exception is raised by the code
+under test, because a do-nothing implementation does not raise it; and, for code
+whose job is a side effect, assertions on that
+effect (written content, persisted row, a call with the expected arguments).
+This check catches tests that verify nothing; it does not prove a test checks the
+right thing (that needs mutation testing).
 
 # Output
 

{mapify_cli-3.34.2 → mapify_cli-3.35.0}/src/mapify_cli/templates/codex/agents/evaluator.toml

@@ -88,6 +88,31 @@ Weighting: readability 40%, maintainability 30%, idioms 30%.
 0-1: hardcoded dependencies, no test consideration.
 Weighting: test coverage 40%, test quality 30%, design for testability 30%.
 
+**Vacuous-test check (do-nothing implementation).** For every new or changed
+test, name the assertion that would FAIL if the code under test were replaced by
+a do-nothing implementation: each function returns the empty value of its return
+type (`None`, `[]`, `{}`, `""`, `0`, `False`) and performs no side effect (no
+write, no call, no state change). No such assertion means the test is
+**vacuous**: it stays green when the code does nothing, so it verifies no behavior.
+
+Typical vacuous shapes:
+- no assertion at all: `process(data)`
+- only a type/shape check an empty value satisfies: `assert isinstance(parse("a,b"), list)`
+- only `is not None` / truthiness of a value an empty implementation also returns: `assert load({"x": 1}) is not None`
+- only checks values the test set up itself, never calling the code under test: `repo.get.return_value = item; assert repo.get(1) == item`
+- expects an exception the test itself raises, not the code under test: `with pytest.raises(KeyError): load({"x": 1})["missing"]`
+
+Not vacuous: `assert parse("a,b") == ["a", "b"]`; expected-exception tests
+(`pytest.raises`, `assertRaises`, `toThrow`) whose exception is raised by the code
+under test, because a do-nothing implementation does not raise it; and, for code
+whose job is a side effect, assertions on that
+effect (written content, persisted row, a call with the expected arguments).
+This check catches tests that verify nothing; it does not prove a test checks the
+right thing (that needs mutation testing).
+
+Score vacuous tests as absent: they add nothing to test coverage or test
+quality, and code covered only by vacuous tests is scored as untested.
+
 ## 6. Performance (0-10)
 10: efficient algorithms, appropriate data structures, handles scale.
 8-9: reasonable complexity, minor optimizations possible.