space-architect 7.0.0 → 7.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1d521b0afec00484bfba5b35e26e9f0a603807fb75f3569fa61b0a0b5ff9b3ab
-  data.tar.gz: d21ecd2d8dd8458b0ec2e89d4cc2ee45a5a70eafc53955b8d2b3c365b55efe3b
+  metadata.gz: 17559f544d11b36996a3e8f927a8e4c9d2db3f178687c726fee14793c7ec6de4
+  data.tar.gz: 5b7c00fc0748f05e5c557339d011f3583816399a2261c79ae45e93e3f9e78ae5
 SHA512:
-  metadata.gz: e27a4154359d6f41370287eb86eeb2881d415dd0ce7e5d6c3c3f241ff338f168a7393456d63faa5e3970e3a72eb927ae4db13d4f407e50e320d90ed54c79dc7e
-  data.tar.gz: 024047dcd39a0de008284fc256c3f7fb08ea8585e0cd0cae53f0e990b70f9e47341325cf92668ef632bf76ef2e34e5d082ccd98eba94af52c4f659c251afd9f8
+  metadata.gz: db1f7cf0ed0ce5401483b7f3e2e429e5caf2200d1baeb450940f6afddd017744bd449a5b05dc2cfbbfc70787967ec01b6542adbd301c69e470917f6b8887f41c
+  data.tar.gz: b1c4fb81c6eeb1c9158e77a4e75aa21e01d4d77ac203e448c8ba564c76c2977bff9959fb481f480858a647f52262f3bcc516743220f6113d8a17c3f614f0f5fc

data/CHANGELOG.md

@@ -5,6 +5,40 @@ All notable changes to this project are 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).
 
+## [7.1.0] - 2026-08-16
+
+One iteration of the Architect Loop (I01, space
+20260816-architect-rehearse-friction) closing the rehearse rerun tax: a heavy
+rehearsal now yields its verdict vector, per-gate reasons, and full raw output
+from one execution plus file reads.
+
+### Added
+
+- **`architect rehearse` writes a durable transcript and prints a bounded
+  summary.** Previously the CLI wrote an unbounded report to stdout only, so
+  every re-view of a run — a tail window, a grep filter, a verdict count —
+  re-ran the whole gate suite. Every non-EMPTY rehearsal now writes its full
+  report (each gate's command, dir, exit code, verdict, reason, complete
+  stdout+stderr, and scope-asymmetry findings) to a uniquely named file under
+  `build/rehearse/` and prints that path; the terminal report itself is now
+  bounded — one line per gate carrying its AC label, gate id, verdict, and
+  exit code regardless of how many lines the command spans, inline output
+  capped to the last 20 lines with an elision marker naming the transcript —
+  and always ends with a summary block (one line per gate, a tally by
+  verdict, and the transcript path) positioned last, so a `tail` of stdout
+  captures the whole outcome.
+- **`execute_gates` dedups identical executions.** Gates that share an
+  identical `(cmd, resolved dir)` pair now execute once; each is still
+  evaluated against its own `expect` and classified independently, the
+  group's effective timeout is the largest any member declares, and the
+  report/transcript name the shared execution so byte-identical output
+  doesn't read as a copy-paste bug. `run_gates` (judge time) shares this for
+  free — dedup lives in `execute_gates`, the one instrument both call.
+- **docs/RELEASING.md.** The release process, retraced from the v7.0.0
+  landing: preconditions, the release-prep commit, the human-run PR/merge and
+  signed-tag steps, what the tag-push automation covers, and local-install
+  verification (including the stale-binstub PATH hazard).
+
 ## [7.0.0] - 2026-08-14
 
 Three iterations of the Architect Loop run against this repo's own tooling, each

data/lib/space_architect/architect_project.rb

@@ -595,16 +595,17 @@ module Space::Architect
       text = path.read
 
       gates = parse_gates(text)
-      repo, base_dir, gate_results, scope_report =
+      repo, base_dir, gate_results, scope_report, transcript =
         if gates.empty?
-          [nil, nil, [], nil]
+          [nil, nil, [], nil, nil]
         else
           r   = resolve_rehearsal_repo(iteration, text, gates)
           dir = r ? space.path.join("repos", r) : nil
           raise Space::Core::Error, "directory does not exist: #{dir}" if dir && !dir.exist?
           results = execute_gates(gates, base_dir: dir, lane: nil, repo_root: nil)
                     .map { |g| g.merge(rehearsal: classify_rehearsal(g)) }
-          [r, dir, results, scope_asymmetry_report(results, text)]
+          scope = scope_asymmetry_report(results, text)
+          [r, dir, results, scope, write_rehearsal_transcript(entry, r, dir, results, scope, now)]
         end
 
       digest = gates_digest(text)
