ace-hitl 0.25.0 → 0.26.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f9115490bffe274fbc591fc0c0c3efb826c70fe549b17e7d57b5928e298ffe23
-  data.tar.gz: e14fa6ef9c4251fcad792f2c8cbdd362fe642b9c66dc7060fa621e6785f65d0a
+  metadata.gz: 64cb514390029a16b5a139d1d0db8da63b36c8fc08b21df9525d2f84bb94c1c3
+  data.tar.gz: 20118ea180abf1437a63d32c48c72581ca6e0aa115b79422b83f77aabc9afc04
 SHA512:
-  metadata.gz: b8f52aef4b90d868a62e1966523282ea1a74eabe20930034736e1a73a941c701df4c4580297659ea8c5255dc45676cf3f37b466c934faa5ce7d71e10cc2d4a5f
-  data.tar.gz: 202ca6825f02dcaec4da9fce88aaeef2ca66c33f98ef6cf51daa6585ec552dc7eeff8cfb3556ad35881aa0ccfa3cb13fc7653b68077a0ffbfcddbbf5b6e6f686
+  metadata.gz: e096433ca99b4cbc9455f21494d42d2cb08bc4dcf305e8e14d1e4c516a470ab8aa6a6e3eb723c3cb142570dc661197695cc30bb088c6c0713698ea6eda390446
+  data.tar.gz: d23bcb8c437f671d91d3661e3f27041939b4b3007acf680e19bb0c2c3315dd13f8250197cc60501786d4f7f875d20913db58c43694a65009f1442341f4a7982b

data/CHANGELOG.md

@@ -5,6 +5,20 @@ All notable changes to `ace-hitl` will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+## [0.26.0] - 2026-11-12
+
+### Added
+
+- Expose canonical local case cancellation through `cancel --case --reason`, preserving audited reasons and idempotence without fabricating human answers or contacting relay services.
+
+## [0.25.1] - 2026-11-10
+
+### Fixed
+
+- Share strict recipient selection between observation and report acceptance; preserve observation owner identity across worktrees.
+
 ## [0.25.0] - 2026-10-30
 
 ### Fixed (review rounds 3/3b + re-review R2)

data/handbook/workflow-instructions/hitl.wf.md

@@ -165,3 +165,16 @@ Canonical lifecycle namespace: `hitl.event.*`
 - Blockers always produce canonical `HITL: <id> <path>` failure reason.
 - Human-required completion handoffs generate approval HITL events.
 - Resolved HITL events are archived only after successful resume dispatch.
+
+## Withdraw an obsolete local question
+
+If the reason for an unanswered or unapplied question no longer exists, cancel
+the exact local case with the evidence. Do not manufacture a human answer:
+
+```bash
+ace-hitl cancel <case-id> --case --reason "Obsolete: verified new review commit and active next round"
+```
+
+This records terminal cancellation in the canonical case. Repetition is a no-op;
+an applied effect must be closed instead. Without `--case`, cancel addresses the
+relay request owner; it never guesses a different owner on lookup failure.

data/lib/ace/hitl/cli/commands/cancel.rb

@@ -14,16 +14,29 @@ module Ace
           include Ace::Support::Cli::Base
           include LifecycleCommand
 
-          desc "Cancel one HITL relay request with an audited reason"
+          desc "Cancel a relay request or an explicit local case with an audited reason"
 
           argument :id, required: true, desc: "HITL relay request id"
 
+          option :case, type: :boolean, desc: "Cancel an exact local case instead of a relay request; requires --reason"
+
           option :reason, type: :string, desc: "Audited reason recorded in the public lifecycle record"
 
           option :quiet, type: :boolean, aliases: %w[-q], desc: "Suppress non-essential output"
 
           def call(id:, **options)
-            emit(lifecycle_client.cancel(id, reason: options[:reason] || ""))
+            if options[:case]
+              reason = options[:reason].to_s.strip
+              raise Ace::Support::Cli::Error.new("local case cancellation requires --reason") if reason.empty?
+              state = Organisms::HitlManager.new.cancel_case(id, reason: reason)
+              emit({"case" => id, "state" => state.to_s})
+            else
+              emit(lifecycle_client.cancel(id, reason: options[:reason] || ""))
+            end
+          rescue Organisms::HitlManager::UnknownCaseError,
+            Organisms::HitlManager::AmbiguousReferenceError,
+            Organisms::HitlManager::LifecycleTransitionError => e
+            raise_lifecycle_error("not cancelled: #{e.message}")
           rescue Lifecycle::Error, Providers::ProviderUnavailableError => e
             raise_lifecycle_error(e.message)
           end

data/lib/ace/hitl/cli/commands/observe.rb

@@ -8,12 +8,13 @@ module Ace
         class Observe < Ace::Support::Cli::Command
           desc "Read bounded semantic event revisions without private message text"
           option :scope, type: :string, default: "current", desc: "current or all linked worktrees"
+          option :in, type: :string, default: "next", desc: "next for live events; all to verify archived publications"
           option :owner, type: :string, desc: "Configured recipient owning incoming events"
           option :limit, type: :integer, default: 500, desc: "Maximum event count (1..2000)"
           def call(**options)
             scope = options[:scope] || "current"
             raise Ace::Support::Cli::Error, "invalid scope" unless %w[current all].include?(scope)
-            puts JSON.generate(Molecules::EventObservation.new.call(scope: scope, limit: options[:limit] || 500, owner: options[:owner]))
+            puts JSON.generate(Molecules::EventObservation.new.call(scope: scope, limit: options[:limit] || 500, owner: options[:owner], in_folder: options[:in] || "next"))
           rescue ArgumentError => e
             raise Ace::Support::Cli::Error, e.message
           end

