ace-git 0.29.0 → 0.30.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ecb7e3224f26cacff289f62d5199d90740ee07a4fbaa378649fc948133e6d05c
-  data.tar.gz: 13ac60da2a81dda68242bc0c9f5f21f5e44f764562f24877426e873b59137bbf
+  metadata.gz: c03430c6a212d4bb6c51a3cb4bbf8f884051fe37b55581f9ea3d5d14048c83fa
+  data.tar.gz: e4da9c0fc2ae249ff7459973be3bfa42679395a68cb184e49446ea049aa5074f
 SHA512:
-  metadata.gz: 19e1dfe5f0315b38572c0c8464852bfb7f2c25477f92f646c73df44d4b0c0f06d72c32cd6e961ef8185ed1ced37c57cd111a4980dec8f698d1eba3ad7596e8c7
-  data.tar.gz: 16ff4c84f2f86b690116792e97cfcbe323c5dd2209d63e5148f6d4aa35fc3725a99dc84b87695cb4d00b9187816ab6652f1194ba7940caf11f6d96dd065b4fdf
+  metadata.gz: 60ade30b905d89e860b44636d5520f7b5365612cbf4182692c3c06ca73a157b0d5811b4a3a8710a6b382180276ec4c8d488c4a156833af455d4baebcfd8a7797
+  data.tar.gz: e3dbbf14e495ac5bc6389079dd62d4c04a19f59ef4bc7d8d4a04507a63af5e52bc4ed734cadea17d6824d1cde353002bd4717bc9b4270282a670d42b72340983

data/CHANGELOG.md

@@ -7,6 +7,41 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.30.1] - 2026-10-17
+
+### Changed
+
+- Document the ordinary local PR create/update/ready path; remove the protected worker boundary and `ace-lab service request/status` requirements from the git PR workflows and guide.
+- Document explicit remote read/compare reconciliation for an interrupted PR update instead of claiming the command compares and accepts the remote description; an interrupted create adopts one exact-head draft but does not compare or rewrite remote title/body.
+- Drop the `attempt-bound`/`execution-attempt` wording from the `as-git-pr-create` and `as-git-pr-update` skills; they wrap the same forge-neutral PR workflows.
+
+### Removed
+
+- Remove the protected merge boundary feature test and its fixture, which exercised the removed protected authority model.
+
+## [0.30.0] - 2026-10-08
+
+### Added
+
+- Execute protected draft create/update, ready and merge through named forge providers, binding exact repository provenance, candidate SHA, input and current campaign acceptance.
+
+### Fixed
+
+- Resolve receiver provider identity from the authenticated PR URL and preserve uncertain effects without replay.
+
+- Verify protected request, status and delivery refuse actual authority endpoint loss without replacing the original claim or dispatching another effect.
+
+- Restore process-wide provider registrations and loader state after registry test fixtures, preserving real adapter tests across randomized single-batch execution.
+
+- Resolve receiver-side merge provider identity from the authenticated PR URL when the prepared candidate has no remote, refusing mismatched or changed pinned servers.
+
+- Route protected delivery through original worker merge request, canonical status and exact result consumption while preserving ordinary delivery and unresolved protected PR policy.
+
+
+### Added
+
+- Fixed receiver-side `service merge` validates the claimed candidate/input, uses the selected neutral provider once, and publishes bounded evidence only for a verified exact-head merged outcome.
+
 ## [0.29.0] - 2026-10-05
 
 ### Removed

data/docs/handbook.md

@@ -9,6 +9,11 @@ ace-docs:
 
 # ace-git Handbook Catalog
 
+> **Planned (L5.5):** role rules, independent review rounds, and the
+> attempt-bound forge delivery workflow are not available yet. The PR
+> create/update skills below are projections of that planned workflow; the
+> ordinary `ace-git pr` CLI commands remain the supported local path.
+
 Reference for package-owned handbook resources in `ace-git/handbook/`.
 
 ## Skills

data/docs/usage.md

@@ -86,6 +86,7 @@ ace-git diff --raw
 ```
 
 **Options:**
+
 - `--format, -f` - Output format: `diff` (default), `summary`, `grouped-stats`
 - `--since, -s` - Changes since date/duration (e.g., "7d", "1 week ago")
 - `--paths, -p` - Include only these glob patterns
@@ -118,12 +119,14 @@ ace-git status --with-diff
 ```
 
 **Options:**
+
 - `--format, -f` - Output format: `markdown` (default), `json`
 - `--no-pr, -n` - Skip PR metadata and activity lookups (faster)
 - `--commits N` - Number of recent commits to show (default: 3 from config)
 - `--with-diff` - Include PR diff in output
 
 **Output includes:**
+
 - Current branch name with git status -sb output
 - Remote tracking status (ahead/behind)
 - Detected task pattern (from branch name)
@@ -153,6 +156,7 @@ ace-git branch --format json
 ```
 
 **Options:**
+
 - `--format, -f` - Output format: `text` (default), `json`
 
 ### `ace-git pr`
@@ -191,16 +195,24 @@ ace-git pr merge 25 --expected-head SHA --method squash
 ```
 
 **Behavior guarantees:**
+
 - Create is idempotent: one exact open base/head match returns the existing
+
   PR (`idempotency: existing`); multiple matches are a conflict.
+
 - `merge` requires the provider to enforce `--expected-head` atomically;
+
   providers without that capability return an unsupported-capability failure
   instead of racing.
+
 - A create request whose outcome is unknown (transport failure after send)
+
   reports an unknown outcome with the exact identity to reconcile; it never
   retries automatically.
+
 - With `--format json`, a failed operation prints the classified error as
