mapify-cli 3.36.0__tar.gz → 3.37.0__tar.gz

{mapify_cli-3.36.0 → mapify_cli-3.37.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: mapify-cli
-Version: 3.36.0
+Version: 3.37.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

{mapify_cli-3.36.0 → mapify_cli-3.37.0}/pyproject.toml

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

{mapify_cli-3.36.0 → mapify_cli-3.37.0}/src/mapify_cli/__init__.py

@@ -23,7 +23,7 @@ Or install globally:
     mapify check
 """
 
-__version__ = "3.36.0"
+__version__ = "3.37.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.36.0 → mapify_cli-3.37.0}/src/mapify_cli/auto_update.py

@@ -12,6 +12,7 @@ import httpx
 
 from mapify_cli import create_ssl_context
 from mapify_cli.config import load_map_config
+from mapify_cli.install_manifest import read_manifest
 from mapify_cli.update_install import (
     InstallKind,
     PackageUpdateError,
@@ -175,10 +176,22 @@ def record_declined_major(
     declined = StableVersion.parse(declined_major)
     if current is None:
         raise ValueError("installed MAP version is not a stable version")
-    if declined is None or declined.major <= current.major:
+    if declined is None:
         raise ValueError(
             "declined major must be a stable version above the installed major"
         )
+    if declined.major <= current.major:
+        # Intent: a project a major behind the running CLI is offered the CLI's own
+        # major (#643); that exact offer may be declined too.
+        stale = _stale_project_providers(Path(project_path).resolve(), current)
+        if (
+            declined != current
+            or stale is None
+            or not _major_behind(stale[0], current)
+        ):
+            raise ValueError(
+                "declined major must be a stable version above the installed major"
+            )
 
     project = Path(project_path).resolve()
     with project_update_lock(project, timeout_s=LOCK_TIMEOUT_SECONDS):
@@ -443,6 +456,60 @@ def _metadata_unavailable_result(
     )
 
 
+def _stale_project_providers(
+    project_path: Path, current: StableVersion
+) -> tuple[StableVersion, tuple[str, ...]] | None:
+    """Return (installed version, providers) when project files predate the CLI.
+
+    Intent: PyPI-based discovery only asks whether a newer CLI exists, so a CLI
+    upgraded outside the updater (#643) left project files stale while the result
+    stayed ``current``. The lock's ``mapify_version`` is the project's installed
+    version; an older stable value is local proof a refresh is owed. A newer or
+    unreadable project version never downgrades.
+    """
+    manifest = read_manifest(project_path)
+    if manifest is None:
+        return None
+    installed = StableVersion.parse(manifest.mapify_version)
+    if installed is None or installed >= current:
+        return None
+    providers = installed_providers(project_path)
+    if not providers:
+        return None
+    return installed, providers
+
+
+def _major_behind(installed: StableVersion, current: StableVersion) -> bool:
+    return installed.major < current.major
+
+
+def _stale_project_state(
+    project_path: Path,
+    state: UpdateState,
+    current: StableVersion,
+    mode: UpdateMode,
+) -> UpdateState | None:
+    """Return a pending-refresh state when a stale project may refresh now.
+
+    Same-major staleness refreshes in both modes. A project a MAJOR behind
+    refreshes only in manual mode; automatic mode offers it through the existing
+    major-consent flow instead (see ``_check_locked``).
+    """
+    stale = _stale_project_providers(project_path, current)
+    if stale is None:
+        return None
+    installed, providers = stale
+    if mode is UpdateMode.AUTOMATIC and _major_behind(installed, current):
+        return None
+    return replace(
+        state,
+        last_installed_version=str(current),
+        pending_install_version=None,
+        pending_refresh=True,
+        pending_providers=providers,
+    )
+
+
 def _check_locked(
     project_path: Path,
     current_version: str,
@@ -489,6 +556,14 @@ def _check_locked(
                 write_update_state(project_path, cleared)
                 progress.state = cleared
 
+        if not progress.state.pending_refresh:
+            stale_state = _stale_project_state(
+                project_path, progress.state, current, mode
+            )
+            if stale_state is not None:
+                write_update_state(project_path, stale_state)
+                progress.state = stale_state
+
         if progress.state.pending_refresh:
             if mode is UpdateMode.AUTOMATIC and not refresh_retry_due(
                 progress.state,
@@ -567,6 +642,17 @@ def _check_locked(
                     refresh_complete=True,
                 )
             progress.recovered_refresh = True
+            if approved_major == str(current):
+                # Intent: approving the CLI's own major for a project a major
+                # behind is a refresh only; there is no newer package to install.
+                return UpdateResult(
+                    UpdateStatus.UPDATED,
+                    current_version,
+                    installed_version=progress.installed_version,
+                    refreshed_providers=progress.refreshed_providers,
+                    reload_current_skill=True,
+                    refresh_complete=True,
+                )
 
         if mode is UpdateMode.AUTOMATIC and not automatic_check_due(
             progress.state,
@@ -591,6 +677,38 @@ def _check_locked(
             )
             write_update_state(project_path, progress.state)
 
+        if mode is UpdateMode.AUTOMATIC:
+            stale = _stale_project_providers(project_path, current)
+            if (
+                stale is not None
+                and _major_behind(stale[0], current)
+                and progress.state.declined_major_version != str(current)
+            ):
+                # Intent: a project a major behind the running CLI is stale, not
+                # current (#643). Reuse the major-consent signal: approving
+                # refreshes the project (no package install), declining records
+                # the exact offer so it does not repeat.
+                with httpx.Client(verify=create_ssl_context()) as offer_client:
+                    offer = fetch_release_highlights(current, offer_client)
+                if offer is None:
+                    return _metadata_unavailable_result(
+                        mode,
+                        current_version,
+                        installed_version=progress.installed_version,
+                        refreshed_providers=progress.refreshed_providers,
+                        reload_current_skill=progress.reload_current_skill,
+                        refresh_complete=progress.refresh_complete,
+                    )
+                return UpdateResult(
+                    UpdateStatus.MAJOR_AVAILABLE,
+                    current_version,
+                    installed_version=progress.installed_version,
+                    major=offer,
+                    refreshed_providers=progress.refreshed_providers,
+                    reload_current_skill=progress.reload_current_skill,
+                    refresh_complete=progress.refresh_complete,
+                )
+
         with httpx.Client(verify=create_ssl_context()) as client:
             targets = fetch_version_targets(current, client)
             _validate_targets(targets, current)

{mapify_cli-3.36.0 → mapify_cli-3.37.0}/src/mapify_cli/templates/codex/skills/map-release/SKILL.md

@@ -11,7 +11,7 @@ For `updated`, re-read this invoked skill's installed `SKILL.md`, skip its alrea
 
 # MAP Framework Release Workflow
 
-**CRITICAL INSTRUCTION:** This is an **automated sequential workflow with IRREVERSIBLE operations**. You MUST execute ALL validation gates and get explicit user confirmation before pushing tags.
+**CRITICAL INSTRUCTION:** This is an **automated sequential workflow with IRREVERSIBLE operations**. You MUST execute ALL validation gates; any failing gate aborts the release. Invoking this skill is the operator's authorization to publish the version Phase 2 computes — never ask the operator questions.
 
 **🚨 ABSOLUTELY FORBIDDEN 🚨**
 
@@ -20,7 +20,7 @@ You are **STRICTLY PROHIBITED** from:
 ❌ Skipping validation gates to save time — every gate exists for a reason
 ❌ Pushing tags without CI confirmation — tag push triggers release workflow immediately
 ❌ Assuming tests passed without checking — always verify CI status explicitly
-❌ Proceeding without user confirmation on IRREVERSIBLE steps — tag push cannot be undone easily
+❌ Pushing a tag when any gate or the Phase 4.1 re-verification did not pass in this run — tag push cannot be undone easily
 ❌ Creating releases without updating CHANGELOG.md — users need to know what changed
 ❌ Pushing tag without verifying `__version__` in `__init__.py` — CRITICAL: bump-version.sh has known bug
 ❌ Any variation of "I'll optimize the release process" — follow the workflow exactly
@@ -38,7 +38,7 @@ parallel_tool_policy: validation_gates_only
 
 - Use deeper reasoning for version selection, release safety, CI interpretation, and rollback decisions.
 - Parallelize only independent pre-release validation gates when their outputs do not depend on one another.
-- Keep version bumping, commits, tags, pushes, PyPI verification, and any irreversible or state-mutating operation sequential with the required user confirmation gates.
+- Keep version bumping, commits, tags, pushes, PyPI verification, and any irreversible or state-mutating operation sequential, each gated by the preceding verification block.
 
 ## Workflow Overview
 
@@ -47,7 +47,7 @@ This workflow orchestrates a complete package release through 7 sequential phase
 ```
 Phase 1: Pre-Release Validation (12 gates)
    ↓
-Phase 2: Version Determination (user decision)
+Phase 2: Version Determination (recommended bump, no prompt)
    ↓
 Phase 3: Execute Version Bump Script (updates code + git commit + tag)
    ↓
@@ -80,19 +80,18 @@ Execute all 12 gates. Read the full gate scripts in [release-reference.md § Pha
 
 ## Phase 2: Version Determination
 
-Read CHANGELOG.md `[Unreleased]` section to determine bump type (MAJOR/MINOR/PATCH/EXPLICIT).
-Get current version from `pyproject.toml`.
+Run the Phase 2 reference block with `RELEASE_REQUEST` set to the release argument
+(empty when none). It never asks: an explicit `X.Y.Z` or `patch`/`minor`/`major`
+argument wins, otherwise the recommended bump is chosen from `[Unreleased]`
+(an entry starting with `BREAKING` or a `### Removed`/`### Breaking` section → MAJOR,
+`### Added`/`### Changed` → MINOR, else PATCH) and a version that does not move forward aborts. Carry exactly the printed
+`BUMP_TYPE` and `NEW_VERSION` into Phase 3 and 4; each command runs in a fresh shell.
 
-Ask the user directly for PATCH / MINOR / MAJOR / EXPLICIT, and wait for their answer.
-
-For EXPLICIT, ask separately for the exact version. Carry only the user's approved
-`BUMP_TYPE` and exact `NEW_VERSION` into Phase 3; each command runs in a fresh shell.
-
-See [release-reference.md § Phase 2](release-reference.md#phase-2-version-determination) for the full question/option block.
+See [release-reference.md § Phase 2](release-reference.md#phase-2-version-determination).
 
 ## Phase 3: Execute Version Bump Script
 
-Show the exact approved version and bump type, then execute the Phase 3 reference
+Show the exact Phase 2 version and bump type, then execute the Phase 3 reference
 blocks with those values explicitly supplied in each invocation. Never rely on
 variables left by a previous shell. Verify the version-derived `vX.Y.Z` tag points
 to HEAD and both version fields match it using the Phase 3.3 reference block.
@@ -105,16 +104,13 @@ If `__version__` mismatches, follow the fix procedure in [release-reference.md
 
 Re-verify: on main branch, exact merge-base CI completed successfully with matching
 `headSha`, only the three allowed metadata files changed, version-derived tag
-points to HEAD and does not already exist on remote. Then request **explicit user
-confirmation** (YES / NO / REVIEW options).
-
-Ask the user directly and wait; only an unambiguous YES authorizes pushing.
+points to HEAD and does not already exist on remote. Then push without asking —
+invoking the release is the authorization. If the version, commit or tag changed
+since Phase 2, stop and re-run Phases 2–4.1 instead of pushing.
 
 Read [release-reference.md § Phase 4](release-reference.md#phase-4-push-commit-and-tag-irreversible)
-for the confirmation and push blocks. Recompute the tag in the push invocation;
-consent for an earlier version or commit does not authorize a changed release.
-
-If user aborts: stop workflow, exit gracefully. Tag remains local only.
+for the verification and push blocks. Recompute the tag in the push invocation and
+pass `NEW_VERSION` so a changed release aborts.
 
 ## Phase 5: CI/CD Monitoring
 
@@ -136,7 +132,7 @@ Print release statistics (version, tag, PyPI URL, GitHub Release URL, CI run). O
 
 - **NEVER skip validation gates** — all 12 gates must pass before Phase 4
 - **NEVER push tag without CI confirmation** — verify CI passed on main before Phase 4
-- **NEVER proceed without user confirmation on IRREVERSIBLE operations**
+- **NEVER push unless Phase 4.1 passed in this run for the Phase 2 version** — no operator prompt replaces a gate
 - **ALWAYS monitor CI/CD pipeline** — don't assume success
 - **ALWAYS verify PyPI availability** before declaring success
 
@@ -147,10 +143,10 @@ Print release statistics (version, tag, PyPI URL, GitHub Release URL, CI run). O
 | 1 | Pytest tests | ❌ NO |
 | 2 | Pyright + hook lint | ❌ NO |
 | 3 | Ruff lint | ❌ NO |
-| 4 | Mypy types | ⚠️ Review |
+| 4 | Mypy types | ❌ NO |
 | 5 | Package build | ❌ NO |
 | 6 | Twine check | ❌ NO |
-| 7 | Security audit | ⚠️ Review |
+| 7 | Security audit | ❌ NO (update the vulnerable pin first) |
 | 8 | Git branch | ❌ NO |
 | 9 | Git clean | ❌ NO |
 | 10 | Git sync | ❌ NO |
@@ -162,8 +158,8 @@ Begin now with the release request above. Read the relevant [release-reference.m
 ## Examples
 
 ```
-$map-release                            # full release workflow; bump type chosen at the confirmation gate
-$map-release patch                      # hint to the version-determination phase
+$map-release                            # full release; recommended bump chosen from [Unreleased]
+$map-release patch                      # force a bump type (patch|minor|major)
 ```
 
 ## Troubleshooting

{mapify_cli-3.36.0 → mapify_cli-3.37.0}/src/mapify_cli/templates/codex/skills/map-release/release-reference.md

@@ -160,36 +160,10 @@ if [[ -n "$LAST_TAG" ]]; then
     awk '/^## \[Unreleased\]/{f=1;next} /^## \[/{f=0} f' CHANGELOG.md
     echo ""
 
-    # Ask user to update CHANGELOG
-    read -p "CHANGELOG appears incomplete. Update it now? (y/n): " UPDATE_CHANGELOG
-
-    if [[ "$UPDATE_CHANGELOG" == "y" ]]; then
-      echo ""
-      echo "Suggested CHANGELOG entries (review and add manually):"
-      echo "────────────────────────────────────────────────────────"
-      git log ${LAST_TAG}..HEAD --no-merges --format="%s (%h)" | while read -r commit_msg; do
-        if [[ "$commit_msg" =~ ^feat ]]; then
-          echo "### Changed"
-          echo "- ${commit_msg#feat*: }"
-        elif [[ "$commit_msg" =~ ^fix ]]; then
-          echo "### Fixed"
-          echo "- ${commit_msg#fix*: }"
-        elif [[ "$commit_msg" =~ ^docs ]]; then
-          echo "### Documentation"
-          echo "- ${commit_msg#docs*: }"
-        else
-          echo "### Changed"
-          echo "- $commit_msg"
-        fi
-      done
-      echo "────────────────────────────────────────────────────────"
-      echo ""
-      echo "Please update CHANGELOG.md manually, then re-run the release."
-      exit 1
-    else
-      read -p "Continue with potentially incomplete CHANGELOG? (y/N): " PROCEED_ANYWAY
-      [[ "$PROCEED_ANYWAY" != "y" ]] && exit 1
-    fi
+    # Never prompt: the release agent reconciles the CHANGELOG itself.
+    echo "ACTION: add the missing user-visible entries to [Unreleased] from the commits above"
+    echo "        in a docs(changelog) commit, then re-run Phase 1 Gates 8-12."
+    exit 2
   fi
 else
   echo "ℹ️  No previous tag found, skipping completeness check"
@@ -198,33 +172,58 @@ fi
 
 ## Phase 2: Version Determination
 
+Invoking the release is the authorization: never ask the operator. Run this block
+with `RELEASE_REQUEST` set to the release argument (empty when none). An explicit
+`X.Y.Z` or `patch`/`minor`/`major` argument wins; anything else selects the
+recommended bump from `[Unreleased]`.
+
 ```bash
-# Get current version from pyproject.toml
+set -euo pipefail
 CURRENT_VERSION=$(grep -m1 -E '^version = ' pyproject.toml | sed -E 's/version = "(.*)"/\1/')
-echo "Current version: $CURRENT_VERSION"
-
-# Read CHANGELOG unreleased section
-UNRELEASED_CHANGES=$(awk '/^## \[Unreleased\]/{f=1;next} /^## \[/{f=0} f' CHANGELOG.md)
+SEMVER='^(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)$'
+[[ "$CURRENT_VERSION" =~ $SEMVER ]] || { echo "ABORT: invalid current version '$CURRENT_VERSION'"; exit 1; }
+UNRELEASED=$(awk '/^## \[Unreleased\]/{f=1;next} /^## \[/{f=0} f' CHANGELOG.md)
+REQUEST=$(printf '%s' "${RELEASE_REQUEST:-}" | tr -d '[:space:]' | tr '[:upper:]' '[:lower:]')
+IFS=. read -r MAJ MIN PAT <<< "$CURRENT_VERSION"
+if [[ "$REQUEST" =~ $SEMVER ]]; then
+  BUMP_TYPE="$REQUEST"; NEW_VERSION="$REQUEST"
+else
+  case "$REQUEST" in
+    patch|minor|major) BUMP_TYPE="$REQUEST" ;;
+    *)
+      # Recommended bump: explicit breaking markers -> major, added/changed -> minor, else patch.
+      # Only an entry that STARTS with BREAKING (or a Removed/Breaking section) counts; the word
+      # inside prose (e.g. an entry describing this rule) must not force a major release.
+      if grep -qE '^- (\*\*)?BREAKING' <<< "$UNRELEASED" || grep -qE '^### (Removed|Breaking)' <<< "$UNRELEASED"; then
+        BUMP_TYPE=major
+      elif grep -qE '^### (Added|Changed)' <<< "$UNRELEASED"; then
+        BUMP_TYPE=minor
+      else
+        BUMP_TYPE=patch
+      fi ;;
+  esac
+  case "$BUMP_TYPE" in
+    major) NEW_VERSION="$((MAJ + 1)).0.0" ;;
+    minor) NEW_VERSION="$MAJ.$((MIN + 1)).0" ;;
+    patch) NEW_VERSION="$MAJ.$MIN.$((PAT + 1))" ;;
+  esac
+fi
+IFS=. read -r NMAJ NMIN NPAT <<< "$NEW_VERSION"
+if (( NMAJ < MAJ || (NMAJ == MAJ && (NMIN < MIN || (NMIN == MIN && NPAT <= PAT))) )); then
+  echo "ABORT: $NEW_VERSION does not move forward from $CURRENT_VERSION"; exit 1
+fi
+echo "BUMP_TYPE=$BUMP_TYPE"
+echo "NEW_VERSION=$NEW_VERSION"
 ```
 
-**Semantic Versioning Rules:**
-- **MAJOR (X.0.0):** Breaking changes, incompatible API/workflow changes
-- **MINOR (x.Y.0):** New features, backward-compatible additions
-- **PATCH (x.y.Z):** Bug fixes and minor improvements
-
+**Semantic Versioning Rules (applied above):**
+- **MAJOR (X.0.0):** an entry starting with `BREAKING` (or `**BREAKING**`), or a `### Removed` / `### Breaking` section
+- **MINOR (x.Y.0):** an `### Added` or `### Changed` section
+- **PATCH (x.y.Z):** only fixes
 
-Ask the user directly which bump to perform: PATCH for fixes, MINOR for
-backward-compatible features, MAJOR for breaking changes, or EXPLICIT.
-Do not choose on the user's behalf and do not continue until they answer.
-
-
-For EXPLICIT, ask a separate question for the exact `X.Y.Z` value; selecting the
-option alone supplies no version. Validate `^(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)$`.
-Calculate the proposed `NEW_VERSION` from the user's bump choice and current
-version (or their explicit version). Show the exact result before execution.
-Supply `BUMP_TYPE` (`patch`, `minor`, `major`, or the exact version) and
-`NEW_VERSION` explicitly to **each** Phase 3 shell invocation, using only these
-approved values. Missing values abort; never assume a previous shell survives.
+Print the selected bump and version, then carry exactly these `BUMP_TYPE` and
+`NEW_VERSION` values into **each** Phase 3 and Phase 4 shell invocation. Missing
+values abort; never assume a previous shell survives.
 
 ## Phase 3: Execute Version Bump Script
 
@@ -232,9 +231,9 @@ approved values. Missing values abort; never assume a previous shell survives.
 
 ```bash
 set -euo pipefail
-: "${BUMP_TYPE:?Supply the user-approved bump type for this invocation}"
-: "${NEW_VERSION:?Supply the user-approved exact version for this invocation}"
-[[ "$NEW_VERSION" =~ ^(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)$ ]] || { echo "ABORT: invalid approved version"; exit 1; }
+: "${BUMP_TYPE:?Supply the Phase 2 bump type for this invocation}"
+: "${NEW_VERSION:?Supply the Phase 2 exact version for this invocation}"
+[[ "$NEW_VERSION" =~ ^(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)$ ]] || { echo "ABORT: invalid Phase 2 version"; exit 1; }
 echo "Version Bump Script Will Execute:"
 echo "1. Update pyproject.toml: version = \"$NEW_VERSION\""
 echo "2. Update CHANGELOG.md: [Unreleased] → [$NEW_VERSION] - $(date +%Y-%m-%d)"
@@ -247,11 +246,11 @@ echo "Changes will be committed locally but NOT pushed yet."
 
 ```bash
 set -euo pipefail
-: "${BUMP_TYPE:?Supply the user-approved bump type for this invocation}"
-: "${NEW_VERSION:?Supply the user-approved exact version for this invocation}"
-[[ "$NEW_VERSION" =~ ^(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)$ ]] || { echo "ABORT: invalid approved version"; exit 1; }
-[[ "$BUMP_TYPE" =~ ^(patch|minor|major)$ || "$BUMP_TYPE" == "$NEW_VERSION" ]] || { echo "ABORT: invalid approved bump type"; exit 1; }
-# Intent: use the approved exact version so a changed current version cannot alter the bump.
+: "${BUMP_TYPE:?Supply the Phase 2 bump type for this invocation}"
+: "${NEW_VERSION:?Supply the Phase 2 exact version for this invocation}"
+[[ "$NEW_VERSION" =~ ^(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)$ ]] || { echo "ABORT: invalid Phase 2 version"; exit 1; }
+[[ "$BUMP_TYPE" =~ ^(patch|minor|major)$ || "$BUMP_TYPE" == "$NEW_VERSION" ]] || { echo "ABORT: invalid Phase 2 bump type"; exit 1; }
+# Intent: use the Phase 2 exact version so a changed current version cannot alter the bump.
 ./scripts/bump-version.sh --yes "$NEW_VERSION"
 ```
 
@@ -343,18 +342,13 @@ REMOTE_TAG=$(git ls-remote --tags origin "refs/tags/$LAST_TAG" "refs/tags/$LAST_
 echo "✅ Pre-push safety checks passed"
 ```
 
-### 4.2 User Confirmation
-
-
-Ask the user directly for explicit confirmation before pushing. State that
-`$LAST_TAG` to `origin/main` will trigger GitHub Actions, publish to PyPI, and
-create a public GitHub release. Accept only an unambiguous YES; NO aborts, and
-REVIEW shows the commit, tag, and CHANGELOG before asking again.
+### 4.2 Authorization
 
-
-If `REVIEW`: show `git show`, `git tag -l -n50 "$LAST_TAG"`, and CHANGELOG excerpt, then ask again.
-Only YES permits Phase 4.3. Repeat Phase 4.1 and ask again if the commit or version
-changes; never interpret REVIEW, silence, or an earlier bump choice as push consent.
+Invoking the release authorizes publishing the version computed in Phase 2; do not
+ask the operator. Proceed to 4.3 only when 4.1 printed its success line in this
+run. Before pushing, print the version, release commit and tag. If anything
+changed since Phase 2 (version, commit, tag), stop and re-run Phases 2–4.1 instead
+of pushing.
 
 ### 4.3 Push
 
@@ -366,7 +360,8 @@ LAST_TAG="v$PYPROJECT_VERSION"
 TAG_COMMIT=$(git rev-parse "$LAST_TAG^{commit}")
 HEAD_COMMIT=$(git rev-parse HEAD)
 [[ "$TAG_COMMIT" == "$HEAD_COMMIT" ]] || { echo "ABORT: release tag does not point to HEAD"; exit 1; }
-# Execute only after the user approved this exact tag and commit in Phase 4.2.
+: "${NEW_VERSION:?Supply the Phase 2 version for this invocation}"
+[[ "$PYPROJECT_VERSION" == "$NEW_VERSION" ]] || { echo "ABORT: release version $PYPROJECT_VERSION differs from Phase 2 ($NEW_VERSION)"; exit 1; }
 git push origin main
 git push origin "$LAST_TAG"
 PUSH_TIMESTAMP=$(date +%s)
@@ -529,9 +524,9 @@ You CANNOT delete packages from PyPI. Only option is yank.
 ### Scenario 5: PyPI Not Available After 5+ Minutes
 
 ```bash
-# Supply the exact release run ID from Phase 5 and the approved exact version.
+# Supply the exact release run ID from Phase 5 and the Phase 2 exact version.
 : "${RUN_ID:?Supply the verified release run ID for this invocation}"
-: "${TAG_VERSION:?Supply the approved exact release version for this invocation}"
+: "${TAG_VERSION:?Supply the Phase 2 exact release version for this invocation}"
 gh run view "$RUN_ID" --log | grep -A 10 "pypi-publish"
 # Check https://status.python.org/
 # Wait up to 15 minutes, probing the simple index pip resolves against —
@@ -560,15 +555,14 @@ gh run view <run-id> --log
 ## MCP Tools
 
 - **`mcp__sequential-thinking__sequentialthinking`** — complex decision making for version bump
-
-- **Direct user confirmation** — wait for explicit consent for IRREVERSIBLE operations
-
+- Invoking the release is the authorization; the workflow never prompts the operator. Hard gates abort instead.
 
 ## Examples
 
 ```
-$map-release                            # full release workflow; bump type chosen at confirmation gate
-$map-release patch                      # hint to version-determination phase
+$map-release                            # full release; recommended bump chosen from [Unreleased]
+$map-release patch                      # force a bump type (patch|minor|major)
+$map-release 4.0.0                      # force an exact version (must move forward)
 ```
 
 ## Troubleshooting

{mapify_cli-3.36.0 → mapify_cli-3.37.0}/src/mapify_cli/templates/codex/skills/map-review/review-reference.md

@@ -49,10 +49,40 @@ user tails, missing or malformed headers and files whose JSON was reformatted st
 any file and it is skipped (visibly, in `skipped_scope`). Use strict `review.security_gates` when PR
 authors are untrusted; it disables this skip. `review.exclude_mapify_managed: false` opts out.
 
+## Compact Prompt Context
+
+Execution checks appear as one line each (exit code, duration, command, `output_sha256`, size and the
+`check:<id>` resource for the full log). The trusted policy text appears once per prompt as UTF-8, marked
+`[trusted-policy:<hash>]`; `shadow_risk` is a summary (tier, reason count and sample, digest) and the
+inventory resource carries hashes and counts. Request `check:<id>` when a log is needed.
+
+Windowed sources carry `line_mapping_scope: "windowed"`: their `line_mapping` covers only the delivered
+windows, so a line outside every window is unknown, not new. `base:<path>` / `current:<path>` return the full
+mapping. A renamed file is windowed against its old blob (`renamed_from`); the old path is a `renamed_to` stub.
+The complete `shadow_risk` record is the optional resource `risk:shadow`.
+
+## Shard Capacity
+
+Shards are packed to the per-reviewer budget minus a measured overhead (the worst scheduled reviewer's
+rendered prompt, inventory, frozen task artifacts and, for Codex, inlined role rubrics, plus a margin;
+never below 64 KiB), also for unsharded rounds.
+
+## Windowed Large Files
+
+A changed text file whose full base+current source resource would exceed `review.full_source_max_bytes`
+(trusted config, default 48 KiB) is a required **windowed** source: its diff hunks plus
+`review.hunk_context_lines` (default 40) numbered lines of base and current context, marked
+`"windowed": true`. Reading it counts as delivery for that file; report it in `covered_files` as usual.
+When the window is not enough to judge a finding, request the optional full content as
+`resource_id` `base:<path>` or `current:<path>` (frozen on first use, same delivery guard as `repo:`;
+never available to diff-only/blind reviewers). Small files, binary/non-UTF-8 files and files without a
+verified base keep the full-content resource. A single file whose windowed hunks still exceed the
+shard capacity fails admission with `file_too_large`; split that change.
+
 ## Sharded Rounds
 
 When the required scope does not fit one reviewer's budget, admission plans `row.shards`
-(deterministic, directory-aware, disjoint; at most `review.max_shards`, default 8) and returns
+(deterministic, directory-aware, disjoint; at most `review.max_shards`, default 8; the operator-local env `MAP_REVIEW_MAX_SHARDS` (positive int, invalid values ignored) overrides the trusted config and the default, and the `too_many_shards` error hints the exact count needed) and returns
 `shard_ids`. A single file above the per-shard capacity or more than `max_shards` shards fails
 admission with `review_context_budget_exceeded` (`reason: file_too_large | too_many_shards`).
 Unsharded rounds never see any of this.