mapify-cli 3.31.3__py3-none-any.whl → 3.31.4__py3-none-any.whl

mapify_cli/__init__.py

@@ -23,7 +23,7 @@ Or install globally:
     mapify check
 """
 
-__version__ = "3.31.3"
+__version__ = "3.31.4"
 
 # 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/templates/codex/hooks/scrub-internal-ids.py

@@ -14,12 +14,16 @@ Gating (no-op in ~all turns):
     1. ``MAP_INVOKED_BY`` set            -> exit (don't run inside a sub-agent).
     2. no ``.map/<branch>/step_state.json`` OR ``workflow_status`` is not
        ``WORKFLOW_COMPLETE``            -> exit (run not finished).
-    3. marker ``.map/<branch>/.scrub_done`` present -> exit (already ran once).
-    4. ``scrub_internal_ids: false`` in ``.map/config.yaml`` -> exit (opt-out).
+    3. no ``.map/<branch>/run_health_report.json`` -> exit (final verification
+       not yet complete; ``workflow_status`` transitions to ``WORKFLOW_COMPLETE``
+       before the final-verifier step, so we gate on the health report instead).
+    4. marker ``.map/<branch>/.scrub_done`` present -> exit (already ran once).
+    5. ``scrub_internal_ids: false`` in ``.map/config.yaml`` -> exit (opt-out).
 
-When it does run: calls the engine in ``clean`` mode, commits the resulting
-working-tree changes as a dedicated ``chore(map): strip internal workflow IDs``
-commit (never amends), and writes the marker so it fires exactly once.
+When it does run: calls the engine in ``clean`` mode, leaves any cleaned files
+unstaged, prints a short ``stderr`` reminder to the operator, and writes the
+marker so it fires exactly once.  The operator decides how and whether to commit
+the changes (preserving the host repository's commit conventions).
 
 Synchronous by design (justified exception to the async-hook rule): the scrub
 must finish and commit before the run is considered done; a detached run would
@@ -135,6 +139,13 @@ def main() -> None:
     if status != "WORKFLOW_COMPLETE":
         _silent()
 
+    # Gate on run_health_report.json: written after the final-verifier step.
+    # workflow_status becomes WORKFLOW_COMPLETE before final verification, so
+    # we wait for the health report to avoid scrubbing while the verifier is
+    # reading HEAD.
+    if not (branch_dir / "run_health_report.json").exists():
+        _silent()
+
     marker = branch_dir / ".scrub_done"
     if marker.exists():
         _silent()
@@ -162,17 +173,16 @@ def main() -> None:
         report = {}
 
     modified = report.get("files_modified") or []
+    # Leave cleaned files unstaged so the operator can review and commit them
+    # using the host repository's conventions (ticket ID, sign-off, etc.).
+    # Never auto-commit with a fixed message.
     if modified:
-        try:
-            subprocess.run(["git", "add", "--", *modified], cwd=PROJECT_DIR,
-                           env=env, capture_output=True, text=True, timeout=15, check=False)
-            subprocess.run(
-                ["git", "commit", "-m", "chore(map): strip internal workflow IDs"],
-                cwd=PROJECT_DIR, env=env, capture_output=True, text=True, timeout=30,
-                check=False,
+        sys.stderr.write(
+            "[scrub-internal-ids] cleaned {} file(s) — review and commit with "
+            "your project's conventions:\n  git add -- {}\n".format(
+                len(modified), " ".join(modified)
             )
-        except (OSError, subprocess.SubprocessError):
-            pass  # leave the cleaned working tree in place; never block
+        )
 
     # Mark done so the scrub fires exactly once for this completed run.
     try:

mapify_cli/templates/codex/skills/map-efficient/SKILL.md

@@ -96,7 +96,7 @@ Resolve pending approval holds before `resume_from_plan` initializes any executi
 python3 .map/scripts/map_step_runner.py list_approval_holds --state pending
 ```
 
-A pending `plan_approval` requires an explicit operator approve/deny, recorded via `decide_approval_hold <hold-id> <approved|denied> --note "<operator note>"`: approved continues into Step 0, denied STOPS here — revise the plan and re-run `$map-plan` (no staleness re-check); an autonomous chain never reaches this ask because its pre-phase `auto_decide_holds` poll approves `plan_approval` first. A pending `dangerous_action`/`safety_guardrail` hold refuses to proceed instead — surface the hold's `reason` and stop.
+A ready plan needs no approval. A pending `plan_approval` (left by an older `$map-plan`) is not a gate: do not ask — close it via `decide_approval_hold <hold-id> approved --note "plan_approval no longer gates execution"` and continue into Step 0. A pending `dangerous_action`/`safety_guardrail` hold refuses to proceed instead — surface the hold's `reason` and stop.
 
 ## Step 0: Resume Existing State Or Plan
 

mapify_cli/templates/codex/skills/map-efficient/efficient-reference.md

@@ -6,9 +6,8 @@ Load only the section needed by the active phase.
 ## Approval-Hold Preflight
 
 Resolve any pending approval hold BEFORE Step 0's `resume_from_plan`
-bootstraps execution state — a hold left pending means execution has not
-been explicitly authorized, and a denied plan must stop before any
-`step_state.json` exists.
+bootstraps execution state. A ready plan itself needs no approval —
+`$map-plan` no longer opens a hold.
 
 ```bash
 python3 .map/scripts/map_step_runner.py list_approval_holds --state pending
@@ -16,31 +15,20 @@ python3 .map/scripts/map_step_runner.py list_approval_holds --state pending
 
 Each pending hold's `kind` decides the branch:
 
-- **`plan_approval`** — the operator must explicitly approve or deny before
-  execution starts:
+- **`plan_approval`** (left by an older `$map-plan`) — not a gate. Do not
+  ask the operator; close it and continue:
   ```bash
   python3 .map/scripts/map_step_runner.py decide_approval_hold \
-    <hold-id> approved --note "approved by operator; proceeding with plan"
-  # or:
-  python3 .map/scripts/map_step_runner.py decide_approval_hold \
-    <hold-id> denied --note "<why the plan was denied>"
+    <hold-id> approved --note "plan_approval no longer gates execution"
   ```
-  - **Approved** — continue into the pre-flight test baseline below.
-  - **Denied** — STOP. Tell the operator to revise the plan and re-run
-    `$map-plan`; there is no staleness re-check against the denied blueprint
-    — the operator who denied it is the same operator re-running
-    `$map-efficient`.
 - **`dangerous_action` / `safety_guardrail`** (hard stops) — never decide
   these from inside the preflight. Refuse to proceed: surface the hold's
   `reason` and `request_summary`, and stop. The operator resolves the
   underlying issue out of band and decides the hold via `decide_approval_hold`
   before retrying.
 
-An autonomous chain never reaches the interactive ask above: its pre-phase
-`auto_decide_holds` poll auto-approves `plan_approval` before `$map-efficient`
-starts, so the preflight here finds nothing pending. If the operator
-already decided the hold manually (CLI) before starting `$map-efficient`, the
-preflight likewise finds nothing pending and proceeds without asking.
+If the operator already decided a hold manually (CLI) before starting
+`$map-efficient`, the preflight finds nothing pending and proceeds.
 
 ## Pre-Monitor Gates
 

mapify_cli/templates/codex/skills/map-plan/SKILL.md

@@ -773,13 +773,9 @@ Record artifacts in the manifest:
 ```
 exec_command:
   cmd: |
-    PLAN_ARTIFACTS_RESULT=$(python3 .map/scripts/map_step_runner.py record_plan_artifacts)
-    printf '%s\n' "$PLAN_ARTIFACTS_RESULT"
-    PLAN_APPROVAL_HOLD_ID=$(printf '%s' "$PLAN_ARTIFACTS_RESULT" | jq -r '.plan_approval_hold_id // empty')
+    python3 .map/scripts/map_step_runner.py record_plan_artifacts
 ```
 
-`record_plan_artifacts` also opens a `plan_approval` hold at the plan-ready boundary and returns it as `plan_approval_hold_id` (idempotent — re-running finds the same pending hold instead of spamming a new one). Capture `PLAN_APPROVAL_HOLD_ID` for the Step 8 checkpoint. This hold does **not** block `$map-plan` itself: planning artifacts are written and Step 8 prints its checkpoint regardless of whether the hold is still pending. The decision (`decide_approval_hold <hold-id> approved|denied`) happens later, at the `$map-efficient` approval-hold preflight — or automatically via an autonomous chain's `auto_decide_holds` poll. If the result instead carries `plan_approval_hold_error: true`, the hold store failed — say so in the Step 8 checkpoint and have the operator create/decide the hold manually (`create_approval_hold --kind plan_approval ...`).
-
 ---
 
 ## Step 8: Output Checkpoint
@@ -804,7 +800,6 @@ exec_command:
     echo "[ok] Plan written to .map/${BRANCH}/task_plan_${BRANCH}.md"
     echo "[ok] artifact_manifest.json updated"
     echo "[ok] Mode: [standard | light | deep]"
-    echo "[ok] Plan approval hold: ${PLAN_APPROVAL_HOLD_ID:-none} — decide via decide_approval_hold <hold-id> <approved|denied> --note \"<operator note>\" before \$map-efficient will proceed"
     echo ""
     echo "Next steps:"
     echo "  1. Review .map/${BRANCH}/task_plan_${BRANCH}.md"

mapify_cli/templates/codex/skills/map-task/SKILL.md

@@ -71,7 +71,7 @@ fi
 python3 .map/scripts/map_step_runner.py list_approval_holds --state pending
 ```
 
-Pending `plan_approval`: ask the operator to approve or deny, then record the decision via `decide_approval_hold <hold-id> <approved|denied> --note "<operator note>"` — approved continues to the resume call below; denied STOPS here — tell the operator to revise the plan and re-run `$map-plan` (do not resume the subtask). Pending `dangerous_action`/`safety_guardrail`: refuse to proceed — surface the hold's `reason` and stop. `$map-task` never auto-decides either kind; both a hard-stop hold and a pending `plan_approval` always require an explicit operator response before single-subtask execution starts.
+A ready plan needs no approval. Pending `plan_approval` (left by an older `$map-plan`): do not ask — close it via `decide_approval_hold <hold-id> approved --note "plan_approval no longer gates execution"` and continue to the resume call below. Pending `dangerous_action`/`safety_guardrail`: refuse to proceed — surface the hold's `reason` and stop; `$map-task` never auto-decides these.
 
 ```bash
 BRANCH=$(git rev-parse --abbrev-ref HEAD | sed -E 's|/|-|g; s|[^a-zA-Z0-9_.-]|-|g; s|-{2,}|-|g; s|^-||; s|-$||')

mapify_cli/templates/hooks/scrub-internal-ids.py

@@ -14,12 +14,16 @@ Gating (no-op in ~all turns):
     1. ``MAP_INVOKED_BY`` set            -> exit (don't run inside a sub-agent).
     2. no ``.map/<branch>/step_state.json`` OR ``workflow_status`` is not
        ``WORKFLOW_COMPLETE``            -> exit (run not finished).
-    3. marker ``.map/<branch>/.scrub_done`` present -> exit (already ran once).
-    4. ``scrub_internal_ids: false`` in ``.map/config.yaml`` -> exit (opt-out).
+    3. no ``.map/<branch>/run_health_report.json`` -> exit (final verification
+       not yet complete; ``workflow_status`` transitions to ``WORKFLOW_COMPLETE``
+       before the final-verifier step, so we gate on the health report instead).
+    4. marker ``.map/<branch>/.scrub_done`` present -> exit (already ran once).
+    5. ``scrub_internal_ids: false`` in ``.map/config.yaml`` -> exit (opt-out).
 
-When it does run: calls the engine in ``clean`` mode, commits the resulting
-working-tree changes as a dedicated ``chore(map): strip internal workflow IDs``
-commit (never amends), and writes the marker so it fires exactly once.
+When it does run: calls the engine in ``clean`` mode, leaves any cleaned files
+unstaged, prints a short ``stderr`` reminder to the operator, and writes the
+marker so it fires exactly once.  The operator decides how and whether to commit
+the changes (preserving the host repository's commit conventions).
 
 Synchronous by design (justified exception to the async-hook rule): the scrub
 must finish and commit before the run is considered done; a detached run would
@@ -135,6 +139,13 @@ def main() -> None:
     if status != "WORKFLOW_COMPLETE":
         _silent()
 
+    # Gate on run_health_report.json: written after the final-verifier step.
+    # workflow_status becomes WORKFLOW_COMPLETE before final verification, so
+    # we wait for the health report to avoid scrubbing while the verifier is
+    # reading HEAD.
+    if not (branch_dir / "run_health_report.json").exists():
+        _silent()
+
     marker = branch_dir / ".scrub_done"
     if marker.exists():
         _silent()
@@ -162,17 +173,16 @@ def main() -> None:
         report = {}
 
     modified = report.get("files_modified") or []
+    # Leave cleaned files unstaged so the operator can review and commit them
+    # using the host repository's conventions (ticket ID, sign-off, etc.).
+    # Never auto-commit with a fixed message.
     if modified:
-        try:
-            subprocess.run(["git", "add", "--", *modified], cwd=PROJECT_DIR,
-                           env=env, capture_output=True, text=True, timeout=15, check=False)
-            subprocess.run(
-                ["git", "commit", "-m", "chore(map): strip internal workflow IDs"],
-                cwd=PROJECT_DIR, env=env, capture_output=True, text=True, timeout=30,
-                check=False,
+        sys.stderr.write(
+            "[scrub-internal-ids] cleaned {} file(s) — review and commit with "
+            "your project's conventions:\n  git add -- {}\n".format(
+                len(modified), " ".join(modified)
             )
-        except (OSError, subprocess.SubprocessError):
-            pass  # leave the cleaned working tree in place; never block
+        )
 
     # Mark done so the scrub fires exactly once for this completed run.
     try:

mapify_cli/templates/map/scripts/map_step_runner.py

@@ -528,7 +528,7 @@ APPROVAL_HOLD_KINDS = frozenset(
         "safety_guardrail",    # hard-deny safety hook triggered
         "autonomy_posture",    # git commit/push blocked by autonomy setting
         "template_overwrite",  # risky managed-file overwrite decision
-        "plan_approval",       # explicit plan approval gate
+        "plan_approval",       # legacy plan approval gate (no longer produced)
         "dangerous_action",    # generic risky action not otherwise categorised
     }
 )
@@ -4022,38 +4022,6 @@ def record_plan_artifacts(branch: str | None = None) -> dict[str, object]:
         "plan_status": stages["plan"]["status"],
     }
 
-    # Intent: emit the plan_approval hold at the plan-ready boundary (#422
-    # AC-1) -- once task_plan + blueprint are both present -- so the
-    # existing approval-hold lifecycle (#344) has a live producer instead of
-    # only synthetic test fixtures. request_summary is derived solely from
-    # the branch name (no timestamp/sha) so create_approval_hold's
-    # (kind, request_summary, pending) dedup makes re-running this function
-    # idempotent rather than spamming a fresh hold on every call.
-    # The producer is best-effort like the other live producers (#422 INV-4
-    # posture): a hold-store I/O failure must not fail the plan-artifact
-    # recording that already completed above -- the result simply carries no
-    # plan_approval_hold_id.
-    if plan_status == "ready":
-        try:
-            hold_result = create_approval_hold(
-                kind="plan_approval",
-                reason="The generated plan requires explicit approval before execution.",
-                request_summary=f"Approve the generated plan for {branch_name}",
-                source="map-plan",
-                branch=branch_name,
-                safe_continuation=(
-                    "Review the plan and decide the hold via decide_approval_hold "
-                    "(approved/denied) before starting /map-efficient or /map-task."
-                ),
-            )
-            if hold_result.get("status") == "ok":
-                result["plan_approval_hold_id"] = hold_result["hold_id"]
-        except Exception:  # noqa: BLE001 -- deliberate fallback/resilience boundary, must not propagate
-            # Surface the degradation instead of losing the approval gate
-            # silently: the Step 8 checkpoint prints this flag and the operator
-            # can create/decide the hold manually before execution.
-            result["plan_approval_hold_error"] = True
-
     return result
 
 

mapify_cli/templates/map/scripts/scrub_internal_ids.py

@@ -24,12 +24,18 @@ Safety model — conservative, hard-scoped, corruption-averse:
    and unknown types are skipped entirely — never blanked.
 3. EDIT. Only inside COMMENTS:
      - a comment whose payload is only an ID marker  -> delete the line;
-     - an ID token inside a larger comment           -> strip the token and tidy
-       adjacent decoration (``()`` / ``[]`` / stray ``:``), keep the line.
+     - an ID token inside a larger comment           -> strip the token and any
+       immediately trailing separator (``ID:`` -> `` ``, ``ID -`` -> `` ``),
+       empty brackets, and redundant whitespace. ``(ID)`` is handled by the
+       empty-bracket cleanup. The line is kept unless the whole comment becomes
+       empty.
    Test identifiers carrying ``vc<n>`` are renamed (``test_vc1_foo`` ->
-   ``test_foo``) with a collision guard. IDs in code, string literals, or
-   docstrings are LEFT IN PLACE and reported (stripping a string substring would
-   corrupt legitimate values, e.g. ``"INV-7-special-sku"`` or a JSON value).
+   ``test_foo``, ``TestFoo_VC1_Bar`` -> ``TestFoo_Bar``) with a collision guard.
+   IDs in code, string literals, or docstrings are LEFT IN PLACE and reported
+   (stripping a string substring would corrupt legitimate values, e.g.
+   ``"INV-7-special-sku"`` or a JSON value). Go subtest names
+   (``t.Run("AC-3: ...", ...)``) are string literals and therefore excluded;
+   they appear in the ``residual`` list so the operator can clean them manually.
 4. RE-SCAN. After cleaning, scope is scanned again; anything not removed is
    reported as ``residual`` rather than corrupted.
 
@@ -213,7 +219,13 @@ def scrub_line(line: str, syntax: dict | None) -> tuple[str | None, list[str], l
     eligible_spans: list[tuple[int, int]] = []
     for m in matches:
         if _region_kind(regions, m.start()) == "comment":
-            eligible_spans.append((m.start(), m.end()))
+            start, end = m.start(), m.end()
+            # Absorb a trailing separator ("ID: text" -> "text", "ID - note" -> "note")
+            # to avoid leaving broken prose. Only one separator consumed.
+            sep = re.match(r"[ \t]*[:\-][ \t]?", line[end:])
+            if sep:
+                end += sep.end()
+            eligible_spans.append((start, end))
             removed.append(m.group(0))
         else:
             residual.append(m.group(0))
@@ -254,9 +266,11 @@ def renamed_test_identifier(name: str) -> str | None:
     if not _VC_SEGMENT.search(name):
         return None
     new = _VC_SEGMENT.sub("", name)
-    new = re.sub(r"__+", "_", new)
-    new = re.sub(r"_+$", "", new)
-    new = re.sub(r"(?<=[A-Za-z])_(?=[A-Z])", "", new)  # Test_Foo -> TestFoo (Go/class)
+    new = re.sub(r"__+", "_", new)   # collapse double-underscore artifacts from removal
+    new = re.sub(r"_+$", "", new)    # strip trailing underscore artifacts
+    # NOTE: do NOT collapse single underscores (e.g. TestFoo_VC1_Bar -> TestFoo__Bar
+    # -> TestFoo_Bar). A blanket (?<=[A-Za-z])_(?=[A-Z]) rule would also remove
+    # legitimate Go table-test separators like TestFoo_CaseA.
     if not new or new in ("test", "test_", "Test"):
         return None
     if new == name:

mapify_cli/templates/skills/map-efficient/SKILL.md

@@ -106,7 +106,7 @@ phase that reads `$TASK_ARGS` — and resumed workflows skip it.
 python3 .map/scripts/map_step_runner.py list_approval_holds --state pending
 ```
 
-Pending `plan_approval`: ask the operator to approve/deny, then record via `decide_approval_hold <hold-id> <approved|denied> --note "<operator note>"` — approved continues into Step 0, denied STOPS here, BEFORE `resume_from_plan` initializes any execution state, with "revise the plan and re-run `/map-plan`" (no staleness re-check); `/map-auto` never reaches this ask because its pre-phase `auto_decide_holds` poll approves `plan_approval` first. Pending `dangerous_action`/`safety_guardrail`: refuse to proceed — surface the hold's `reason` and stop. Full recipe: [efficient-reference.md](efficient-reference.md#approval-hold-preflight).
+A ready plan needs no approval. Pending `plan_approval` (left by an older `/map-plan`): do not ask — close it via `decide_approval_hold <hold-id> approved --note "plan_approval no longer gates execution"` and continue into Step 0. Pending `dangerous_action`/`safety_guardrail`: refuse to proceed — surface the hold's `reason` and stop. Full recipe: [efficient-reference.md](efficient-reference.md#approval-hold-preflight).
 
 ## Step 0: Detect Existing State or Plan
 

mapify_cli/templates/skills/map-efficient/efficient-reference.md

@@ -466,9 +466,8 @@ It is read-only and exits 0 always; callers branch on `recommended_gate`.
 ## Approval-hold preflight
 
 Resolve any pending approval hold BEFORE Step 0's `resume_from_plan`
-bootstraps execution state — a hold left pending means execution has not
-been explicitly authorized, and a denied plan must stop before any
-`step_state.json` exists.
+bootstraps execution state. A ready plan itself needs no approval —
+`/map-plan` no longer opens a hold.
 
 ```bash
 python3 .map/scripts/map_step_runner.py list_approval_holds --state pending
@@ -476,31 +475,20 @@ python3 .map/scripts/map_step_runner.py list_approval_holds --state pending
 
 Each pending hold's `kind` decides the branch:
 
-- **`plan_approval`** — the operator must explicitly approve or deny before
-  execution starts:
+- **`plan_approval`** (left by an older `/map-plan`) — not a gate. Do not
+  ask the operator; close it and continue into the pre-flight test baseline:
   ```bash
   python3 .map/scripts/map_step_runner.py decide_approval_hold \
-    <hold-id> approved --note "approved by operator; proceeding with plan"
-  # or:
-  python3 .map/scripts/map_step_runner.py decide_approval_hold \
-    <hold-id> denied --note "<why the plan was denied>"
+    <hold-id> approved --note "plan_approval no longer gates execution"
   ```
-  - **Approved** — continue into the pre-flight test baseline below.
-  - **Denied** — STOP. Tell the operator to revise the plan and re-run
-    `/map-plan`; there is no staleness re-check against the denied blueprint —
-    the operator who denied it is the same operator re-running
-    `/map-efficient`.
 - **`dangerous_action` / `safety_guardrail`** (hard stops,
   `HARD_STOP_HOLD_KINDS`) — never decide these from inside the preflight.
   Refuse to proceed: surface the hold's `reason` and `request_summary`, and
   stop. The operator resolves the underlying issue out of band and decides
   the hold via `decide_approval_hold` before retrying.
 
-`/map-auto` runs never reach the interactive ask above: its pre-phase
-`auto_decide_holds` poll auto-approves `plan_approval` before `/map-efficient`
-starts, so the preflight here finds nothing pending. If the operator
-already decided the hold manually (CLI) before starting `/map-efficient`, the
-preflight likewise finds nothing pending and proceeds without asking.
+If the operator already decided a hold manually (CLI) before starting
+`/map-efficient`, the preflight finds nothing pending and proceeds.
 
 ## Pre-flight test baseline
 

mapify_cli/templates/skills/map-plan/SKILL.md

@@ -428,15 +428,11 @@ Rerun blueprint validation after writing the human-readable plan if any decompos
 Record planning artifacts in the branch manifest after spec, blueprint, and task plan exist. Use the named CLI — don't introspect the script:
 
 ```bash
-PLAN_ARTIFACTS_RESULT=$(python3 .map/scripts/map_step_runner.py record_plan_artifacts)
-echo "$PLAN_ARTIFACTS_RESULT"
-PLAN_APPROVAL_HOLD_ID=$(printf '%s' "$PLAN_ARTIFACTS_RESULT" | jq -r '.plan_approval_hold_id // empty')
+python3 .map/scripts/map_step_runner.py record_plan_artifacts
 ```
 
 `/map-plan` deliberately stops BEFORE `INIT_STATE` (that step belongs to `/map-efficient`), so `plan_status: "ready"` requires only `task_plan_<branch>.md` + `blueprint.json` — `step_state.json` will land later. Don't be alarmed by `has_step_state: false` in the response; it's the expected planning-complete state.
 
-`record_plan_artifacts` also opens a `plan_approval` hold at the plan-ready boundary and returns it as `plan_approval_hold_id` (idempotent — re-running finds the same pending hold instead of spamming a new one). Capture `PLAN_APPROVAL_HOLD_ID` for the Step 8 checkpoint. This hold does **not** block `/map-plan` itself: planning artifacts are written and Step 8 prints its checkpoint regardless of whether the hold is still pending. The decision (`decide_approval_hold <hold-id> approved|denied`) happens later, at the `/map-efficient` approval-hold preflight or the `/map-task` Step 1 preflight — or automatically via `/map-auto`'s hold poll. If the result instead carries `plan_approval_hold_error: true`, the hold store failed — say so in the Step 8 checkpoint and have the operator create/decide the hold manually (`create_approval_hold --kind plan_approval ...`).
-
 Runner functions you'll commonly need from `/map-plan`:
 
 | Function | Purpose |
@@ -460,11 +456,10 @@ Spec: .map/<branch>/spec_<branch>.md
 Blueprint: .map/<branch>/blueprint.json
 Task plan: .map/<branch>/task_plan_<branch>.md
 Mode: [standard | light | deep]
-Plan approval hold: <$PLAN_APPROVAL_HOLD_ID, or "none" if empty> — decide via `decide_approval_hold <hold-id> <approved|denied> --note "<operator note>"` before /map-efficient or /map-task will proceed
 Next: /map-efficient or /map-task for a selected subtask
 ```
 
-Include the active mode (`light` / `deep` / `standard`) so the operator knows which steps ran, and the `$PLAN_APPROVAL_HOLD_ID` captured in Step 7 on the "Plan approval hold" line. This hold does not gate the checkpoint — it prints whether the hold is pending, decided, or absent.
+Include the active mode (`light` / `deep` / `standard`) so the operator knows which steps ran. A ready plan needs no separate approval: `/map-efficient` or `/map-task` can start right away.
 
 ### Step 8.5: Execution Handoff Note
 

mapify_cli/templates/skills/map-release/SKILL.md

@@ -76,7 +76,7 @@ Execute all 12 gates. Read the full gate scripts in [release-reference.md § Pha
 - **Gates 5–6:** Build + twine check
 - **Gate 7:** Security audit (`pip-audit`)
 - **Gates 8–10:** Git state — main branch, clean working directory, up-to-date with origin
-- **Gate 11:** Latest CI run on main must have `conclusion: "success"`
+- **Gate 11:** CI run for `git merge-base HEAD origin/main` must have `conclusion: "success"`; unpushed commits may touch only release metadata
 - **Gate 12:** CHANGELOG.md completeness (Unreleased section exists and has content; commit/entry gap check)
 
 **If any gate fails:** ABORT. Fix issues, re-run Phase 1.

mapify_cli/templates/skills/map-release/release-reference.md

@@ -73,13 +73,21 @@ git pull origin main
 ### Gate 11: CI Status Verification
 
 ```bash
-gh run list --branch main --limit 1 --json conclusion,status,headBranch
-gh run view
+# CI only runs on pushed commits. Local commits on top of origin/main (a
+# docs(changelog) fix-up, later the chore(release) bump) never get a run, so
+# verify CI on the merge-base and allow only release-metadata files after it.
+git fetch origin main -q
+BASE_SHA=$(git merge-base HEAD origin/main)
+UNVERIFIED=$(git diff --name-only "$BASE_SHA" HEAD | grep -vxE 'CHANGELOG\.md|pyproject\.toml|src/mapify_cli/__init__\.py' || true)
+[[ -n "$UNVERIFIED" ]] && echo "❌ ABORT: local commits change files CI has not verified — push them and wait for CI:" && echo "$UNVERIFIED" && exit 1
+gh run list --commit "$BASE_SHA" --workflow CI --json conclusion,status,headSha --jq '.[0]'
 ```
 
 **Expected Results:**
-- ✅ Latest CI run on main branch has `conclusion: "success"`
+- ✅ Commits after `BASE_SHA` touch only `CHANGELOG.md`, `pyproject.toml`, `src/mapify_cli/__init__.py`
+- ✅ CI run for `BASE_SHA` has `conclusion: "success"` and `status: "completed"`
 - ✅ All jobs passed (build, test, lint)
+- ✅ `headSha` in the run output matches `BASE_SHA`
 
 **If CI failed:** ABORT release, investigate and fix CI failures first.
 
@@ -276,9 +284,19 @@ git tag -l -n50 "$LAST_TAG"
 CURRENT_BRANCH=$(git branch --show-current)
 [[ "$CURRENT_BRANCH" != "main" ]] && echo "❌ ABORT: Not on main branch" && exit 1
 
-LATEST_RUN=$(gh run list --branch main --limit 1 --json conclusion,status,createdAt,headBranch --jq '.[0]')
+# HEAD is the local chore(release) bump commit, which has no CI run yet.
+# Verify CI on the merge-base with origin/main and allow only
+# release-metadata files in the unpushed commits on top of it.
+git fetch origin main -q
+BASE_SHA=$(git merge-base HEAD origin/main)
+UNVERIFIED=$(git diff --name-only "$BASE_SHA" HEAD | grep -vxE 'CHANGELOG\.md|pyproject\.toml|src/mapify_cli/__init__\.py' || true)
+[[ -n "$UNVERIFIED" ]] && echo "❌ ABORT: unpushed commits change files CI has not verified:" && echo "$UNVERIFIED" && exit 1
+LATEST_RUN=$(gh run list --commit "$BASE_SHA" --workflow CI --json conclusion,status,headSha --jq '.[0]')
+[[ -z "$LATEST_RUN" || "$LATEST_RUN" == "null" ]] && echo "❌ ABORT: No CI run found for $BASE_SHA" && exit 1
+RUN_STATUS=$(printf '%s' "$LATEST_RUN" | jq -r '.status')
+[[ "$RUN_STATUS" != "completed" ]] && echo "❌ ABORT: CI run for $BASE_SHA is not completed (status: $RUN_STATUS)" && exit 1
 RUN_CONCLUSION=$(printf '%s' "$LATEST_RUN" | jq -r '.conclusion')
-[[ "$RUN_CONCLUSION" != "success" ]] && echo "❌ ABORT: Latest CI did not succeed" && exit 1
+[[ "$RUN_CONCLUSION" != "success" ]] && echo "❌ ABORT: CI run for $BASE_SHA did not succeed (conclusion: $RUN_CONCLUSION)" && exit 1
 
 LAST_TAG=$(git tag --sort=-version:refname | head -1)
 git ls-remote --tags origin | grep -q "refs/tags/$LAST_TAG" && echo "❌ ABORT: Tag already on remote" && exit 1

mapify_cli/templates/skills/map-task/SKILL.md

@@ -74,7 +74,7 @@ fi
 python3 .map/scripts/map_step_runner.py list_approval_holds --state pending
 ```
 
-Pending `plan_approval`: ask the operator to approve or deny, then record the decision via `decide_approval_hold <hold-id> <approved|denied> --note "<operator note>"` — approved continues to the resume call below; denied STOPS here — tell the operator to revise the plan and re-run `/map-plan` (do not resume the subtask). Pending `dangerous_action`/`safety_guardrail`: refuse to proceed — surface the hold's `reason` and stop. `/map-task` never auto-decides either kind; both a hard-stop hold and a pending `plan_approval` always require an explicit operator response before single-subtask execution starts.
+A ready plan needs no approval. Pending `plan_approval` (left by an older `/map-plan`): do not ask — close it via `decide_approval_hold <hold-id> approved --note "plan_approval no longer gates execution"` and continue to the resume call below. Pending `dangerous_action`/`safety_guardrail`: refuse to proceed — surface the hold's `reason` and stop; `/map-task` never auto-decides these.
 
 ```bash
 BRANCH=$(git rev-parse --abbrev-ref HEAD | sed -E 's|/|-|g; s|[^a-zA-Z0-9_.-]|-|g; s|-{2,}|-|g; s|^-||; s|-$||')

mapify_cli/templates_src/codex/skills/map-efficient/SKILL.md.jinja

@@ -91,7 +91,7 @@ Resolve pending approval holds before `resume_from_plan` initializes any executi
 python3 .map/scripts/map_step_runner.py list_approval_holds --state pending
 ```
 
-A pending `plan_approval` requires an explicit operator approve/deny, recorded via `decide_approval_hold <hold-id> <approved|denied> --note "<operator note>"`: approved continues into Step 0, denied STOPS here — revise the plan and re-run `$map-plan` (no staleness re-check); an autonomous chain never reaches this ask because its pre-phase `auto_decide_holds` poll approves `plan_approval` first. A pending `dangerous_action`/`safety_guardrail` hold refuses to proceed instead — surface the hold's `reason` and stop.
+A ready plan needs no approval. A pending `plan_approval` (left by an older `$map-plan`) is not a gate: do not ask — close it via `decide_approval_hold <hold-id> approved --note "plan_approval no longer gates execution"` and continue into Step 0. A pending `dangerous_action`/`safety_guardrail` hold refuses to proceed instead — surface the hold's `reason` and stop.
 
 ## Step 0: Resume Existing State Or Plan
 

mapify_cli/templates_src/codex/skills/map-efficient/efficient-reference.md.jinja

@@ -6,9 +6,8 @@ Load only the section needed by the active phase.
 ## Approval-Hold Preflight
 
 Resolve any pending approval hold BEFORE Step 0's `resume_from_plan`
-bootstraps execution state — a hold left pending means execution has not
-been explicitly authorized, and a denied plan must stop before any
-`step_state.json` exists.
+bootstraps execution state. A ready plan itself needs no approval —
+`$map-plan` no longer opens a hold.
 
 ```bash
 python3 .map/scripts/map_step_runner.py list_approval_holds --state pending
@@ -16,31 +15,20 @@ python3 .map/scripts/map_step_runner.py list_approval_holds --state pending
 
 Each pending hold's `kind` decides the branch:
 
-- **`plan_approval`** — the operator must explicitly approve or deny before
-  execution starts:
+- **`plan_approval`** (left by an older `$map-plan`) — not a gate. Do not
+  ask the operator; close it and continue:
   ```bash
   python3 .map/scripts/map_step_runner.py decide_approval_hold \
-    <hold-id> approved --note "approved by operator; proceeding with plan"
-  # or:
-  python3 .map/scripts/map_step_runner.py decide_approval_hold \
-    <hold-id> denied --note "<why the plan was denied>"
+    <hold-id> approved --note "plan_approval no longer gates execution"
   ```
-  - **Approved** — continue into the pre-flight test baseline below.
-  - **Denied** — STOP. Tell the operator to revise the plan and re-run
-    `$map-plan`; there is no staleness re-check against the denied blueprint
-    — the operator who denied it is the same operator re-running
-    `$map-efficient`.
 - **`dangerous_action` / `safety_guardrail`** (hard stops) — never decide
   these from inside the preflight. Refuse to proceed: surface the hold's
   `reason` and `request_summary`, and stop. The operator resolves the
   underlying issue out of band and decides the hold via `decide_approval_hold`
   before retrying.
 
-An autonomous chain never reaches the interactive ask above: its pre-phase
-`auto_decide_holds` poll auto-approves `plan_approval` before `$map-efficient`
-starts, so the preflight here finds nothing pending. If the operator
-already decided the hold manually (CLI) before starting `$map-efficient`, the
-preflight likewise finds nothing pending and proceeds without asking.
+If the operator already decided a hold manually (CLI) before starting
+`$map-efficient`, the preflight finds nothing pending and proceeds.
 
 ## Pre-Monitor Gates
 

mapify_cli/templates_src/codex/skills/map-plan/SKILL.md.jinja

@@ -768,13 +768,9 @@ Record artifacts in the manifest:
 ```
 exec_command:
   cmd: |
-    PLAN_ARTIFACTS_RESULT=$(python3 .map/scripts/map_step_runner.py record_plan_artifacts)
-    printf '%s\n' "$PLAN_ARTIFACTS_RESULT"
-    PLAN_APPROVAL_HOLD_ID=$(printf '%s' "$PLAN_ARTIFACTS_RESULT" | jq -r '.plan_approval_hold_id // empty')
+    python3 .map/scripts/map_step_runner.py record_plan_artifacts
 ```
 
-`record_plan_artifacts` also opens a `plan_approval` hold at the plan-ready boundary and returns it as `plan_approval_hold_id` (idempotent — re-running finds the same pending hold instead of spamming a new one). Capture `PLAN_APPROVAL_HOLD_ID` for the Step 8 checkpoint. This hold does **not** block `$map-plan` itself: planning artifacts are written and Step 8 prints its checkpoint regardless of whether the hold is still pending. The decision (`decide_approval_hold <hold-id> approved|denied`) happens later, at the `$map-efficient` approval-hold preflight — or automatically via an autonomous chain's `auto_decide_holds` poll. If the result instead carries `plan_approval_hold_error: true`, the hold store failed — say so in the Step 8 checkpoint and have the operator create/decide the hold manually (`create_approval_hold --kind plan_approval ...`).
-
 ---
 
 ## Step 8: Output Checkpoint
@@ -799,7 +795,6 @@ exec_command:
     echo "[ok] Plan written to .map/${BRANCH}/task_plan_${BRANCH}.md"
     echo "[ok] artifact_manifest.json updated"
     echo "[ok] Mode: [standard | light | deep]"
-    echo "[ok] Plan approval hold: ${PLAN_APPROVAL_HOLD_ID:-none} — decide via decide_approval_hold <hold-id> <approved|denied> --note \"<operator note>\" before \$map-efficient will proceed"
     echo ""
     echo "Next steps:"
     echo "  1. Review .map/${BRANCH}/task_plan_${BRANCH}.md"

mapify_cli/templates_src/codex/skills/map-task/SKILL.md.jinja

@@ -66,7 +66,7 @@ fi
 python3 .map/scripts/map_step_runner.py list_approval_holds --state pending
 ```
 
-Pending `plan_approval`: ask the operator to approve or deny, then record the decision via `decide_approval_hold <hold-id> <approved|denied> --note "<operator note>"` — approved continues to the resume call below; denied STOPS here — tell the operator to revise the plan and re-run `$map-plan` (do not resume the subtask). Pending `dangerous_action`/`safety_guardrail`: refuse to proceed — surface the hold's `reason` and stop. `$map-task` never auto-decides either kind; both a hard-stop hold and a pending `plan_approval` always require an explicit operator response before single-subtask execution starts.
+A ready plan needs no approval. Pending `plan_approval` (left by an older `$map-plan`): do not ask — close it via `decide_approval_hold <hold-id> approved --note "plan_approval no longer gates execution"` and continue to the resume call below. Pending `dangerous_action`/`safety_guardrail`: refuse to proceed — surface the hold's `reason` and stop; `$map-task` never auto-decides these.
 
 ```bash
 BRANCH=$(git rev-parse --abbrev-ref HEAD | sed -E 's|/|-|g; s|[^a-zA-Z0-9_.-]|-|g; s|-{2,}|-|g; s|^-||; s|-$||')