-  JSON on stdout (`{"error": {"category": ..., "message": ...}}` — e.g.
+
+  JSON on stdout (`{"error": {"category": ..., "message": ...}}` -- e.g.
   `expected_head_conflict`, `unsupported_capability`, `unknown_outcome`)
   before the nonzero exit; text mode explains the same failure on stderr.
 
@@ -256,9 +268,10 @@ diff:
 | `grouped_stats.layers` | Array | `["lib","test","handbook"]` | Preferred layer grouping order |
 | `grouped_stats.collapse_above` | Integer | `5` | Collapse markdown groups above this file count |
 | `grouped_stats.show_full_tree` | String | `collapsible` | Tree rendering strategy hint |
-| `grouped_stats.dotfile_groups` | Array | `[".ace-task",".ace"]` | Dot-directories to prioritize in grouping |
+| `grouped_stats.dotfile_groups` | Array | `[".ace-tasks",".ace"]` | Dot-directories to prioritize in grouping |
 
 **Default exclude_patterns** (from `.ace-defaults/git/config.yml`):
+
 - Lock files: `**/*.lock`, `package-lock.json`, `yarn.lock`, `Gemfile.lock`
 - Vendored deps: `vendor/**/*`, `node_modules/**/*`
 - Build artifacts: `coverage/**/*`, `dist/**/*`, `build/**/*`, `.cache/**/*`
@@ -289,13 +302,24 @@ Note: `test/**/*` and `spec/**/*` are NOT excluded by default - test changes are
 
 ## Provider Packages
 
+> **Planned (L5.5):** the forge-neutral worker/integrator role rules and the
+> attempt-bound PR delivery workflow are not available yet. The old protected
+> `service create|update|ready|merge` receiver handlers are not part of the
+> file-based flow and are not a requirement for opening or reviewing a PR.
+>
+> Use the ordinary `ace-git pr` commands documented above for now; they create
+> or reconcile a PR for the pushed branch.
+
 `ace-git` is forge-neutral. It defines the server registry (`Ace::Git::ServerRegistry`),
 the provider contract (`Ace::Git::Providers::Base`), and normalized evidence types;
 provider packages own all forge CLI behavior:
 
 - **ace-git-github** - GitHub behavior via the `gh` CLI (PR lookups, diffs, issue
+
   tracking operations). Registers under the `github` provider type.
+
 - **ace-git-forgejo** - Forgejo behavior via the `fj` CLI. Registers under the
+
   `forgejo` provider type.
 
 Both providers implement the same issue-tracking contract (issue lookup, comment

data/handbook/guides/version-control-system-git.g.md

@@ -21,7 +21,7 @@ This project uses a **mono-repo architecture** with all packages at the reposito
 
 - **ace-*/**: Ruby gems for specific functionality (ace-git, ace-task, ace-docs, etc.)
 - **docs/**: Project documentation and architecture decisions
-- **.ace-task/**: Task management and release coordination
+- **.ace-tasks/**: Task management and release coordination
 - **_legacy/**: Archived content from previous multi-repo structure
 
 #### Common Git Commands
@@ -183,18 +183,19 @@ git remote prune origin
    git push -u origin feature/your-feature
    ```
 
-2. **Create an attempt-bound draft on the selected forge**:
+2. **Create a draft on the selected forge**:
 
    ```bash
    ace-bundle wfi://git/pr/create
    ```
 
-   Use the managed assignment and active delivery attempt with explicit
-   fork/canonical repository and ref provenance. The canonical operation is
-   `ace-assign delivery --assignment ID --attempt ATTEMPT --operation create --title TITLE --body-file DESCRIPTION`.
+   Use the actual assignment and active attempt when the work belongs to an
+   assignment, with explicit fork/canonical repository and ref provenance. The
+   forge command is
+   `ace-git pr create --server NAME --head HEAD-REF --base BASE-REF --expected-head CANDIDATE-SHA --title TITLE --body-file DESCRIPTION --format json`.
    Preserve the resolved forge and exact candidate SHA. Continue through
-   `wfi://git/pr/update` only with accepted current test and independent review
-   receipts; CI status remains advisory. Inside ACE use source `bin/ace-*`.
+   `wfi://git/pr/update` only with current exact-head test and independent review
+   evidence; CI status remains advisory. Inside ACE use source `bin/ace-*`.
 
 3. **Link to relevant issues/tasks**:
 
@@ -225,8 +226,8 @@ git push --force-with-lease origin feature/your-feature
 
 #### Fork-Based Workflow
 
-Provider-specific GitHub clone example for external contributors; canonical
-assignment delivery above uses the explicitly selected forge and provenance:
+Provider-specific GitHub clone example for external contributors; the neutral
+draft/update flow above uses the explicitly selected forge and provenance:
 
 ```bash
 # Fork repository on GitHub, then:

data/handbook/skills/as-git-pr-create/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: as-git-pr-create
-description: Create an attempt-bound forge-neutral pull request
+description: Create a forge-neutral pull request
 user-invocable: true
 source: ace-git
 allowed-tools:
@@ -13,7 +13,7 @@ assign:
     - name: create-pr
       description: Create the exact assignment pull request
       produces: [pull-request]
-      consumes: [code-changes, execution-attempt]
+      consumes: [code-changes]
 skill:
   kind: workflow
   execution:

data/handbook/skills/as-git-pr-update/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: as-git-pr-update
-description: Update an attempt-bound forge-neutral pull request
+description: Update a forge-neutral pull request
 user-invocable: true
 source: ace-git
 allowed-tools:
@@ -13,7 +13,7 @@ assign:
     - name: update-pr-desc
       description: Update the exact assignment pull request
       produces: [pull-request]
-      consumes: [code-changes, execution-attempt]
+      consumes: [code-changes]
 skill:
   kind: workflow
   execution:

data/handbook/workflow-instructions/git/pr/create.wf.md

@@ -1,18 +1,18 @@
 ---
 doc-type: workflow
-title: Create an attempt-bound draft pull request
+title: Create a draft pull request
 purpose: Create or reconcile a forge-neutral draft for the exact candidate
 ---
 
-# Create an attempt-bound draft pull request
+# Create a draft pull request
 
 ## Goal
 
-Create one draft PR on the selected forge and retain its exact source/base identity in the assignment attempt journal.
+Create one draft PR on the selected forge and record its exact source/base identity in the assignment report.
 
 ## Prerequisites
 
-A reviewed task, managed assignment, active delivery attempt, committed candidate, and pushed source ref. Credentials permit transport only; they grant no integration authority.
+A reviewed task or explicit implementation scope, a committed candidate, and a pushed source ref. Credentials permit transport only; they grant no integration permission.
 
 ## Inputs
 
@@ -25,12 +25,18 @@ Use `forge_server` or `forge_default: true`, mutually exclusive. Neither means r
 ## Steps
 
 1. Read the task and actual committed diff; prepare a concrete title and description explaining behavior and executed validation. Save the description as a local file.
-2. Use the existing managed assignment and active delivery attempt IDs. If needed, start the delivery step with `ace-assign attempt start --assignment ID --step STEP --project PROJECT` (numeric step scope). The execution boundary supplies actor identity; do not impersonate a reviewer or integrator.
-3. Supply the assignment source's `delivery` mapping, or save the explicit input JSON and pass `--parameters FILE`. For task-mode creation, `ace-assign create --task TASK --delivery-parameters FILE` retains these inputs in the generated job.
-4. Execute `ace-assign delivery --assignment ID --attempt ATTEMPT --operation create --title TITLE --body-file DESCRIPTION`. Add `--parameters FILE` only when supplying an explicit file. In this repository invoke the source `bin/ace-assign` entrypoint.
-5. Read the structured result. Verify the retained server/provider/base and head repository/ref, draft PR number/URL, candidate SHA, base_head, evidence_git_ref, and separate journal_commit. The pushed ref must equal the candidate; journal commits never advance it.
-6. On interruption or unknown create outcome, repeat the delivery command to perform exact-selector reconciliation reads. One matching draft at the exact head is adopted without a second create. Zero remains unresolved; multiple matches conflict. Never bypass uncertainty with a direct provider command.
+2. When this work belongs to an assignment, use its actual ID and record the PR identity in the assignment report. The execution boundary supplies actor identity; do not impersonate a reviewer or integrator.
+3. Verify the pushed source ref resolves to the candidate SHA. The pushed ref must equal the candidate.
+4. Create the draft with the configured forge command; drafts are the default:
+
+   ```sh
+   ace-git pr create --server NAME --head HEAD-REF --head-repo HEAD-REPOSITORY-URL --base BASE-REF --expected-head CANDIDATE-SHA --title TITLE --body-file DESCRIPTION --format json
+   ```
+
+   Use the retained default/remote selection instead of `--server NAME` when applicable. In this repository invoke the source `bin/ace-git` entrypoint.
+5. Read the structured result. Verify the retained server/provider/base and head repository/ref, draft PR number/URL, candidate SHA and base head. Record the PR identity and observed candidate head in the assignment report.
+6. On interruption or an unknown create outcome, repeat the same command with the same selectors: the implementation re-reads open PRs and adopts one matching draft at the exact head without a second create. Adoption does not compare or rewrite the remote title/body, so verify the remote content explicitly before relying on it, and use `wfi://git/pr/update` if the description differs. Zero matches remain unresolved; multiple matches conflict. Never bypass an uncertain read with a different provider command.
 
 ## Success criteria
 
-The journal records exact identity, intent before the write, and proven draft outcome afterward. A report or shell exit alone proves nothing. Continue with actual tests and independent current-head review; keep the PR draft until those receipts are accepted. CI is visible and advisory. Publication is a separate authorized operation and is not required for delivery.
+The assignment report records exact identity and the proven draft outcome. A report or shell exit alone proves nothing. Continue with actual tests and independent current-head review; keep the PR draft until those results are accepted. CI is visible and advisory. Publication is a separate authorized operation and is not required for delivery.

data/handbook/workflow-instructions/git/pr/update.wf.md

@@ -1,10 +1,10 @@
 ---
 doc-type: workflow
-title: Update an attempt-bound pull request
-purpose: Update the exact forge-neutral PR and consume current delivery evidence
+title: Update a pull request
+purpose: Update the exact forge-neutral PR and record current delivery evidence
 ---
 
-# Update an attempt-bound pull request
+# Update a pull request
 
 ## Goal
 
@@ -12,17 +12,35 @@ Update the recorded PR description for the current candidate and preserve provid
 
 ## Prerequisites
 
-A managed assignment with a recorded PR and active delivery attempt. Reuse the original forge selection and complete fork/canonical provenance; changed configuration or identity is a conflict. A new committed candidate, including task-only changes, requires renewed tests and independent review.
+An assignment with a recorded PR, or an explicit local PR scope. Reuse the original forge selection and complete fork/canonical provenance; changed configuration or identity is a conflict. A new committed candidate, including task-only changes, requires renewed tests and independent review.
 
 ## Steps
 
-1. Inspect the committed changes and accepted test/review evidence. Prepare the final description with the concrete behavior, executed test results, independent verdict, and actual limitations. Save it as a local file; do not put credentials or terminal dumps in the attempt journal.
-2. Execute `ace-assign delivery --assignment ID --attempt ATTEMPT --operation update --body-file DESCRIPTION`. Supply `--parameters FILE` only if the assignment source lacks the original `delivery` mapping. In this repository use `bin/ace-assign`.
-3. On interrupted update, repeat the delivery command. It reads the exact remote title/body and compares the requested field digest before accepting; an unmatched or unreadable outcome remains unresolved. Never blindly resend a mutation.
-4. To mark ready, supply two JSON reference files, each containing only `attempt_id` and `receipt_digest`, from coordinator-accepted current-head test and independent review attempts in this assignment/project. Execute `ace-assign delivery --assignment ID --attempt ATTEMPT --operation ready --tests TEST-REF --review REVIEW-REF`. Missing, fabricated, stale, or self-approved evidence cannot authorize readiness. Red CI alone does not veto valid executed tests and review.
-5. Merge is an integrator/service operation under the existing exact qjx authorization policy. The authorized executor calls `ace-git pr merge IDENTIFIER --server NAME --expected-head CANDIDATE-SHA --method METHOD --format json` with the retained selection (or `--default-server`, otherwise remote resolution). Both expected SHA and the authorized squash/merge/rebase method are required; there is no default method. It does not recursively request its own future receipt. The worker consumes the completed, verified service receipt using `ace-assign delivery --assignment ID --attempt ATTEMPT --operation merge --tests TEST-REF --review REVIEW-REF --service-request REQUEST`. The request must bind this assignment, attempt, project, candidate and PR URL. No completed receipt means a routed blocker; credentials or caller assertions grant no authority.
-6. Unknown merge remains pending service reconciliation and is never automatically retried. Inspect the authoritative selected remote and verified executor evidence. Changed head or scope blocks acceptance. Merge does not authorize publication, deployment or synchronization.
+1. Inspect the committed changes and accepted test/review evidence. Prepare the final description with the concrete behavior, executed test results, independent verdict, and actual limitations. Save it as a local file; do not put credentials or terminal dumps in the assignment report.
+2. Update the PR with the configured forge command:
+
+   ```sh
+   ace-git pr update IDENTIFIER --server NAME --expected-head CANDIDATE-SHA --body-file DESCRIPTION --format json
+   ```
+
+   Use the retained default/remote selection instead of `--server NAME` when applicable. In this repository invoke the source `bin/ace-git` entrypoint.
+3. On an interrupted update, do not assume the command reconciles for you: `ace-git pr update` verifies the head and rewrites the title/body, so a retry is a new write. Explicitly read the exact remote title/body (for example `ace-git pr show IDENTIFIER --format json`), compare it with the prepared description; if identical, treat the update as done, otherwise re-run the command. An unreadable or uncertain read stays unresolved. Never blindly resend a mutation.
+4. Mark ready only after tests and independent review pass on the exact head. Record the executed tests and independent review evidence for that head, then run:
+
+   ```sh
+   ace-git pr ready IDENTIFIER --server NAME --expected-head CANDIDATE-SHA --format json
+   ```
+
+   Missing, stale, or self-approved evidence cannot authorize readiness. Red CI alone does not veto valid executed tests and review.
+5. Merge is a separate authorized operation for the exact candidate. The authorized executor runs:
+
+   ```sh
+   ace-git pr merge IDENTIFIER --server NAME --expected-head CANDIDATE-SHA --method METHOD --format json
+   ```
+
+   with the retained selection (or `--default-server`, otherwise remote resolution). Both the expected SHA and the authorized squash/merge/rebase method are required; there is no default method. Credentials or caller assertions grant no permission.
+6. An unknown merge remains an unresolved effect. Inspect the authoritative selected remote and the actual executor evidence; never retry blindly. Changed head or scope blocks acceptance. Merge does not authorize publication, deployment or synchronization.
 
 ## Success criteria
 
-The exact remote outcome and existing qjl evidence agree. Real artifacts, current executed tests, independent verdict and required authorization gate completion. Preserve unresolved history and distinct candidate_head/journal_commit. qkb.1 supplies installed charter/proposal/service adoption; this workflow does not fabricate that acceptance.
+The exact remote outcome and the locally recorded evidence agree. Real artifacts, current executed tests and an independent verdict gate completion. Preserve unresolved history and distinguish the candidate head from evidence commits.

data/lib/ace/git/atoms/delivery_parameters.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+require_relative "server_url"
+
+module Ace
+  module Git
+    module Atoms
+      # Explicit non-secret remote delivery inputs; local recipes need not call this validator.
+      module DeliveryParameters
+        PROVENANCE_FIELDS = %w[mode head_repository_url head_ref base_repository_url base_ref].freeze
+        def self.validate(input)
+          raise ArgumentError, "Delivery parameters must be a mapping" unless input.is_a?(Hash)
+          unless (input.keys - %w[forge_server forge_default pr_provenance]).empty?
+            raise ArgumentError, "Unexpected delivery parameter fields"
+          end
+          default = input.fetch("forge_default", false)
+          raise ArgumentError, "forge_default must be boolean" unless [true, false].include?(default)
+          server = input["forge_server"]
+          if server && (!server.is_a?(String) || !server.match?(/\A[a-zA-Z0-9][a-zA-Z0-9_.-]{0,127}\z/))
+            raise ArgumentError, "Invalid forge_server"
+          end
+          raise ArgumentError, "forge_server and forge_default are mutually exclusive" if server && default
+          provenance = input["pr_provenance"]
+          unless provenance.is_a?(Hash) && provenance.keys.sort == PROVENANCE_FIELDS.sort &&
+              %w[fork canonical].include?(provenance["mode"])
+            raise ArgumentError, "Explicit complete fork or canonical PR provenance is required"
+          end
+          %w[head_repository_url base_repository_url].each { |key| validate_url!(provenance[key]) }
+          %w[head_ref base_ref].each do |key|
+            ref = provenance[key]
+            unless ref.is_a?(String) && ref.match?(/\A[a-zA-Z0-9][a-zA-Z0-9_\/.\-]{0,255}\z/) &&
+                !ref.include?("..") && !ref.include?("//") && !ref.end_with?("/", ".", ".lock")
+              raise ArgumentError, "Invalid PR ref"
+            end
+          end
+          if provenance["mode"] == "canonical" && !Ace::Git::Atoms::ServerUrl.match?(
+              provenance["head_repository_url"], provenance["base_repository_url"])
+            raise ArgumentError, "Canonical provenance requires matching head and base repositories"
+          end
+          {"forge_server" => server, "forge_default" => default,
+           "pr_provenance" => provenance.transform_values(&:dup)}
+        end
+
+        def self.validate_url!(url)
+          unless url.is_a?(String) && url.length <= 512 &&
+              (url.match?(%r{\Ahttps?://[a-zA-Z0-9.:-]+/[a-zA-Z0-9_./-]+\z}) ||
+               url.match?(%r{\Agit@[a-zA-Z0-9.-]+:[a-zA-Z0-9_./-]+\z}) ||
+               url.match?(%r{\Assh://git@[a-zA-Z0-9.:-]+/[a-zA-Z0-9_./-]+\z}))
+            raise ArgumentError, "PR repository URL must contain a repository and no credentials or query"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/git/atoms/service_merge_evidence.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+require "json"
+require_relative "delivery_parameters"
+require_relative "pr_reference"
+require_relative "../providers/evidence"
+
+module Ace
+  module Git
+    module Atoms
+      # Parse executor-owned evidence; authority supplies the original binding
+      # and separately checks the reconstructed input's canonical digest.
+      module ServiceMergeEvidence
+        MAX_BYTES = 64 * 1024
+        def self.validate(bytes, request_id:, input_digest:, target:, head:)
+          unless bytes.is_a?(String) && bytes.bytesize.between?(1, MAX_BYTES) &&
+              bytes.dup.force_encoding(Encoding::UTF_8).valid_encoding? && !bytes.include?("\0")
+            raise ArgumentError, "merge evidence is invalid or oversized"
+          end
+          marker, payload = bytes.split("\n", 2)
+          unless marker == "ace-service-attestation request:#{request_id} input:#{input_digest} outcome:succeeded"
+            raise ArgumentError, "merge evidence original marker differs"
+          end
+          value = JSON.parse(payload.to_s, max_nesting: 16, create_additions: false,
+            allow_duplicate_key: false, allow_comments: false, allow_nan: false)
+          closed!(value, %w[server delivery method candidate_head receipt])
+          delivery = DeliveryParameters.validate(value.fetch("delivery"))
+          unless value["delivery"] == delivery && value["delivery"].keys.sort == %w[forge_default forge_server pr_provenance] &&
+              %w[squash merge rebase].include?(value["method"]) && value["candidate_head"] == head
+            raise ArgumentError, "merge evidence selection/method/head differs"
+          end
+          server, receipt = value.values_at("server", "receipt")
+          closed!(server, %w[name provider url])
+          closed!(receipt, %w[server_name operation pull_request idempotency])
+          unless server["name"].is_a?(String) && server["name"].match?(/\A[a-zA-Z0-9][a-zA-Z0-9_.-]{0,127}\z/) &&
+              server["provider"].is_a?(String) && server["provider"].match?(/\A[a-zA-Z0-9_-]{1,128}\z/) &&
+              receipt["server_name"] == server["name"] && receipt["operation"] == "merge"
+            raise ArgumentError, "merge evidence provider receipt differs"
+          end
+          DeliveryParameters.validate_url!(server["url"])
+          pr = receipt.fetch("pull_request")
+          closed!(pr, ProviderPullRequest.members.map(&:to_s))
+          provenance = delivery.fetch("pr_provenance")
+          reference = target.is_a?(Hash) && PrReference.parse(target["resource"])
+          unless reference && reference.repository_url && pr["number"].is_a?(Integer) && pr["number"].positive? &&
+              pr["number"] == reference.number && pr["url"] == target["resource"] && pr["server_name"] == server["name"] &&
+              pr["head_sha"] == head && head.is_a?(String) && head.match?(/\A[0-9a-f]{40}\z/) &&
+              pr["state"] == "merged" && [true, false].include?(pr["draft"]) &&
+              pr.except("number", "draft").values.all? { |value| value.nil? || value.is_a?(String) } &&
+              pr["merge_commit_sha"].is_a?(String) && pr["merge_commit_sha"].match?(/\A[0-9a-f]{40}\z/) &&
+              pr["head_ref"] == provenance["head_ref"] && pr["base_ref"] == provenance["base_ref"] &&
+              ServerUrl.match?(reference.repository_url, provenance["base_repository_url"]) &&
+              ServerUrl.match?(server["url"], provenance["base_repository_url"]) &&
+              ServerUrl.match?(pr["head_repository_url"], provenance["head_repository_url"]) &&
+              ServerUrl.match?(pr["base_repository_url"], provenance["base_repository_url"]) &&
+              (!delivery["forge_server"] || delivery["forge_server"] == server["name"])
+            raise ArgumentError, "merge evidence PR identity or outcome differs"
+          end
+          {input: {"target" => target, "delivery" => delivery, "method" => value.fetch("method")},
+            pr: pr, server: server}
+        rescue JSON::ParserError, KeyError, TypeError
+          raise ArgumentError, "merge evidence is malformed"
+        end
+
+        def self.closed!(value, fields)
+          raise ArgumentError, "merge evidence fields differ" unless value.is_a?(Hash) && value.keys.sort == fields.sort
+        end
+        private_class_method :closed!
+      end
+    end
+  end
+end

data/lib/ace/git/atoms/service_pr_evidence.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+require "json"
+require_relative "service_pr_input"
+require_relative "../providers"
+require_relative "../server_registry"
+
+module Ace
+  module Git
+    module Atoms
+      module ServicePrEvidence
+        def self.validate(bytes, operation:, request_id:, input_digest:, target:, head:)
+          unless ServicePrInput::DRAFT_OPERATIONS.include?(operation) || operation == "ready"
+            raise ArgumentError, "unsupported PR evidence operation"
+          end
+          unless bytes.is_a?(String) && bytes.bytesize.between?(1, 64 * 1024) &&
+              bytes.dup.force_encoding(Encoding::UTF_8).valid_encoding? && !bytes.include?("\0")
+            raise ArgumentError, "PR evidence is invalid or oversized"
+          end
+          marker, payload = bytes.split("\n", 2)
+          unless marker == "ace-service-attestation request:#{request_id} input:#{input_digest} outcome:succeeded"
+            raise ArgumentError, "PR evidence original marker differs"
+          end
+          value = JSON.parse(payload.to_s, max_nesting: 16, create_additions: false,
+            allow_duplicate_key: false, allow_comments: false, allow_nan: false)
+          closed!(value, %w[server operation input candidate_head receipt])
+          input = ServicePrInput.validate(value.fetch("input"), operation: operation)
+          unless value["operation"] == operation && value["candidate_head"] == head && input["target"] == target
+            raise ArgumentError, "PR evidence operation/input/head differs"
+          end
+          server, receipt = value.values_at("server", "receipt")
+          closed!(server, %w[name provider url])
+          closed!(receipt, %w[server_name operation pull_request idempotency])
+          pr = receipt.fetch("pull_request")
+          closed!(pr, ProviderPullRequest.members.map(&:to_s))
+          delivery = input.fetch("delivery")
+          provenance = delivery.fetch("pr_provenance")
+          reference = PrReference.parse(pr["url"])
+          unless server["name"].is_a?(String) && server["provider"].is_a?(String) && server["url"].is_a?(String)
+            raise ArgumentError, "PR evidence provider identity is malformed"
+          end
+          selected = ResolvedServer.new(name: server["name"], provider: server["provider"], url: server["url"])
+          expected_title = Providers.for(selected).class.pull_request_title(title: input["title"], draft: true) if ServicePrInput::DRAFT_OPERATIONS.include?(operation)
+          unless reference && reference.repository_url && pr["number"] == reference.number &&
+              pr["number"].is_a?(Integer) && pr["number"].positive? &&
+              server["name"].is_a?(String) && server["name"].match?(/\A[a-zA-Z0-9][a-zA-Z0-9_.-]{0,127}\z/) &&
+              server["provider"].is_a?(String) && server["provider"].match?(/\A[a-zA-Z0-9_-]{1,128}\z/) &&
+              receipt["server_name"] == server["name"] && receipt["operation"] == operation &&
+              pr["server_name"] == server["name"] && pr["head_sha"] == head &&
+              head.is_a?(String) && head.match?(/\A[0-9a-f]{40}\z/) && pr["state"] == "open" &&
+              pr["draft"] == ServicePrInput::DRAFT_OPERATIONS.include?(operation) &&
+              pr.except("number", "draft").values.all? { |item| item.nil? || item.is_a?(String) } &&
+              (operation == "create" ? %w[created existing].include?(receipt["idempotency"]) : receipt["idempotency"].nil?) &&
+              pr["head_ref"] == provenance["head_ref"] && pr["base_ref"] == provenance["base_ref"] &&
+              ServerUrl.match?(reference.repository_url, provenance["base_repository_url"]) &&
+              ServerUrl.match?(server["url"], provenance["base_repository_url"]) &&
+              ServerUrl.match?(pr["head_repository_url"], provenance["head_repository_url"]) &&
+              ServerUrl.match?(pr["base_repository_url"], provenance["base_repository_url"]) &&
+              (!delivery["forge_server"] || delivery["forge_server"] == server["name"]) &&
+              (operation == "create" || pr["url"] == target["resource"]) &&
+              (operation == "ready" || pr["title"] == expected_title && pr["body"] == input["body"])
+            raise ArgumentError, "PR evidence selected identity or outcome differs"
+          end
+          DeliveryParameters.validate_url!(server["url"])
+          {input: input, pr: pr, server: server}
+        rescue JSON::ParserError, KeyError, TypeError, Ace::Git::Error
+          raise ArgumentError, "PR evidence is malformed"
+        end
+
+        def self.closed!(value, fields)
+          raise ArgumentError, "PR evidence fields differ" unless value.is_a?(Hash) && value.keys.sort == fields.sort
+        end
+        private_class_method :closed!
+      end
+    end
+  end
+end

data/lib/ace/git/atoms/service_pr_input.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+require_relative "delivery_parameters"
+require_relative "pr_reference"
+
+module Ace
+  module Git
+    module Atoms
+      # Fixed receiver input vocabulary; draft is source policy, not a flag.
+      module ServicePrInput
+        OPERATIONS = %w[create update ready merge].freeze
+        DRAFT_OPERATIONS = %w[create update].freeze
+
+        def self.validate(input, operation:)
+          fields = case operation
+          when "create", "update" then %w[target delivery title body]
+          when "ready" then %w[target delivery]
+          when "merge" then %w[target delivery method]
+          else raise ArgumentError, "unsupported protected PR operation"
+          end
+          unless input.is_a?(Hash) && input.keys.sort == fields.sort &&
+              input["target"].is_a?(Hash) && input["target"].keys.sort == %w[artifact_digest resource]
+            raise ArgumentError, "protected PR input fields differ"
+          end
+          parameters = DeliveryParameters.validate(input.fetch("delivery"))
+          unless input["delivery"].keys.sort == %w[forge_default forge_server pr_provenance] && input["delivery"] == parameters
+            raise ArgumentError, "protected PR selection must be normalized"
+          end
+          resource = input.fetch("target").fetch("resource")
+          if operation == "create"
+            DeliveryParameters.validate_url!(resource)
+            unless ServerUrl.match?(resource, parameters.fetch("pr_provenance").fetch("base_repository_url"))
+              raise ArgumentError, "draft create target differs from base repository"
+            end
+          else
+            reference = resource.is_a?(String) && PrReference.parse(resource)
+            raise ArgumentError, "protected PR target requires an exact URL" unless reference && reference.repository_url
+          end
+          digest = input.fetch("target").fetch("artifact_digest")
+          unless digest.nil? || digest.is_a?(String) && /\A[0-9a-f]{64}\z/.match?(digest)
+            raise ArgumentError, "protected PR target artifact digest differs"
+          end
+          if DRAFT_OPERATIONS.include?(operation)
+            unless input["title"].is_a?(String) && input["title"].bytesize.between?(1, 1024) &&
+                input["body"].is_a?(String) && input["body"].bytesize <= 32 * 1024 &&
+                [input["title"], input["body"]].all? { |text| text.dup.force_encoding(Encoding::UTF_8).valid_encoding? && !text.include?("\0") }
+              raise ArgumentError, "draft PR requires bounded UTF-8 title/body"
+            end
+          elsif operation == "merge" && !%w[squash merge rebase].include?(input["method"])
+            raise ArgumentError, "protected merge requires an exact method"
+          end
+          input
+        end
+      end
+    end
+  end
+end

data/lib/ace/git/cli/commands/service_merge.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+require_relative "../../organisms/service_merge"
+
+module Ace
+  module Git
+    module CLI
+      module Commands
+        class ServiceMerge < Ace::Support::Cli::Command
+          desc "Execute a fixed receiver-owned exact-head PR envelope"
+
+          def initialize(input: nil, producer: nil, root: nil, operation: "merge")
+            @input, @producer, @root, @operation = input, producer, root, operation
+          end
+
+          def call(**options)
+            raise ArgumentError, "fixed PR entry accepts no options" unless options.empty?
+            bytes = (@input || $stdin).read(Organisms::ServiceMerge::MAX_INPUT + 1)
+            result = (@producer || Organisms::ServiceMerge.new(operation: @operation)).call(bytes: bytes, root: @root || Dir.pwd)
+            puts JSON.generate(result)
+          rescue Ace::Git::Error, ArgumentError, SystemCallError, IOError => error
+            # No stdout receipt on an unverified/uncertain effect. The existing
+            # receiver retains its original dispatch instead of retrying it.
+            raise Ace::Support::Cli::Error, error.message
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/git/cli.rb

@@ -7,6 +7,7 @@ require_relative "cli/commands/diff"
 require_relative "cli/commands/status"
 require_relative "cli/commands/branch"
 require_relative "cli/commands/pr"
+require_relative "cli/commands/service_merge"
 
 module Ace
   module Git
@@ -52,7 +53,11 @@ module Ace
         ["diff", "Show filtered git diff output"],
         ["status", "Show repository status and PR context"],
         ["branch", "Show current branch information"],
-        ["pr", "Forge-neutral pull request lifecycle: show, create, update, ready, merge"]
+        ["pr", "Forge-neutral pull request lifecycle: show, create, update, ready, merge"],
+        ["service merge", "Fixed receiver-owned exact-head merge envelope"],
+        ["service create", "Fixed receiver-owned draft PR creation"],
+        ["service update", "Fixed receiver-owned draft PR update"],
+        ["service ready", "Fixed receiver-owned reviewed PR readiness"]
       ].freeze
 
       HELP_EXAMPLES = [
@@ -70,6 +75,10 @@ module Ace
       register "pr update", Commands::Pr::Update.new
       register "pr ready", Commands::Pr::Ready.new
       register "pr merge", Commands::Pr::Merge.new
+      register "service merge", Commands::ServiceMerge.new
+      %w[create update ready].each do |operation|
+        register "service #{operation}", Commands::ServiceMerge.new(operation: operation)
+      end
 
       version_cmd = Ace::Support::Cli::VersionCommand.build(
         gem_name: "ace-git",

data/lib/ace/git/organisms/pull_request_lifecycle.rb

@@ -196,6 +196,11 @@ module Ace
           )
         end
 
+        # Pure provider-owned encoding; selection is pinned by the caller.
+        def draft_title(title)
+          provider_for(resolve_selected_server).class.pull_request_title(title: title, draft: true)
+        end
+
         # Update title/body after exact-head verification.
         #
         # @return [ProviderMutationReceipt]
@@ -237,8 +242,23 @@ module Ace
         end
 
         # Freeze the selected provider identity for an assignment attempt.
-        def resolved_identity
-          resolve_selected_server.to_h.transform_keys(&:to_s).transform_values(&:to_s)
+        def resolved_identity(identifier = nil)
+          selected = identifier.nil? ? resolve_selected_server : resolve_server_for(parse_identifier(identifier))
+          if @pinned_server && selected != @pinned_server
+            raise ProviderIdentityMismatchError, "Configured server identity changed from the pinned delivery identity"
+          end
+          selected.to_h.transform_keys(&:to_s).transform_values(&:to_s)
+        end
+
+        # Protected create has no PR identifier or materialized origin remote.
+        # Resolve the retained base repository through the same exact registry.
+        def resolved_repository_identity(repository_url)
+          Atoms::DeliveryParameters.validate_url!(repository_url)
+          selected = resolve_matching_server(ServerRegistry.matching_servers(repository_url), repository_url)
+          if @pinned_server && selected != @pinned_server
+            raise ProviderIdentityMismatchError, "Configured server identity changed from the pinned delivery identity"
+          end
+          selected.to_h.transform_keys(&:to_s).transform_values(&:to_s)
         end
 
         # Read-only reconciliation of a possibly completed create. Absence
@@ -291,10 +311,13 @@ module Ace
             ServerRegistry.servers_for_owner_repo(reference.owner_repo)
           end
 
+          resolve_matching_server(candidates, reference.repository_url || reference.owner_repo)
+        end
+
+        def resolve_matching_server(candidates, identity)
           if @selection[:server_name] || @selection[:use_default]
             selected = resolve_selected_server
             unless candidates.any? { |candidate| candidate.name == selected.name }
-              identity = reference.repository_url || reference.owner_repo
               raise ProviderIdentityMismatchError,
                 "PR identifier (#{identity}) does not match the selected server '#{selected.name}'"
             end
@@ -303,12 +326,10 @@ module Ace
           elsif candidates.size == 1
             candidates.first
           elsif candidates.empty?
-            identity = reference.repository_url || reference.owner_repo
             raise AmbiguousRemoteError,
               "PR repository '#{identity}' matches no configured server (configured: " \
               "#{ServerRegistry.servers.map(&:name).join(", ")})"
           else
-            identity = reference.repository_url || reference.owner_repo
             raise AmbiguousRemoteError,
               "PR repository '#{identity}' matches multiple configured servers " \
               "(#{candidates.map(&:name).join(", ")}); select one explicitly"

data/lib/ace/git/organisms/service_merge.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+require "json"
+require "digest"
+require_relative "pull_request_lifecycle"
+require_relative "../atoms/delivery_parameters"
+require_relative "../atoms/service_pr_input"
+
+module Ace
+  module Git
+    module Organisms
+      # A fixed receiver-side operation, never a grant or a worker fallback.
+      class ServiceMerge
+        MAX_INPUT = 128 * 1024
+        MAX_SERVICE_INPUT = 64 * 1024
+        MAX_ARTIFACT = 64 * 1024
+        ARTIFACT = "pr-result.txt"
+        REQUEST = %w[request_id assignment_id attempt_id project_id operation input_digest target candidate_head
+          executor_uid transport authorization service_id caller_uid].freeze
+        EXECUTION = %w[executor_uid authority_id claim_binding candidate_generation head staging_id].freeze
+        TOKEN = /\A[a-zA-Z0-9][a-zA-Z0-9_.-]{0,127}\z/
+        SHA = /\A[0-9a-f]{40}\z/
+        DIGEST = /\A[0-9a-f]{64}\z/
+
+        def initialize(operation: "merge", lifecycle_factory: nil, uid: -> { Process.uid }, euid: -> { Process.euid })
+          raise ArgumentError, "unsupported fixed PR operation" unless Atoms::ServicePrInput::OPERATIONS.include?(operation)
+          @operation = operation
+          @factory = lifecycle_factory || ->(**selection) { PullRequestLifecycle.new(**selection) }
+          @uid, @euid = uid, euid
+        end
+
+        def call(bytes:, root:)
+          envelope = parse!(bytes)
+          request, execution, input = envelope.values_at("request", "execution", "input")
+          parameters = Atoms::DeliveryParameters.validate(input.fetch("delivery"))
+          Atoms::ServicePrInput.validate(input, operation: @operation)
+          directory, held = private_root!(root)
+          begin
+            lifecycle = @factory.call(server_name: parameters["forge_server"], use_default: parameters.fetch("forge_default"), repo_root: directory)
+            server = if @operation == "create"
+              lifecycle.resolved_repository_identity(request.fetch("target").fetch("resource"))
+            else
+              lifecycle.resolved_identity(request.fetch("target").fetch("resource"))
+            end
+            provenance = parameters.fetch("pr_provenance")
+            unless Atoms::ServerUrl.match?(server.fetch("url"), provenance.fetch("base_repository_url"))
+              raise ProviderIdentityMismatchError, "merge forge differs from accepted provenance"
+            end
+            pinned = ResolvedServer.new(name: server.fetch("name"), provider: server.fetch("provider").to_sym, url: server.fetch("url"))
+            lifecycle = @factory.call(server_name: pinned.name, use_default: false, repo_root: directory, resolved_server: pinned)
+            resource, head = request.fetch("target").fetch("resource"), execution.fetch("head")
+            if @operation != "create"
+              before = lifecycle.show(resource)
+              verify_pr!(before, resource, head, server, provenance)
+              if %w[update ready].include?(@operation) && before.state.to_s != "open"
+                raise ProviderExpectedHeadConflictError, "protected PR edit requires an open PR"
+              end
+              if @operation == "update" && !before.draft
+                raise ProviderExpectedHeadConflictError, "protected update requires a draft PR"
+              end
+            end
+            title = lifecycle.draft_title(input.fetch("title")) if Atoms::ServicePrInput::DRAFT_OPERATIONS.include?(@operation)
+            receipt = case @operation
+            when "create"
+              lifecycle.create(head_ref: provenance.fetch("head_ref"), base_ref: provenance.fetch("base_ref"),
+                head_repository_url: provenance.fetch("head_repository_url"), expected_head: head,
+                title: title, body: input.fetch("body"), draft: true)
+            when "update"
+              lifecycle.update(resource, expected_head: head, title: title, body: input.fetch("body"))
+            when "ready" then lifecycle.ready(resource, expected_head: head)
+            when "merge" then lifecycle.merge(resource, expected_head: head, method: input.fetch("method"))
+            end
+            unless receipt.is_a?(ProviderMutationReceipt) && receipt.server_name == pinned.name && receipt.operation.to_s == @operation
+              raise ProviderUnknownOutcomeError, "PR response does not identify the selected operation"
+            end
+            after = receipt.pull_request
+            raise ProviderUnknownOutcomeError, "PR response lacks its exact result" unless after.is_a?(ProviderPullRequest)
+            verify_pr!(after, @operation == "create" ? after.url : resource, head, server, provenance)
+            if @operation == "merge"
+              unless after.state.to_s == "merged" && after.merge_commit_sha.is_a?(String) && after.merge_commit_sha.match?(SHA)
+                raise ProviderUnknownOutcomeError, "merge outcome is not verified"
+              end
+              payload = {"server" => server, "delivery" => parameters, "method" => input.fetch("method"),
+                "candidate_head" => head, "receipt" => receipt.to_h}
+            else
+              expected_draft = Atoms::ServicePrInput::DRAFT_OPERATIONS.include?(@operation)
+              unless after.state.to_s == "open" && after.draft == expected_draft &&
+                  (!expected_draft || after.title == title && after.body == input.fetch("body"))
+                raise ProviderUnknownOutcomeError, "PR draft/content outcome is not verified"
+              end
+              payload = {"server" => server, "operation" => @operation, "input" => input,
+                "candidate_head" => head, "receipt" => receipt.to_h}
+            end
+            artifact = "ace-service-attestation request:#{request.fetch('request_id')} input:#{request.fetch('input_digest')} outcome:succeeded\n" + JSON.generate(payload) + "\n"
+            digest = publish!(directory, held, artifact)
+            {"request_id" => request.fetch("request_id"), "input_digest" => request.fetch("input_digest"),
+              "outcome" => "succeeded", "evidence" => [{"ref" => ARTIFACT, "sha256" => digest}]}
+          ensure
+            held.close
+          end
+        end
+
+        private
+
+        def parse!(bytes)
+          unless bytes.is_a?(String) && bytes.bytesize.between?(1, MAX_INPUT) && bytes.dup.force_encoding(Encoding::UTF_8).valid_encoding? && !bytes.include?("\0")
+            raise ArgumentError, "merge envelope is invalid or oversized"
+          end
+          envelope = JSON.parse(bytes, max_nesting: 16, create_additions: false,
+            allow_duplicate_key: false, allow_comments: false, allow_nan: false)
+          closed!(envelope, %w[version request input execution])
+          raise ArgumentError, "merge envelope version differs" unless envelope["version"].is_a?(Integer) && envelope["version"] == 1
+          request, execution, input = envelope.values_at("request", "execution", "input")
+          closed!(request, REQUEST)
+          closed!(execution, EXECUTION)
+          Atoms::ServicePrInput.validate(input, operation: @operation)
+          raise ArgumentError, "merge service input exceeds receiver bound" if JSON.generate(input).bytesize > MAX_SERVICE_INPUT
+          closed!(input["target"], %w[resource artifact_digest])
+          closed!(request["target"], %w[resource artifact_digest])
+          %w[request_id assignment_id attempt_id project_id authorization service_id].each do |key|
+            raise ArgumentError, "merge request identifier differs" unless request[key].is_a?(String) && request[key].match?(TOKEN)
+          end
+          %w[authority_id staging_id].each do |key|
+            raise ArgumentError, "merge execution identifier differs" unless execution[key].is_a?(String) && execution[key].match?(TOKEN)
+          end
+          unless request["operation"] == @operation && request["transport"] == "unix" &&
+              %w[executor_uid caller_uid].all? { |key| request[key].is_a?(Integer) && request[key].positive? } &&
+              request["executor_uid"] != request["caller_uid"] && request["executor_uid"] == execution["executor_uid"] &&
+              execution["executor_uid"].is_a?(Integer) &&
+              request["executor_uid"] == @uid.call && request["executor_uid"] == @euid.call &&
+              execution["candidate_generation"].is_a?(Integer) && execution["candidate_generation"].positive? &&
+              execution["head"].is_a?(String) && execution["head"].match?(SHA) && request["candidate_head"] == execution["head"] &&
+              execution["claim_binding"].is_a?(String) && execution["claim_binding"].match?(DIGEST) &&
+              request["input_digest"].is_a?(String) && request["input_digest"].match?(DIGEST) &&
+              request["input_digest"] == Digest::SHA256.hexdigest(JSON.generate(canonical(input))) && request["target"] == input["target"]
+            raise ArgumentError, "merge original claim/input/executor join differs"
+          end
+          target = input.fetch("target")
+          reference = target["resource"].is_a?(String) && Atoms::PrReference.parse(target["resource"])
+          unless (@operation == "create" || reference && reference.repository_url) && target["resource"].is_a?(String) && target["resource"].bytesize.between?(1, 256) &&
+              (target["artifact_digest"].nil? || target["artifact_digest"].is_a?(String) && target["artifact_digest"].match?(DIGEST))
+            raise ArgumentError, "merge target requires an exact PR URL"
+          end
+          envelope
+        rescue JSON::ParserError, JSON::NestingError, KeyError
+          raise ArgumentError, "merge envelope is malformed"
+        end
+
+        def closed!(value, fields)
+          raise ArgumentError, "merge fields differ" unless value.is_a?(Hash) && value.keys.sort == fields.sort
+        end
+
+        def canonical(value)
+          case value
+          when Hash then value.keys.sort.to_h { |key| [key, canonical(value.fetch(key))] }
+          when Array then value.map { |item| canonical(item) }
+          else value
+          end
+        end
+
+        def verify_pr!(pr, resource, head, server, provenance)
+          reference = Atoms::PrReference.parse(resource)
+          unless pr.is_a?(ProviderPullRequest) && reference && reference.repository_url && pr.url == resource && pr.number == reference.number &&
+              pr.server_name == server.fetch("name") && pr.head_sha == head &&
+              pr.head_ref == provenance.fetch("head_ref") && pr.base_ref == provenance.fetch("base_ref") &&
+              Atoms::ServerUrl.match?(reference.repository_url, provenance.fetch("base_repository_url")) &&
+              Atoms::ServerUrl.match?(pr.head_repository_url, provenance.fetch("head_repository_url")) &&
+              Atoms::ServerUrl.match?(pr.base_repository_url, provenance.fetch("base_repository_url"))
+            raise ProviderExpectedHeadConflictError, "merge PR identity/head/provenance differs"
+          end
+        end
+
+        def private_root!(root)
+          raise ArgumentError, "merge staging root must be absolute" unless root.is_a?(String) && root.start_with?("/")
+          held = File.open(root, File::RDONLY | File::NOFOLLOW | File::NONBLOCK)
+          stat = held.stat
+          unless stat.directory? && stat.uid == @uid.call && (stat.mode & 0o7777) == 0o700 &&
+              [stat.dev, stat.ino] == File.lstat(root).then { |value| [value.dev, value.ino] }
+            raise ArgumentError, "merge staging root is not private"
+          end
+          [root, held]
+        rescue StandardError
+          held&.close
+          raise
+        end
+
+        def publish!(root, held, bytes)
+          raise ProviderUnknownOutcomeError, "merge result exceeds evidence bound" unless bytes.bytesize <= MAX_ARTIFACT
+          stat = held.stat
+          identity = [stat.dev, stat.ino]
+          unless stat.directory? && stat.uid == @uid.call && (stat.mode & 0o7777) == 0o700 &&
+              identity == File.lstat(root).then { |value| [value.dev, value.ino] }
+            raise ProviderUnknownOutcomeError, "merge staging root changed"
+          end
+          File.open(File.join(root, ARTIFACT), File::RDWR | File::CREAT | File::EXCL | File::NOFOLLOW | File::NONBLOCK, 0o600) do |file|
+            file.write(bytes); file.flush; file.fsync; file.chmod(0o400)
+            before = file.stat
+            file.rewind
+            captured = file.read(MAX_ARTIFACT + 1)
+            after = file.stat
+            unless before.file? && before.uid == @uid.call && captured == bytes &&
+                [before.dev, before.ino, before.size, before.mtime, before.ctime] == [after.dev, after.ino, after.size, after.mtime, after.ctime]
+              raise ProviderUnknownOutcomeError, "merge held evidence changed"
+            end
+            held.fsync
+            raise ProviderUnknownOutcomeError, "merge staging root changed" unless identity == File.lstat(root).then { |value| [value.dev, value.ino] }
+            Digest::SHA256.hexdigest(captured)
+          end
+        rescue SystemCallError, IOError
+          raise ProviderUnknownOutcomeError, "merge evidence publication unavailable"
+        end
+      end
+    end
+  end
+end

data/lib/ace/git/providers/base.rb

@@ -17,6 +17,12 @@ module Ace
       #   keyword arguments (args:, timeout:, env:) and returning a Hash with
       #   :stdout, :stderr, :exit_code
       class Base
+        # Pure transport title for the requested draft state. Providers own
+        # server-specific draft encodings; callers retain their original title.
+        def self.pull_request_title(title:, draft:)
+          title
+        end
+
         attr_reader :server, :timeout
 
         # @param server [ResolvedServer] resolved server identity

data/lib/ace/git/version.rb

@@ -2,6 +2,6 @@
 
 module Ace
   module Git
-    VERSION = "0.29.0"
+    VERSION = "0.30.1"
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ace-git
 version: !ruby/object:Gem::Version
-  version: 0.29.0
+  version: 0.30.1
 platform: ruby
 authors:
 - Michal Czyz
 bindir: exe
 cert_chain: []
-date: 2026-10-05 00:00:00.000000000 Z
+date: 2026-10-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ace-support-config
@@ -141,6 +141,7 @@ files:
 - lib/ace/git.rb
 - lib/ace/git/atoms/command_executor.rb
 - lib/ace/git/atoms/date_resolver.rb
+- lib/ace/git/atoms/delivery_parameters.rb
 - lib/ace/git/atoms/diff_numstat_parser.rb
 - lib/ace/git/atoms/diff_parser.rb
 - lib/ace/git/atoms/file_grouper.rb
@@ -154,6 +155,9 @@ files:
 - lib/ace/git/atoms/repository_checker.rb
 - lib/ace/git/atoms/repository_state_detector.rb
 - lib/ace/git/atoms/server_url.rb
+- lib/ace/git/atoms/service_merge_evidence.rb
+- lib/ace/git/atoms/service_pr_evidence.rb
+- lib/ace/git/atoms/service_pr_input.rb
 - lib/ace/git/atoms/stale_lock_cleaner.rb
 - lib/ace/git/atoms/status_formatter.rb
 - lib/ace/git/atoms/task_pattern_extractor.rb
@@ -162,6 +166,7 @@ files:
 - lib/ace/git/cli/commands/branch.rb
 - lib/ace/git/cli/commands/diff.rb
 - lib/ace/git/cli/commands/pr.rb
+- lib/ace/git/cli/commands/service_merge.rb
 - lib/ace/git/cli/commands/status.rb
 - lib/ace/git/errors.rb
 - lib/ace/git/models/diff_config.rb
@@ -177,6 +182,7 @@ files:
 - lib/ace/git/organisms/issue_tracking.rb
 - lib/ace/git/organisms/pull_request_lifecycle.rb
 - lib/ace/git/organisms/repo_status_loader.rb
+- lib/ace/git/organisms/service_merge.rb
 - lib/ace/git/providers.rb
 - lib/ace/git/providers/base.rb
 - lib/ace/git/providers/evidence.rb