@@ -617,7 +618,8 @@ module Space::Architect
       end
 
       { iteration: iteration, repo: repo, base_dir: base_dir, gates: gate_results,
-        empty: gates.empty?, placeholder: untouched_ac_placeholder?(text), scope_asymmetry: scope_report }
+        empty: gates.empty?, placeholder: untouched_ac_placeholder?(text), scope_asymmetry: scope_report,
+        transcript: transcript }
     end
 
     # Emit grounding reads for the architect's SessionStart hook.
@@ -1252,28 +1254,35 @@ module Space::Architect
     # same shell (capture_with_timeout's Process.spawn), same GateEvaluator,
     # same timeout handling (I09/AC3). repo_root/lane are nil outside a lane
     # context (rehearsal never has one — it always runs in the repo checkout).
+    #
+    # I01: gates sharing an identical (resolved cmd, resolved dir) pair execute
+    # once; the shared capture is fanned back out to every member, each still
+    # evaluated against its own `expect` and classified independently. A
+    # group's effective timeout is the largest any member declares, so no
+    # duplicate is cut short by another's shorter budget.
     def execute_gates(gates, base_dir:, lane:, repo_root:)
-      gates.map do |gate|
+      resolved = gates.map do |gate|
         g   = gate.transform_keys(&:to_s)
-        dir =
-          if (cwd = g["cwd"])
-            gate_cwd = space.path.join(cwd)
-            if lane && repo_root && (gate_cwd == repo_root || gate_cwd.to_s.start_with?("#{repo_root}/"))
-              base_dir.join(gate_cwd.relative_path_from(repo_root)).cleanpath
-            else
-              gate_cwd
-            end
-          else
-            base_dir
-          end
+        dir = resolve_gate_dir(g, base_dir: base_dir, lane: lane, repo_root: repo_root)
         raise Space::Core::Error, "directory does not exist: #{dir}" unless dir.exist?
+        [g, dir]
+      end
+
+      groups = resolved.group_by { |g, dir| [g["cmd"], dir.to_s] }
+      captures = groups.transform_values do |members|
+        timeout       = members.map { |g, _| g["timeout"] || DEFAULT_GATE_TIMEOUT }.max
+        sample_g, dir = members.first
+        capture_with_timeout(sample_g["cmd"], dir: dir, timeout: timeout).merge(timeout: timeout)
+      end
 
-        effective = g["timeout"] || DEFAULT_GATE_TIMEOUT
-        captured = capture_with_timeout(g["cmd"], dir: dir, timeout: effective)
+      resolved.map do |g, dir|
+        key      = [g["cmd"], dir.to_s]
+        captured = captures[key]
+        siblings = groups[key].map { |gg, _| gg["id"] } - [g["id"]]
 
         if captured[:timed_out]
           status = :fail
-          reason = "timed out after #{effective}s"
+          reason = "timed out after #{captured[:timeout]}s"
         else
           ev     = GateEvaluator.call(stdout: captured[:stdout], exit_code: captured[:exit_code], expect: g["expect"] || {})
           status = ev.pass? ? :pass : :fail
@@ -1282,10 +1291,69 @@ module Space::Architect
 
         { id: g["id"], ac: g["ac"].to_s, cmd: g["cmd"], expect: g["expect"],
           stdout: captured[:stdout], stderr: captured[:stderr], exit_code: captured[:exit_code],
-          dir: dir, status: status, reason: reason, timed_out: captured[:timed_out] }
+          dir: dir, status: status, reason: reason, timed_out: captured[:timed_out],
+          shared_with: siblings }
+      end
+    end
+
+    # The directory a single gate executes in: its own `cwd` (remapped into the
+    # lane worktree when it falls under repo_root) or the run's base_dir.
+    def resolve_gate_dir(g, base_dir:, lane:, repo_root:)
+      return base_dir unless (cwd = g["cwd"])
+
+      gate_cwd = space.path.join(cwd)
+      if lane && repo_root && (gate_cwd == repo_root || gate_cwd.to_s.start_with?("#{repo_root}/"))
+        base_dir.join(gate_cwd.relative_path_from(repo_root)).cleanpath
+      else
+        gate_cwd
       end
     end
 
