ace-git 0.28.1 → 0.30.0

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

@@ -29,8 +29,10 @@ module Ace
         # @param remote_name [String, nil] git remote used when nothing selected
         # @param timeout [Integer, nil] provider operation timeout
         # @param runner [Proc, nil] injectable provider command runner (tests)
-        def initialize(server_name: nil, use_default: false, remote_name: nil, timeout: nil, runner: nil)
+        def initialize(server_name: nil, use_default: false, remote_name: nil, timeout: nil, runner: nil, repo_root: nil, resolved_server: nil)
+          @pinned_server = resolved_server
           @selection = {server_name: server_name, use_default: use_default, remote_name: remote_name}
+          @selection[:repo_root] = repo_root if repo_root
           @timeout = timeout
           @runner = runner
         end
@@ -194,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]
@@ -234,6 +241,37 @@ module Ace
           )
         end
 
+        # Freeze the selected provider identity for an assignment attempt.
+        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
+        # does not authorize another write; the assignment owns that policy.
+        def reconcile_create(head_repository_url:, head_ref:, base_repository_url:, base_ref:)
+          server = resolve_selected_server
+          unless Atoms::ServerUrl.match?(server.url, base_repository_url)
+            raise ProviderIdentityMismatchError, "Create reconciliation base does not match selected server"
+          end
+          provider_for(server).find_open_pull_requests(head_repository_url: head_repository_url,
+            head_ref: head_ref, base_repository_url: base_repository_url, base_ref: base_ref)
+        end
+
         def resolved_server_url(identifier)
           reference = parse_identifier(identifier)
           resolve_server_for(reference).url
@@ -255,7 +293,11 @@ module Ace
         end
 
         def resolve_selected_server
-          ServerRegistry.resolve_for(**@selection)
+          selected = ServerRegistry.resolve_for(**@selection)
+          if @pinned_server && selected != @pinned_server
+            raise ProviderIdentityMismatchError, "Configured server identity changed from the pinned delivery identity"
+          end
+          @pinned_server || selected
         end
 
         # Resolve exactly one server for a parsed reference, validating any
@@ -269,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 = ServerRegistry.resolve_for(**@selection)
+            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
@@ -281,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/server_registry.rb

@@ -80,9 +80,9 @@ module Ace
         # @return [ResolvedServer] the single matching configured server
         # @raise [AmbiguousRemoteError] when the remote matches no configured
         #   server, or more than one
-        def resolve_remote(remote_name = nil)
+        def resolve_remote(remote_name = nil, repo_root: nil)
           remote_name ||= Ace::Git.config["remote"] || "origin"
-          remote_url = read_remote_url(remote_name)
+          remote_url = read_remote_url(remote_name, repo_root: repo_root)
           matches = entries.map(&:server).select { |server| Atoms::ServerUrl.match?(server.url, remote_url) }
 
           if matches.empty?
@@ -108,7 +108,7 @@ module Ace
         # @raise [ConfigError] when explicit selection and default conflict
         # @raise [UnknownServerNameError, NoDefaultServerConfiguredError,
         #   MultipleDefaultServersError, AmbiguousRemoteError] per resolution
-        def resolve_for(server_name: nil, use_default: false, remote_name: nil)
+        def resolve_for(server_name: nil, use_default: false, remote_name: nil, repo_root: nil)
           if server_name && use_default
             raise ConfigError,
               "Server selection is ambiguous: an explicit server ('#{server_name}') and " \
@@ -120,7 +120,7 @@ module Ace
           elsif use_default
             resolve_default
           else
-            resolve_remote(remote_name)
+            resolve_remote(remote_name, repo_root: repo_root)
           end
         end
 
@@ -173,8 +173,10 @@ module Ace
         end
 
         # Read a remote URL with local git only (no network, no forge CLI).
-        def read_remote_url(remote_name)
-          result = Atoms::CommandExecutor.execute("git", "remote", "get-url", remote_name.to_s)
+        def read_remote_url(remote_name, repo_root: nil)
+          argv = ["git"]
+          argv += ["-C", repo_root] if repo_root
+          result = Atoms::CommandExecutor.execute(*argv, "remote", "get-url", remote_name.to_s)
           result[:success] ? result[:output].to_s.strip : nil
         end
 

data/lib/ace/git/version.rb

@@ -2,6 +2,6 @@
 
 module Ace
   module Git
-    VERSION = "0.28.1"
+    VERSION = "0.30.0"
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ace-git
 version: !ruby/object:Gem::Version
-  version: 0.28.1
+  version: 0.30.0
 platform: ruby
 authors:
 - Michal Czyz
 bindir: exe
 cert_chain: []
