@julioborges/gantry 0.1.0 → 1.0.3

package/.agents/skills/gantry/scripts/frontier.py

@@ -185,7 +185,7 @@ def main() -> int:
             print(f"  ERROR: {error}")
     if errors:
         return 1
-    return 0 if selected or parked else 2
+    return 0 if selected or parked or all(i.done for i in issues.values()) else 2
 
 
 if __name__ == "__main__":

package/.agents/skills/gantry/scripts/guard.py

@@ -36,7 +36,7 @@ sys.path.insert(0, str(Path(__file__).parent))
 import runlog  # noqa: E402
 
 DECISION_EVENTS = {"PreToolUse", "tool.execute.before"}
-SUBAGENT_START_EVENTS = {"SubagentStart"}
+SUBAGENT_START_EVENTS = {"SubagentStart", "invoke_subagent"}
 SUBAGENT_STOP_EVENTS = {"SubagentStop"}
 COMPACTION_EVENTS = {"PreCompact", "session.compacted"}
 
@@ -67,15 +67,16 @@ EVENT_REQUIRED_CONCEPTS = {
 CONCEPT_FIELD_BY_HARNESS = {
     "claude-code": {"tool_name": "tool_name", "tool_input": "tool_input", "session_id": "session_id"},
     "opencode": {"tool_name": "tool", "tool_input": "args", "session_id": "sessionID"},
+    "antigravity": {"tool_name": "tool_name", "tool_input": "tool_input", "session_id": "session_id"},
 }
 CONCEPT_ALIASES = {
-    "tool_name": ("tool_name", "tool", "toolName"),
-    "tool_input": ("tool_input", "args", "toolInput", "input"),
+    "tool_name": ("tool_name", "tool", "toolName", "name"),
+    "tool_input": ("tool_input", "args", "toolInput", "input", "parameters", "arguments"),
     "session_id": ("session_id", "sessionID", "sessionId"),
 }
 
-MODIFYING_TOOLS = {"edit", "write", "multiedit", "notebookedit", "applypatch", "patch"}
-BASH_TOOLS = {"bash", "shell", "exec"}
+MODIFYING_TOOLS = {"edit", "write", "multiedit", "notebookedit", "applypatch", "patch", "writetofile", "replacefilecontent"}
+BASH_TOOLS = {"bash", "shell", "exec", "runcommand"}
 
 ISSUE_FILE_RE = re.compile(r"^\d{2,}-[a-z0-9-]+\.md$")
 STATUS_LINE_RE = re.compile(r"(?m)^Status:\s*(\S+)")
@@ -134,13 +135,21 @@ def tool_input(payload: dict) -> dict:
 
 
 def extract_path(payload: dict, arguments: dict) -> str | None:
-    value = _first(arguments, ("file_path", "filePath", "path", "filename")) or _first(payload, ("file_path", "path"))
+    value = (
+        _first(arguments, ("file_path", "filePath", "path", "filename", "TargetFile", "target_file", "targetFile"))
+        or _first(payload, ("file_path", "path", "TargetFile", "target_file", "targetFile"))
+    )
     return str(value) if value else None
 
 
 def extract_text(arguments: dict) -> str:
     parts: list[str] = []
-    for key in ("old_string", "oldString", "new_string", "newString", "content", "text"):
+    for key in (
+        "old_string", "oldString", "new_string", "newString", "content", "text",
+        "CodeContent", "code_content", "codeContent",
+        "TargetContent", "target_content", "targetContent",
+        "ReplacementContent", "replacement_content", "replacementContent",
+    ):
         value = arguments.get(key)
         if isinstance(value, str):
             parts.append(value)
@@ -158,7 +167,11 @@ def extract_text(arguments: dict) -> str:
 def extract_new_text(arguments: dict) -> str:
     """The resulting text a modifying tool would write -- never the text it replaces."""
     parts: list[str] = []
-    for key in ("new_string", "newString", "content", "text"):
+    for key in (
+        "new_string", "newString", "content", "text",
+        "CodeContent", "code_content", "codeContent",
+        "ReplacementContent", "replacement_content", "replacementContent",
+    ):
         value = arguments.get(key)
         if isinstance(value, str):
             parts.append(value)
@@ -182,18 +195,22 @@ def is_draft_safe(new_text: str) -> bool:
 
 
 def extract_command(arguments: dict) -> str | None:
-    value = _first(arguments, ("command", "cmd"))
+    value = _first(arguments, ("command", "cmd", "CommandLine", "command_line", "commandLine"))
     return str(value) if value else None
 
 
 def payload_cwd(payload: dict) -> str | None:
     """The harness-reported working directory for this call, if the payload carries one.
 
-    Claude Code spells it `cwd`, OpenCode spells it `directory`. Neither is a decision
-    concept the capability files gate on -- it is only ever used to pick *where* to look
-    (a git worktree, an Issue path), never to grant or withhold authority on its own.
+    Claude Code spells it `cwd`, OpenCode spells it `directory`, Antigravity spells it `Cwd`
+    in run_command tool_input. Neither is a decision concept the capability files gate on --
+    it is only ever used to pick *where* to look (a git worktree, an Issue path), never to grant
+    or withhold authority on its own.
     """
-    value = _first(payload, ("cwd", "directory"))
+    value = _first(payload, ("cwd", "directory", "Cwd"))
+    if not value and isinstance(payload, dict):
+        args = tool_input(payload)
+        value = _first(args, ("cwd", "directory", "Cwd"))
     return str(value) if value else None
 
 
@@ -218,23 +235,23 @@ def apply_edits(original: str, arguments: dict) -> str | None:
     """
     edits = arguments.get("edits")
     if not isinstance(edits, list):
-        old = arguments.get("old_string", arguments.get("oldString"))
-        new = arguments.get("new_string", arguments.get("newString"))
+        old = _first(arguments, ("old_string", "oldString", "TargetContent", "target_content", "targetContent"))
+        new = _first(arguments, ("new_string", "newString", "ReplacementContent", "replacement_content", "replacementContent"))
         if not isinstance(old, str) or not isinstance(new, str):
             return None
-        replace_all = arguments.get("replace_all", arguments.get("replaceAll"))
+        replace_all = arguments.get("replace_all", arguments.get("replaceAll", arguments.get("AllowMultiple", arguments.get("allow_multiple", arguments.get("allowMultiple")))))
         edits = [{"old_string": old, "new_string": new, "replace_all": replace_all}]
     text = original
     for edit in edits:
         if not isinstance(edit, dict):
             return None
-        old = edit.get("old_string", edit.get("oldString"))
-        new = edit.get("new_string", edit.get("newString"))
+        old = _first(edit, ("old_string", "oldString", "TargetContent", "target_content", "targetContent"))
+        new = _first(edit, ("new_string", "newString", "ReplacementContent", "replacement_content", "replacementContent"))
         if not isinstance(old, str) or not isinstance(new, str):
             return None
         if old not in text:
             return None
-        replace_all = bool(edit.get("replace_all", edit.get("replaceAll")))
+        replace_all = bool(edit.get("replace_all", edit.get("replaceAll", edit.get("AllowMultiple", edit.get("allow_multiple", edit.get("allowMultiple"))))))
         count = -1 if replace_all else 1
         text = text.replace(old, new, count)
     return text
@@ -258,7 +275,7 @@ def decide(payload: dict, cwd: Path) -> Decision:
         if ISSUE_FILE_RE.match(basename):
             target = Path(path)
             target = target if target.is_absolute() else cwd / target
-            if normalized_name in {"write", "multiedit"}:
+            if normalized_name in {"write", "multiedit", "writetofile"}:
                 # The draft exemption only ever applies to *creating* a new Issue file.
                 # Once the target exists, its Status/checkbox fields are already under
                 # protection, and the new content must fall through to the same
@@ -266,7 +283,7 @@ def decide(payload: dict, cwd: Path) -> Decision:
                 # never exempted just because the new content, read alone, looks draft-safe.
                 if not target.exists() and is_draft_safe(extract_new_text(arguments)):
                     return Decision(True)
-            if normalized_name in {"edit", "multiedit"} and target.exists():
+            if normalized_name in {"edit", "multiedit", "replacefilecontent"} and target.exists():
                 # Compare the whole file before/after applying the edit in memory, so a
                 # value-only edit (e.g. 'ready-for-agent' -> 'done', or '[ ]' -> '[x]'
                 # without the '- ' scaffolding) is caught even though neither its
@@ -449,7 +466,14 @@ def handle_subagent_event(payload: dict, args: argparse.Namespace, event: str) -
         return
     role = None
     if isinstance(payload, dict):
-        role = _first(payload, ("role", "subagent_type", "agent_type", "subagentType", "agentType", "description"))
+        role = _first(payload, ("role", "subagent_type", "agent_type", "subagentType", "agentType", "description", "Role", "TypeName"))
+        if not role:
+            args_input = tool_input(payload)
+            subagents = args_input.get("Subagents") or args_input.get("subagents")
+            if isinstance(subagents, list) and subagents:
+                role = _first(subagents[0], ("Role", "role", "TypeName", "typeName"))
+            if not role:
+                role = _first(args_input, ("Role", "role", "TypeName", "typeName", "description"))
     record(
         cwd,
         root,
@@ -463,6 +487,36 @@ def handle_subagent_event(payload: dict, args: argparse.Namespace, event: str) -
     )
 
 
+def record_invoke_subagent_event(payload: dict, args: argparse.Namespace, cwd: Path, event: str) -> None:
+    args_input = tool_input(payload)
+    subagents = args_input.get("Subagents") or args_input.get("subagents")
+    roles = []
+    if isinstance(subagents, list):
+        for sub in subagents:
+            if isinstance(sub, dict):
+                r = _first(sub, ("Role", "role", "TypeName", "typeName", "type_name", "description"))
+                if r:
+                    roles.append(str(r))
+    if not roles:
+        r = _first(args_input, ("Role", "role", "TypeName", "typeName", "description"))
+        if r:
+            roles.append(str(r))
+    run_id, root = resolve_run(payload, args.run_id, args.state_root, cwd)
+    if run_id:
+        for role_name in (roles or ["unknown"]):
+            record(
+                cwd,
+                root,
+                run_id,
+                {
+                    "ts": now_iso(),
+                    "run": run_id,
+                    "event": event,
+                    "data": {"role": role_name},
+                },
+            )
+
+
 def handle_compaction_event(payload: dict, args: argparse.Namespace) -> None:
     cwd = Path(args.cwd).resolve()
     run_id, root = resolve_run(payload if isinstance(payload, dict) else {}, args.run_id, args.state_root, cwd)
@@ -539,14 +593,26 @@ def main() -> int:
     if args.event in DECISION_EVENTS:
         decision = handle_decision_event(payload, args)
         if decision.allow:
+            name = tool_name(payload)
+            normalized_name = re.sub(r"[^a-z]", "", name)
+            if normalized_name == "invokesubagent":
+                record_invoke_subagent_event(payload, args, cwd, "subagent.started")
             return allow()
         message = f"deny: {decision.rule} {decision.path}"
         if args.json:
-            print(json.dumps({"decision": "deny", "rule": decision.rule, "path": decision.path}, separators=(",", ":")))
+            print(json.dumps({"decision": "deny", "rule": decision.rule, "path": decision.path, "reason": message}, separators=(",", ":")))
+            return 0
         else:
             print(message)
-        print(message, file=sys.stderr)
-        return 2
+            print(message, file=sys.stderr)
+            return 2
+
+    if args.event == "PostToolUse":
+        name = tool_name(payload)
+        normalized_name = re.sub(r"[^a-z]", "", name)
+        if normalized_name == "invokesubagent":
+            record_invoke_subagent_event(payload, args, cwd, "subagent.stopped")
+        return allow()
 
     if args.event in SUBAGENT_START_EVENTS:
         handle_subagent_event(payload, args, "subagent.started")

package/.agents/skills/gantry/scripts/runlog.py

@@ -29,14 +29,17 @@ EVENTS = {
     "policy.changed",
     "issue.done",
     "issue.blocked",
+    "issue.paused",
     "refutation",
     "review.finding",
+    "role.selected",
+    "role.changed",
 }
 RUN_EVENTS = {"run.started", "run.resumed", "run.cancelled", "run.finished"}
 ROUND_EVENTS = {"round.started", "round.finished"}
 PHASE_EVENTS = {"phase.started", "phase.finished"}
 SUBAGENT_EVENTS = {"subagent.started", "subagent.stopped"}
-ISSUE_EVENTS = {"issue.done", "issue.blocked", "refutation", "review.finding"}
+ISSUE_EVENTS = {"issue.done", "issue.blocked", "issue.paused", "refutation", "review.finding", "role.selected", "role.changed"}
 FINISHED_EVENTS = {"run.cancelled", "run.finished"}
 UNIT_ID_RE = re.compile(r"^[0-9a-f]{12}$")
 RUN_ID_RE = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._:-]*$")
@@ -277,6 +280,29 @@ def validate_event(payload: object) -> dict:
         if not isinstance(data, dict) or "policyHash" not in data:
             raise EventError("policy.changed requires data.policyHash")
         require_string(data["policyHash"], "data.policyHash")
+    elif event == "issue.paused":
+        if "issue" not in payload:
+            raise EventError("issue.paused requires issue")
+        if not isinstance(data, dict) or not {"role", "reason"} <= set(data):
+            raise EventError("issue.paused requires data.role and data.reason")
+        require_string(data["role"], "data.role")
+        require_string(data["reason"], "data.reason")
+    elif event == "role.selected":
+        if "issue" not in payload:
+            raise EventError("role.selected requires issue")
+        if not isinstance(data, dict) or not {"role", "requested", "effective"} <= set(data):
+            raise EventError("role.selected requires data.role, data.requested, and data.effective")
+        require_string(data["role"], "data.role")
+        if not isinstance(data["requested"], dict) or not isinstance(data["effective"], dict):
+            raise EventError("data.requested and data.effective must be objects")
+    elif event == "role.changed":
+        if "issue" not in payload:
+            raise EventError("role.changed requires issue")
+        if not isinstance(data, dict) or not {"role", "requested", "effective"} <= set(data):
+            raise EventError("role.changed requires data.role, data.requested, and data.effective")
+        require_string(data["role"], "data.role")
+        if not isinstance(data["requested"], dict) or not isinstance(data["effective"], dict):
+            raise EventError("data.requested and data.effective must be objects")
     elif event in ISSUE_EVENTS and "issue" not in payload:
         raise EventError(f"{event} requires issue")
     return payload
@@ -339,6 +365,17 @@ def inflight(root: Path, unit: str) -> list[dict]:
                     "phase": event["phase"],
                     "worktree": event.get("data", {}).get("worktree"),
                 }
+            elif event["event"] == "issue.paused":
+                if event["issue"] in active:
+                    if event.get("data", {}).get("worktree"):
+                        active[event["issue"]]["worktree"] = event["data"]["worktree"]
+                else:
+                    active[event["issue"]] = {
+                        "run": event["run"],
+                        "issue": event["issue"],
+                        "phase": event.get("phase") or "Critic",
+                        "worktree": event.get("data", {}).get("worktree"),
+                    }
             elif event["event"] == "phase.finished":
                 active.pop(event["issue"], None)
             elif event["event"] in {"issue.done", "issue.blocked"}:

package/.agents/skills/gantry/scripts/setup.py

@@ -2,6 +2,8 @@
 """Conversational setup wizard for Gantry policy and hooks."""
 import argparse
 import json
+import os
+import shutil
 import sys
 from pathlib import Path
 
@@ -111,6 +113,43 @@ def main() -> None:
                     indented_new_hooks = new_hooks_text.replace('\n', '\n' + ' ' * base_indent)
                     settings_path.write_text(content[:start_idx] + indented_new_hooks + content[end_idx:], encoding="utf-8")
 
+    # Antigravity hook wiring: when Antigravity is detected, generate or merge .agents/hooks.json
+    if (repo_root / ".agents").exists() or shutil.which("agy") or os.environ.get("ANTIGRAVITY_PROJECT_DIR") or os.environ.get("GEMINI_CLI"):
+        ag_hook_frag_path = Path(__file__).resolve().parents[1] / "hooks" / "antigravity.hooks.json"
+        if ag_hook_frag_path.exists():
+            ag_hook_frag = json.loads(ag_hook_frag_path.read_text(encoding="utf-8"))
+        else:
+            guard_cmd = 'python3 ".agents/skills/gantry/scripts/guard.py" PreToolUse --json'
+            ag_hook_frag = {
+                "hooks": {
+                    "PreToolUse": [
+                        {
+                            "matcher": "*",
+                            "hooks": [
+                                {
+                                    "type": "command",
+                                    "command": guard_cmd,
+                                }
+                            ]
+                        }
+                    ]
+                }
+            }
+        agents_dir = repo_root / ".agents"
+        agents_dir.mkdir(parents=True, exist_ok=True)
+        hooks_json_path = agents_dir / "hooks.json"
+        if hooks_json_path.exists():
+            try:
+                existing_hooks = json.loads(hooks_json_path.read_text(encoding="utf-8"))
+                if not isinstance(existing_hooks, dict):
+                    existing_hooks = {}
+            except Exception:
+                existing_hooks = {}
+            merged_hooks = merge_dicts(existing_hooks, ag_hook_frag)
+            hooks_json_path.write_text(json.dumps(merged_hooks, indent=2) + "\n", encoding="utf-8")
+        else:
+            hooks_json_path.write_text(json.dumps(ag_hook_frag, indent=2) + "\n", encoding="utf-8")
+
     agents_path = repo_root / "AGENTS.md"
     content = agents_path.read_text(encoding="utf-8") if agents_path.exists() else ""
     begin_marker = "<!-- gantry:begin -->"

package/.agents/skills/gantry-setup/SKILL.md

@@ -16,15 +16,28 @@ You are the sole conversational writer of repository policy.
    - Enables recording by default.
    - Asks before denial hooks.
 
-3. **Constraints**:
+3. **Caveman Lite Option**:
+   - Offer Caveman lite as a recommended, explicitly confirmed repository preference (`"caveman": true`).
+   - Explain conversational scope (messages and summaries only; specs, issues, code, contracts, and exact errors retain full detail), user-managed installation, fallback to normal behavior, and variable savings.
+   - If declined or skipped, resolve to disabled (`"caveman": false`).
+   - When confirmed and Caveman is not installed, guide user with host-harness installation command (`npx skills add caveman` for Claude Code; clone into `~/.gemini/config/skills/caveman` or `.agents/skills/caveman` for Antigravity; `.agents/skills/caveman` for OpenCode/Codex). Gantry runs no installer and changes no global agent configuration.
+   - After user reports installation, verify host-harness discovery and readability using `python3 .agents/skills/gantry/scripts/caveman.py check --harness <harness>`.
+
+4. **Role Execution Defaults & Antigravity**:
+   - Persist sparse repository role execution defaults under `execution.roles` in `.gantry/config.json`.
+   - Each role selection contains `harness`, `model` and optional `effort`.
+   - When Antigravity is detected (`.agents/` directory or `agy` CLI on PATH), `setup.py` generates or merges `.agents/hooks.json` to wire `PreToolUse` to `guard.py PreToolUse --json`.
+   - Unrelated repository policy, hook settings and Caveman opt-in are preserved during merges.
+
+5. **Constraints**:
    - Creates no engine, database, MCP service, or automatic cleanup.
    - All setup-generated policy, prompts, and marked content must be English.
 
-4. **Applying the Policy**:
+6. **Applying the Policy**:
    Once the operator confirms the settings, construct the JSON configuration and pipe it to `setup.py`:
    
    ```bash
    python3 .agents/skills/gantry/scripts/setup.py --config '{...}'
    ```
    
-   The `setup.py` script renders the full proposed `.gantry/config.json` before writing, supports merge, overwrite, and abort for an existing policy, handles idempotent merging of the Claude Code hook fragment into `.claude/settings.json`, and adds or replaces only the marked Gantry section in `AGENTS.md`. Do not modify these files directly.
+   The `setup.py` script renders the full proposed `.gantry/config.json` before writing, supports merge, overwrite, and abort for an existing policy, handles idempotent merging of the Claude Code hook fragment into `.claude/settings.json`, configures `.agents/hooks.json` when Antigravity is detected, and adds or replaces only the marked Gantry section in `AGENTS.md`. Do not modify these files directly.

package/README.md

@@ -3,6 +3,10 @@
 **Turn an approved Spec into verified software deliveries inside your coding
 harness.**
 
+[![CI](https://github.com/JulioBorges/gantry/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/JulioBorges/gantry/actions/workflows/ci.yml)
+[![Release](https://github.com/JulioBorges/gantry/actions/workflows/release.yml/badge.svg)](https://github.com/JulioBorges/gantry/actions/workflows/release.yml)
+[![npm version](https://img.shields.io/npm/v/%40julioborges%2Fgantry)](https://www.npmjs.com/package/@julioborges/gantry)
+[![GitHub release](https://img.shields.io/github/v/release/JulioBorges/gantry)](https://github.com/JulioBorges/gantry/releases)
 [![License: Apache 2.0](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](LICENSE)
 [![Python: 3.10+](https://img.shields.io/badge/python-3.10%2B-blue.svg)](#requirements)
 [![Agent Skills](https://img.shields.io/badge/Agent-Skills-orange.svg)](#installation)
@@ -46,9 +50,8 @@ claiming support for a particular integration. See [PRD §13](PRD.md#13-harness-
 for harness support and fixture requirements. A declared tier does not prove every harness version
 has been exercised.
 
-The npm installer is configured locally as `@julioborges/gantry` version `0.1.0`;
-publication is a separate release step. Use the GitHub installation below until
-an npm release is available.
+The npm installer is published as `@julioborges/gantry`. The npm badge above
+shows the published version; new releases require maintainer authorization.
 
 ## Requirements
 
@@ -83,7 +86,7 @@ Select all three skills and your harness in the installer:
 You can also copy or symlink the three directories into
 `<repo>/.agents/skills/` or `~/.agents/skills/`. The repository copy wins.
 
-Once the npm package is published, its bundled installer supports:
+The npm package includes a bundled installer:
 
 ```bash
 npx @julioborges/gantry add
@@ -385,6 +388,11 @@ Use [GitHub Issues](https://github.com/JulioBorges/gantry/issues) to describe a
 reproducible problem or propose a change. Delivery Issues used by Gantry itself
 remain local Markdown artifacts.
 
+All changes go through a PR; `main` requires passing CI and maintainer review.
+Only [JulioBorges](https://github.com/JulioBorges) reviews and merges contributions.
+See [CONTRIBUTING.md](CONTRIBUTING.md) for the fork workflow, required gates,
+and the documented self-review exception for maintainer PRs.
+
 Before changing the pack, read `PRD.md`, `CONTEXT.md`, `docs/adr/`, and `AGENTS.md`.
 Keep documentation and generated artifacts in English. Explain behavior changes
 and include validation evidence in your pull request.
@@ -392,6 +400,9 @@ and include validation evidence in your pull request.
 Run the Python suite from the repository root:
 
 ```bash
+python3 -m venv .venv
+source .venv/bin/activate
+python3 -m pip install -r requirements-dev.txt
 make test
 ```
 
@@ -409,28 +420,19 @@ verify with `roadmap.py check`.
 
 ### Publishing to npm
 
-The package is configured for public publication as `@julioborges/gantry`, initially version `0.1.0`.
-Only the installer, three skill directories, README and license are included; Python caches,
-project Issues, fixtures, local configuration and runtime state are excluded.
-
-```bash
-npm ci
-npm run test:package
-npm pack --dry-run
-# After approving the release and authenticating with an account allowed to publish the scope:
-make release
-```
-
-`make release` verifies the npm account before installing locked dependencies with `npm ci` and publishing the current version from
-`package.json` to npm. Update that version before publishing a subsequent release.
-`prepublishOnly` first checks `npm whoami` against npmjs.org and refuses publication unless the
-authenticated account is exactly `julioborges`. Authentication and network failures block publication.
-This applies to both `make release` and direct `npm publish`; npm's registry permissions remain the
-authority, and lifecycle hooks can be bypassed with npm options.
-After authorization, it runs the repository test suite and the tarball installation test once before publication.
-The tarball test executes `npx` and installs all three skills in a temporary project using the packed
-artifact. See [npm's package metadata documentation](https://docs.npmjs.com/cli/v11/configuring-npm/package-json/)
-for the `bin`, `files` and `publishConfig` settings. No automatic publication is configured.
+Releases use the manually authorized [Release workflow](.github/workflows/release.yml).
+A version bump goes through a PR, then JulioBorges pushes a tag such as `v0.1.1`
+for the merged commit and approves the `npm-release` environment. The workflow
+derives the version from the tag and requires matching package and lockfile versions.
+The workflow reruns gates, publishes the verified tarball using npm OIDC with
+provenance, verifies registry integrity, and creates the GitHub Release for the immutable tag. Merging a PR does not automatically publish.
+
+See the [maintainer release runbook](docs/maintainers/releases.md) for versioning,
+authorization, npm trusted publisher setup, and recovery after partial failures.
+The package includes only the installer, three skill directories, README and
+license; project Issues, fixtures, caches, local configuration and runtime state
+are excluded. Local `make release` retains its npm account check, but GitHub
+Actions is the normal publication path.
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@julioborges/gantry",
-  "version": "0.1.0",
+  "version": "1.0.3",
   "description": "Install the Gantry harness-neutral agentic SDLC skill pack.",
   "type": "commonjs",
   "license": "Apache-2.0",
@@ -10,9 +10,20 @@
   },
   "homepage": "https://github.com/JulioBorges/gantry#readme",
   "bugs": "https://github.com/JulioBorges/gantry/issues",
-  "keywords": ["agent-skills", "gantry", "sdlc", "claude-code", "codex", "opencode"],
-  "engines": {"node": ">=22.20.0"},
-  "bin": {"gantry": "bin/gantry.mjs"},
+  "keywords": [
+    "agent-skills",
+    "gantry",
+    "sdlc",
+    "claude-code",
+    "codex",
+    "opencode"
+  ],
+  "engines": {
+    "node": ">=22.20.0"
+  },
+  "bin": {
+    "gantry": "bin/gantry.mjs"
+  },
   "files": [
     "bin/gantry.mjs",
     "scripts/ensure-npm-author.mjs",
@@ -27,10 +38,15 @@
   ],
   "scripts": {
     "test": "make test",
-    "test:package": "node --test tests/npm-package.test.mjs tests/npm-author.test.mjs",
+    "test:package": "node --test tests/npm-package.test.mjs tests/npm-author.test.mjs tests/github-release.test.mjs",
     "pack:check": "npm run test:package",
     "prepublishOnly": "node scripts/ensure-npm-author.mjs && npm test && npm run test:package"
   },
-  "dependencies": {"skills": "1.5.26"},
-  "publishConfig": {"access": "public", "registry": "https://registry.npmjs.org/"}
+  "dependencies": {
+    "skills": "1.5.26"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  }
 }