+    # I01: the durable, unbounded counterpart to the CLI's bounded terminal
+    # report — one file per non-EMPTY rehearsal under build/rehearse/, holding
+    # every gate's full command, dir, exit code, verdict, reason, and complete
+    # stdout+stderr, plus the scope-asymmetry findings. The CLI prints this
+    # path so a rerun is never needed just to see output the terminal trimmed.
+    def write_rehearsal_transcript(entry, repo, base_dir, gate_results, scope_report, now)
+      dir  = space.path.join("build", "rehearse")
+      FileUtils.mkdir_p(dir)
+      path = dir.join("#{iteration_id(entry)}-#{now.strftime('%Y%m%dT%H%M%S.%6N')}.md")
+
+      lines = ["# Rehearsal transcript — #{entry['name']} — #{now.iso8601}"]
+      lines << (repo ? "Repo: #{repo} (#{base_dir})" : "Each gate ran in its own declared cwd")
+
+      gate_results.each do |g|
+        lines << ""
+        lines << "## #{g[:ac].empty? ? "(gate)" : g[:ac]} #{g[:id]} — #{g[:rehearsal].to_s.upcase} (exit #{g[:exit_code].inspect})"
+        lines << "cmd: #{g[:cmd]}"
+        lines << "dir: #{g[:dir]}"
+        lines << "reason: #{g[:reason]}" unless g[:reason].to_s.empty?
+        lines << "shared execution with: #{g[:shared_with].join(', ')} (identical cmd+dir, captured once)" if g[:shared_with]&.any?
+        lines << "--- stdout ---"
+        lines << g[:stdout].to_s
+        lines << "--- stderr ---"
+        lines << g[:stderr].to_s
+      end
+
+      if scope_report && (scope_report[:findings].any? || scope_report[:not_analyzable].any?)
+        lines << ""
+        lines << "## Scope-asymmetry check (grep-family gates only)"
+        scope_report[:findings].each do |f|
+          lines << "── #{f[:id]} (#{f[:repo]}): pattern #{f[:pattern].inspect} searched #{f[:paths].join(', ')}"
+          if f[:outside_lanes].any?
+            lines << "OUTSIDE ANY LANE'S TOUCH SET — no lane may legally fix these:"
+            f[:outside_lanes].each { |file| lines << "  #{file}" }
+          end
+          lines << "also matches (within a declared lane's touch set): #{f[:within_lanes].join(', ')}" if f[:within_lanes].any?
+          lines << "0 files elsewhere match" if f[:outside_lanes].empty? && f[:within_lanes].empty?
+        end
+        scope_report[:not_analyzable].each { |na| lines << "not analyzed — #{na[:id]}: #{na[:reason]}" }
+      end
+
+      path.write("#{lines.join("\n")}\n")
+      path
+    end
+
     # I09/AC4, #90/AC5-AC6: resolve the repo to default for gates that declare no
     # `cwd` of their own — only those gates need one, and only they are ambiguous
     # when the drafted ```lanes``` block names more than one repo. A gate with its

data/lib/space_architect/cli/architect.rb

@@ -262,17 +262,29 @@ module Space::Architect
 
         private
 
+        # I01: inline output is bounded — one identity line per gate, ≤ 20
+        # lines of tail output — because the full report always lands in the
+        # transcript #render_gate points at. The summary block is emitted last
+        # (after the disclaimer) so a `tail` of stdout captures it whole.
         def render_rehearsal(result)
           if result[:empty]
             reason = result[:placeholder] ? "the scaffold placeholder '#{ArchitectProject::AC1_PLACEHOLDER}' with no active gate" : "no gates drafted yet"
             terminal.say "EMPTY — #{reason}. Nothing to rehearse; the pre-freeze look is still stamped."
-          else
-            terminal.say rehearsal_header(result)
-            result[:gates].each { |g| render_gate(g) }
-            render_scope_asymmetry(result[:scope_asymmetry])
+            terminal.say ""
+            terminal.say discrimination_note
+            return
           end
+
+          terminal.say rehearsal_header(result)
+          result[:gates].each { |g| render_gate(g, result[:transcript]) }
+          render_scope_asymmetry(result[:scope_asymmetry])
           terminal.say ""
-          terminal.say "Discrimination report only — this runs and reports; it never judges whether these gates are good, bad, or ready."
+          terminal.say discrimination_note
+          render_summary(result)
+        end
+
+        def discrimination_note
+          "Discrimination report only — this runs and reports; it never judges whether these gates are good, bad, or ready."
         end
 
         # #90/AC7: with a single defaultable repo, name it as before; a cross-repo
@@ -286,17 +298,45 @@ module Space::Architect
           end
         end
 
-        def render_gate(g)
+        # I01/AC "bounded terminal report": identity (AC label, gate id, verdict,
+        # exit code) always lands on one stdout line, however many lines `cmd`
+        # spans — the command itself is shown as at most its first line,
+        # truncated; the full command lives in the transcript.
+        CMD_LINE_MAX    = 100
+        OUTPUT_LINE_CAP = 20
+
+        def render_gate(g, transcript_path)
           terminal.say ""
-          terminal.say "── #{g[:ac].empty? ? "(gate)" : g[:ac]}: #{g[:cmd]}  (exit #{g[:exit_code].inspect})  [#{g[:rehearsal].to_s.upcase}]"
+          terminal.say "── #{g[:ac].empty? ? "(gate)" : g[:ac]} #{g[:id]}: #{truncated_cmd(g[:cmd])}  (exit #{g[:exit_code].inspect})  [#{g[:rehearsal].to_s.upcase}]"
           terminal.say "   dir: #{terminal.path(g[:dir])}"
           terminal.say "   reason: #{g[:reason]}" unless g[:reason].to_s.empty?