-date: 2026-10-04 00:00:00.000000000 Z
+date: 2026-10-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ace-support-config
@@ -124,23 +124,24 @@ files:
 - handbook/guides/version-control/ruby.md
 - handbook/guides/version-control/rust.md
 - handbook/guides/version-control/typescript.md
+- handbook/skills/as-git-pr-create/SKILL.md
+- handbook/skills/as-git-pr-update/SKILL.md
 - handbook/skills/as-git-rebase/SKILL.md
 - handbook/skills/as-git-reorganize-commits/SKILL.md
-- handbook/skills/as-github-pr-create/SKILL.md
-- handbook/skills/as-github-pr-update/SKILL.md
 - handbook/skills/as-github-release-publish/SKILL.md
 - handbook/templates/commit/squash.template.md
 - handbook/templates/pr/bugfix.template.md
 - handbook/templates/pr/default.template.md
 - handbook/templates/pr/feature.template.md
+- handbook/workflow-instructions/git/pr/create.wf.md
+- handbook/workflow-instructions/git/pr/update.wf.md
 - handbook/workflow-instructions/git/rebase.wf.md
 - handbook/workflow-instructions/git/reorganize-commits.wf.md
-- handbook/workflow-instructions/github/pr/create.wf.md
-- handbook/workflow-instructions/github/pr/update.wf.md
 - handbook/workflow-instructions/github/release-publish.wf.md
 - 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

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

@@ -1,72 +0,0 @@
----
-name: as-github-pr-create
-description: Create GitHub pull request with generated description and summary
-# bundle: wfi://github/pr/create
-# agent: general-purpose
-user-invocable: true
-allowed-tools:
-  - Bash(ace-git:*)
-  - Bash(ace-bundle:*)
-  - Bash(gh:*)
-  - Read
-argument-hint: pr-type
-last_modified: 2026-01-10
-source: ace-git
-integration:
-  targets:
-    - claude
-    - codex
-    - gemini
-    - opencode
-    - pi
-  providers:
-    claude:
-      frontmatter:
-        context: fork
-        model: haiku
-assign:
-  steps:
-    - name: create-pr
-      description: Create a pull request for the implemented changes
-      intent:
-        phrases:
-          - "create pr"
-          - "create a pr"
-          - "open pr"
-          - "open pull request"
-      prerequisites:
-        - name: work-on-task
-          strength: required
-          reason: "Must have code changes to create a PR"
-      produces: [pull-request]
-      consumes: [code-changes, commits]
-      context:
-        default: null
-        reason: "PR creation needs access to git state in main context"
-      when_to_skip:
-        - "PR already exists for this branch"
-        - "Changes don't warrant a PR (e.g., direct push allowed)"
-      effort: light
-      tags: [git, pr, publishing]
-skill:
-  kind: workflow
-  execution:
-    workflow: wfi://github/pr/create
----
-
-## Arguments
-
-Use the skill `argument-hint` values as the explicit inputs for this skill.
-
-## Variables
-
-None
-
-## Execution
-
-- You are working in the current project.
-- Run `ace-bundle wfi://github/pr/create` in the current project to load the workflow instructions.
-- Read the loaded workflow and execute it end-to-end in this project.
-- Follow the workflow as the source of truth.
-- Do the work described by the workflow instead of only summarizing it.
-- When the workflow requires edits, tests, or commits, perform them in this project.

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

@@ -1,41 +0,0 @@
----
-name: as-github-pr-update
-description: Update PR description based on current work
-# bundle: wfi://github/pr/update
-# agent: general-purpose
-user-invocable: true
-allowed-tools:
-  - Bash(ace-git:*)
-  - Bash(ace-bundle:*)
-  - Bash(gh:*)
-  - Read
-  - Grep
-argument-hint: pr-number
-last_modified: 2026-01-10
-source: ace-git
-integration:
-  targets:
-    - claude
-    - codex
-    - gemini
-    - opencode
-    - pi
-assign:
-  source: wfi://github/pr/update
-  steps:
-    - name: update-pr-desc
-      description: Update PR description with implementation summary and final state
-      intent:
-        phrases:
-          - "update pr description"
-          - "update pull request description"
-          - "refresh pr description"
-          - "sync pr description"
-      tags: [git, pr, documentation]
-skill:
-  kind: workflow
-  execution:
-    workflow: wfi://github/pr/update
----
-
-Load and run `ace-bundle wfi://github/pr/update` in the current project, then follow the loaded workflow as the source of truth and execute it end-to-end instead of only summarizing it.