data/lib/ace/hitl/cli.rb

@@ -47,7 +47,7 @@ module Ace
         ["wait", "Wait for an answer on a specific HITL event"],
         ["deliver", "Deliver an answer (stdin) to a pending HITL relay request"],
         ["consume", "Wait for and consume the answer of one own HITL relay request"],
-        ["cancel", "Cancel one HITL relay request with an audited reason"],
+        ["cancel", "Cancel a relay request or explicit local case (--case)"],
         ["pending", "List answerable HITL relay requests (transport)"],
         ["states", "List public HITL lifecycle projections (transport)"],
         ["duty", "Project pending and escalated HITL requests (transport)"],

data/lib/ace/hitl/molecules/event_observation.rb

@@ -13,12 +13,8 @@ module Ace
           @manager = manager
         end
 
-        def call(scope: "current", limit: 500, owner: nil)
-          raise ArgumentError, "invalid observation limit" unless (1..2000).cover?(limit)
-          events = @manager.list(in_folder: "next", scope: scope, limit: limit, strict: true)
-          raise ArgumentError, "observation exceeds configured event budget" if events.size > limit
-          address = owner && Molecules::HitlAddressResolver.new(config: @manager.config).resolve(owner)
-          events = events.select { |event| incoming?(event, address) } if address
+        def call(scope: "current", limit: 500, owner: nil, in_folder: "next")
+          events = incoming_events(scope: scope, limit: limit, owner: owner, in_folder: in_folder)
           rows = events.map do |event|
             semantic = [event.id, event.type, event.status, event.result, event.kind,
               event.title, event.content, event.answer, event.questions,
@@ -32,6 +28,18 @@ module Ace
           {"schema" => "ace.hitl.observation/v1", "events" => rows.sort_by { |row| row["key"] }}
         end
 
+        # Shared read boundary for observation and report consumers. Preserve
+        # strict enumeration and recipient ownership in both paths.
+        def incoming_events(scope: "current", limit: 500, owner: nil, in_folder: "next")
+          raise ArgumentError, "invalid observation limit" unless (1..2000).cover?(limit)
+          raise ArgumentError, "invalid observation folder" unless %w[next all].include?(in_folder)
+          events = @manager.list(in_folder: in_folder, scope: scope, limit: limit, strict: true)
+          raise ArgumentError, "observation exceeds configured event budget" if events.size > limit
+          address = owner && Molecules::HitlAddressResolver.new(config: @manager.config).resolve(owner)
+          events = events.select { |event| incoming?(event, address) } if address
+          events
+        end
+
         private
 
         # Questions created locally are outbound until actually answered. A

data/lib/ace/hitl/organisms/hitl_manager.rb

@@ -115,7 +115,7 @@ module Ace
 
         def list(status: nil, kind: nil, type: nil, delivery: nil, in_folder: "next", tags: [], scope: nil, limit: nil, strict: false)
           effective_scope = @scope_resolver.effective_scope(scope)
-          scan_results = scan_results_for_scope(effective_scope, in_folder: in_folder)
+          scan_results = scan_results_for_scope(effective_scope, in_folder: in_folder, strict: strict)
           raise ArgumentError, "observation exceeds configured event budget" if limit && scan_results.size > limit
           events = load_events(scan_results)
           raise ArgumentError, "incomplete HITL observation" if strict && events.size != scan_results.size
@@ -267,7 +267,7 @@ module Ace
         # Only from the not-yet-applied states — an applied effect is
         # history and is closed, not cancelled.
         # @return [Symbol] :cancelled or :duplicate
-        def cancel_case(ref, scope: nil)
+        def cancel_case(ref, scope: nil, reason: nil)
           event = exact_case(ref, scope: scope)
 
           transition(event.file_path) do |frontmatter, _body|
@@ -276,6 +276,7 @@ module Ace
             when "", "pending"
               frontmatter["application"] = {"state" => "cancelled",
                 "cancelled_at" => timestamp}
+              frontmatter["application"]["reason"] = reason.to_s.strip unless reason.to_s.strip.empty?
               :cancelled
             when "cancelled"
               :duplicate
@@ -838,11 +839,12 @@ module Ace
           }
         end
 
-        private def scan_results_for_scope(scope, in_folder:)
+        private def scan_results_for_scope(scope, in_folder:, strict:)
           total = 0
           folder_counts = Hash.new(0)
 
           results = hitl_roots_for_scope(scope).uniq.flat_map do |hitl_root|
+            verify_observation_root!(hitl_root) if strict
             scanner = Molecules::HitlScanner.new(hitl_root)
             scoped_results = scanner.scan_in_folder(in_folder)
             total += scanner.last_scan_total.to_i
@@ -855,6 +857,16 @@ module Ace
           results
         end
 
+        private def verify_observation_root!(path)
+          return if File.stat(path).directory?
+
+          raise Errno::ENOTDIR, path
+        rescue Errno::ENOENT
+          # A worktree can legitimately have no events and no store yet.
+          # A dangling symlink, however, explicitly points at a lost source.
+          raise if File.symlink?(path)
+        end
+
         private def load_events(scan_results)
           scan_results.filter_map { |scan_result| load_event(scan_result) }
         end

data/lib/ace/hitl/version.rb

@@ -2,6 +2,6 @@
 
 module Ace
   module Hitl
-    VERSION = "0.25.0"
+    VERSION = "0.26.0"
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ace-hitl
 version: !ruby/object:Gem::Version
-  version: 0.25.0
+  version: 0.26.0
 platform: ruby
 authors:
 - Michal Czyz
 bindir: exe
 cert_chain: []
-date: 2026-10-30 00:00:00.000000000 Z
+date: 2026-11-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ace-hitl-contract