+          if g[:shared_with]&.any?
+            terminal.say "   shared execution with: #{g[:shared_with].join(', ')} (identical cmd+dir, captured once)"
+          end
           if g[:rehearsal] == :broken
             terminal.say "   BROKEN is advisory, not certain — a correct RED can look broken (e.g. a file the lane " \
               "hasn't written yet). Confirm before treating it as a defect."
           end
-          terminal.say g[:stdout].rstrip unless g[:stdout].strip.empty?
-          terminal.say g[:stderr].rstrip unless g[:stderr].strip.empty?
+          render_gate_output(g, transcript_path)
+        end
+
+        def truncated_cmd(cmd)
+          first, *rest = cmd.to_s.each_line.map(&:chomp)
+          clipped = first.length > CMD_LINE_MAX ? "#{first[0, CMD_LINE_MAX]}…" : first
+          rest.any? || clipped != first ? "#{clipped} …" : clipped
+        end
+
+        def render_gate_output(g, transcript_path)
+          combined = [g[:stdout], g[:stderr]].map { |s| s.to_s.rstrip }.reject(&:empty?).join("\n")
+          return if combined.empty?
+
+          lines = combined.lines(chomp: true)
+          if lines.size > OUTPUT_LINE_CAP
+            terminal.say lines.last(OUTPUT_LINE_CAP).join("\n")
+            terminal.say "   … #{lines.size - OUTPUT_LINE_CAP} more line(s) elided — full output in #{terminal.path(transcript_path)}"
+          else
+            terminal.say lines.join("\n")
+          end
         end
 
         # I12/AC3-AC4: reports scope asymmetry only — never affects RED/GREEN/
@@ -325,6 +365,22 @@ module Space::Architect
           report[:not_analyzable].each { |na| terminal.say "   #{na[:id]}: #{na[:reason]}" }
         end
 
+        # I01: always-on, positioned last so a `tail` of stdout captures it
+        # whole — one line per gate (AC label, gate id, verdict; reason
+        # appended for RED/BROKEN), a tally by verdict, and the transcript path.
+        def render_summary(result)
+          terminal.say ""
+          terminal.say "Summary:"
+          result[:gates].each do |g|
+            line = "  #{g[:ac].empty? ? "(gate)" : g[:ac]} #{g[:id]} [#{g[:rehearsal].to_s.upcase}]"
+            line += " — #{g[:reason]}" if %i[red broken].include?(g[:rehearsal]) && !g[:reason].to_s.empty?
+            terminal.say line
+          end
+          tally = result[:gates].group_by { |g| g[:rehearsal] }.transform_values(&:size)
+          terminal.say "  #{%i[green red broken].filter_map { |v| "#{v.to_s.upcase}: #{tally[v]}" if tally[v] }.join(', ')}"
+          terminal.say "  transcript: #{terminal.path(result[:transcript])}"
+        end
+
         def render_record(result)
           return "> Rehearsed #{result[:iteration]} — no gates drafted; nothing to record." if result[:empty]
 

data/lib/space_core/version.rb

@@ -2,6 +2,6 @@
 
 module Space
   module Core
-    VERSION = "7.0.0"
+    VERSION = "7.1.0"
   end
 end

data/skill/architect/SKILL.md

@@ -381,9 +381,13 @@ architect-read.
   that measures nothing; **BROKEN**, a 127 / syntax error / timeout —
   advisory, because a correct RED can look broken (`grep -q x` on a file the
   lane will write exits 2): the tool names the suspicion, you confirm;
-  **EMPTY**, no gates or an untouched placeholder. `--record` emits a
-  paste-able provenance block for the AC preamble. It reports; which GREENs
-  are guards and which are defects stays your call.
+  **EMPTY**, no gates or an untouched placeholder. Every non-EMPTY run writes
+  a full transcript (every gate's command, dir, exit code, verdict, reason,
+  complete stdout+stderr) under `build/rehearse/`, prints its path, and ends
+  with a bounded summary — one line per gate plus a tally — so a rerun is
+  never needed just to re-see output the terminal already trimmed. `--record`
+  emits a paste-able provenance block for the AC preamble. It reports; which
+  GREENs are guards and which are defects stays your call.
 
 Then run `architect freeze <name>`. Freeze requires a fresh rehearsal stamp —
 `rehearse` records one in `space.yaml`, keyed to the gates block's content, so

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: space-architect
 version: !ruby/object:Gem::Version
-  version: 7.0.0
+  version: 7.1.0
 platform: ruby
 authors:
 - Eric Jacobs