space-architect 9.9.0 → 9.9.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bf5117e5de28d8f40811d45561c37ccd7852a1dc27758af06f08cc565aa90b65
-  data.tar.gz: 9c5fe91d46305b83d8f0fe3f17a689238ad6e81d620f95009b96c9f74da38b14
+  metadata.gz: f318cd07ca8f7d21bb494fa477a77b48e9c5166435e08eb68d7a108646d4b2df
+  data.tar.gz: d3aec9ba1be0f7671badd5a0dba43ad9a67c337c87dbd06ea3797ee954488679
 SHA512:
-  metadata.gz: 4698ad55f2c91d9a71fd996ad3523c6155aefad548c2ac9dba8a1f51bc115f2cfdad0223cc0353aefda83eed5c874625b02a58fc2b065feb124adaf0202c0674
-  data.tar.gz: d031b8fc81071a4c8a68892d07af6f8b4b0bf0c458a605c437fb513dd982fd7f79afb8cae8ee82bdd6281e5bd05cbdad8bb2c22edaa07f753e7a6a73e1fd9b14
+  metadata.gz: 4f7334e56966e8de660ece8d1cfea9239f501ff55b478a47166b7ef2bf888bbca588323c36fe4c80a5469f482f2b350ad23bfd90907c77347f5cb481c172333b
+  data.tar.gz: de4f8de478015e918f7c1742fb3d0ccf530d2ddd51d44da037c5eba090cae4c81af24446336277de8a0e61e85f4270956224dbdccda302564b745dd65573ab10

data/CHANGELOG.md

@@ -5,6 +5,34 @@ 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).
 
+## [9.9.2] - 2026-11-14
+
+### Added
+
+- **`architect looplog` reads tart records (I95)** — alongside the pi roots,
+  looplog now lists/follows tart's own run records (`TART_SUBAGENTS_HOME`,
+  default `~/.tart/subagents`: `status.json` identity with null-tolerant task
+  and dir-name id fallback, newest `sessions/**/*.jsonl` as the transcript
+  unit, space-cwd scope filter with both sides symlink-expanded, malformed
+  entries skipped silently) and session records (`TART_SESSIONS_DIR`, default
+  `~/.tart/sessions`: every `*.jsonl` under the space's slug dir, under the
+  `(session)` label). Both render through the ONE existing Renderer via a
+  drain-level tart→pi record adapter — no forked display code. Known display
+  note: the ✓ line's cache-read slot is filled from `cache_write_tokens`
+  (uniformly 0 across the real corpus, so rendering is byte-identical); the
+  slot correction rides the open `cache_read_tokens` follow-up.
+
+## [9.9.1] - 2026-10-30
+
+### Changed
+
+- **Driver-mode launch prose (matches the pi-extensions entry-compaction fix)** —
+  architect-action and DESIGN no longer describe an entry compaction at
+  `architect_loop` launch: a compaction aborts the in-flight turn and, with no
+  subagent in flight, nothing resumes the session. The driver begins driving in
+  the launch turn and first compacts (`architect_compact`) only after its first
+  child launch.
+
 ## [9.9.0] - 2026-10-30
 
 ### Added

data/lib/space_architect/agent_installer.rb

@@ -4,19 +4,23 @@ require "open3"
 
 module Space
   module Architect
-    # Installs the role playbooks (architect-spec/builder/judge/narrator) to
-    # ~/.pi/agent/agents and removes a stale architect-coordinator.md left by a
+    # Installs the role playbooks (architect-spec/builder/judge/narrator) to the
+    # provider's agents dir — ~/.pi/agent/agents for pi, ~/.tart/agents for tart
+    # — and removes a stale architect-coordinator.md left by a
     # pre-driver-era install (I10: the coordinator role retired — the architect
-    # session itself drives the loop). The playbook text is rendered by the
-    # installed architect-loop extension itself — the extension owns that text
-    # (it renders the per-space .pi/agents files from the same source), so this
-    # installer carries no second copy to drift. Routing pins come from the
-    # global architect.yaml (ENV["SPACE_ARCHITECT_GLOBAL_CONFIG"] overrides the
-    # path, honored inside the extension): the user-level files are the
-    # machine-wide fallback for sessions that cannot see a space's .pi dir;
-    # a space's own .pi/agents files always win inside that space.
+    # session itself drives the loop). One render, two dest roots: the playbook
+    # text is rendered by the installed architect-loop extension itself — the
+    # extension owns that text (it renders the per-space .pi/agents files from
+    # the same source), so this installer carries no second copy to drift; tart
+    # gets the same render from the same installed pi extension (tart has no
+    # extension of its own — its architect surfaces are native). Routing pins
+    # come from the global architect.yaml (ENV["SPACE_ARCHITECT_GLOBAL_CONFIG"]
+    # overrides the path, honored inside the extension): the user-level files
+    # are the machine-wide fallback for sessions that cannot see a space's .pi
+    # dir; a space's own .pi/agents files always win inside that space.
     module AgentInstaller
       ROLES = %w[spec builder judge narrator].freeze
+      PROVIDERS = %w[pi tart].freeze
 
       # Renders each role's agent file and prints it between ===FILE===<role>
       # markers. Dynamic import (node -e runs CJS; import() is legal there) so
@@ -42,7 +46,8 @@ module Space
       JS
 
       class << self
-        def install(env: ENV, force: false, dry_run: false, dest: nil, extension_dir: nil)
+        def install(env: ENV, provider: "pi", force: false, dry_run: false, dest: nil, extension_dir: nil)
+          validate_provider!(provider)
           source = extension_dir ? Pathname.new(extension_dir).join("architect-loop.ts") : locate_extension(env)
           unless source&.exist?
             raise Space::Core::Error,
@@ -50,7 +55,7 @@ module Space
                   "(install-agents renders its playbooks from the installed extension)"
           end
 
-          dest ||= default_dest(env)
+          dest ||= default_dest(env, provider)
           rendered = render_via_node(source, env)
           results = ROLES.map do |role|
             write_agent(dest.join("architect-#{role}.md"), rendered.fetch(role), force: force, dry_run: dry_run)
@@ -72,8 +77,21 @@ module Space
           [{ name: stale.basename.to_s, action: dry_run ? :would_remove : :removed, path: stale }]
         end
 
-        def default_dest(env)
-          Pathname.new(env.fetch("PI_AGENTS_DIR", File.join(pi_agent_dir(env), "agents")))
+        # Provider first: validation precedes the extension lookup and any
+        # render, so an unknown provider can never produce side effects.
+        def validate_provider!(provider)
+          return if PROVIDERS.include?(provider.to_s)
+
+          raise Space::Core::Error, "Unknown provider '#{provider}'. Expected one of: #{PROVIDERS.join(', ')}"
+        end
+
+        def default_dest(env, provider)
+          case provider.to_s
+          when "tart"
+            Pathname.new(Space::Core::XDG.home(env: env)).join(".tart", "agents")
+          else
+            Pathname.new(env.fetch("PI_AGENTS_DIR", File.join(pi_agent_dir(env), "agents")))
+          end
         end
 
         # Same convention as SkillInstaller: PI_CODING_AGENT_DIR or ~/.pi/agent.

data/lib/space_architect/cli/architect.rb

@@ -1175,7 +1175,7 @@ module Space::Architect
       class InstallSkills < BaseCommand
         desc "Install bundled skills (architect, architect-discuss, architect-action, architect-status, architect-research) for a harness"
         phase 53, "Project"
-        option :provider, default: "pi", desc: "Skill install target (default: pi; validated by the installer)"
+        option :provider, default: "pi", desc: "Skill install target: claude | codex | opencode | pi | tart (default: pi)"
         option :project, type: :boolean, default: false, desc: "Install to CWD instead of global"
         option :force,   type: :boolean, default: false, desc: "Overwrite existing skills that differ"
         option :dry_run, type: :boolean, default: false, desc: "Print what would happen without writing files"
@@ -1213,22 +1213,26 @@ module Space::Architect
         end
       end
 
-      # Role playbooks to ~/.pi/agent/agents, rendered from the installed
-      # architect-loop extension (the single owner of the playbook text) with
-      # global-routing pins — the machine-wide fallback for sessions that
-      # cannot see a space's .pi dir. Needs install-extensions to have run.
+      # Role playbooks to the provider's agents dir (~/.pi/agent/agents for pi,
+      # ~/.tart/agents for tart), rendered from the installed architect-loop
+      # extension (the single owner of the playbook text) with global-routing
+      # pins — the machine-wide fallback for sessions that cannot see a space's
+      # .pi dir. Needs install-extensions to have run (both providers render
+      # from the same installed pi extension).
       class InstallAgents < BaseCommand
-        desc "Install the role playbooks (architect-spec/builder/judge/narrator) to ~/.pi/agent/agents, rendered from the installed architect-loop extension, and remove a stale architect-coordinator.md"
+        desc "Install the role playbooks (architect-spec/builder/judge/narrator) to the provider's agents dir (~/.pi/agent/agents for pi, ~/.tart/agents for tart), rendered from the installed architect-loop extension, and remove a stale architect-coordinator.md"
         phase 53, "Project"
+        option :provider, default: "pi", desc: "Playbook install target: pi | tart (default: pi)"
         option :force,   type: :boolean, default: false, desc: "Overwrite existing playbooks that differ"
         option :dry_run, type: :boolean, default: false, desc: "Print what would happen without writing files"
 
-        def call(force: false, dry_run: false, **opts)
+        def call(provider: "pi", force: false, dry_run: false, **opts)
           setup_terminal(**opts.slice(:color, :colors))
           handle_errors do
-            result = AgentInstaller.install(env: project_config.env, force: force, dry_run: dry_run)
+            result = AgentInstaller.install(env: project_config.env, provider: provider,
+                                            force: force, dry_run: dry_run)
             verb = dry_run ? "Would install" : "Installed"
-            terminal.say "#{verb} role playbooks for pi → #{terminal.path(result[:dest_root])}"
+            terminal.say "#{verb} role playbooks for #{provider} → #{terminal.path(result[:dest_root])}"
             result[:agents].each do |a|
               terminal.say "  #{a[:name]}: #{terminal.style_skill_action(a[:action])} (#{terminal.path(a[:path])})"
             end
@@ -1240,32 +1244,59 @@ module Space::Architect
       # The one-shot machine install: skills (pi by default), the
       # architect-loop extension, then the role playbooks — in that order,
       # because install-agents renders from the extension the prior step just
-      # installed. Each step aborts loudly on failure; there are no partial
-      # silent states to reason about afterwards.
+      # installed. The extension step is pi-only: for tart it is skipped with
+      # one say line (tart's architect surfaces are native; the playbooks
+      # still render from the installed pi extension). Each step aborts loudly
+      # on failure; there are no partial silent states to reason about
+      # afterwards.
       class Install < BaseCommand
-        desc "Install everything for this machine: skills (--provider, default pi), the architect-loop extension, then the role playbooks"
+        desc "Install everything for this machine: skills, the architect-loop extension (pi only), then the role playbooks (--provider pi|tart, default pi)"
         phase 53, "Project"
-        option :provider, default: "pi", desc: "Skill install target (default: pi; validated by the installer; passed through to install-skills)"
+        option :provider, default: "pi", desc: "Full-stack install target: pi | tart (default: pi; skills-only providers are rejected — use install-skills for those)"
         option :force,   type: :boolean, default: false, desc: "Overwrite existing skills/playbooks that differ (passed through)"
 
         def call(provider: "pi", force: false, **opts)
           setup_terminal(**opts.slice(:color, :colors))
           handle_errors do
+            validate_install_provider!(provider)
+
             skills = SkillInstaller.install(provider, project: false, force: force,
                                              env: project_config.env)
             terminal.say "skills → #{terminal.path(skills[:dest_root])}"
             skills[:skills].each { |s| terminal.say "  #{s[:name]}: #{terminal.style_skill_action(s[:action])}" }
 
-            extensions = ExtensionInstaller.install(env: project_config.env)
-            extensions[:steps].each { |s| terminal.say "  #{s[:cmd]} (exit #{s[:exit_code]})" }
+            if provider == "tart"
+              # tart's architect surfaces are native (BRIEF §6) — no pi
+              # extension step, so no extension output at all; the playbooks
+              # below still render from the installed pi extension.
+              terminal.say "extension: skipped (tart's architect surfaces are native — no pi extension step)"
+            else
+              extensions = ExtensionInstaller.install(env: project_config.env)
+              extensions[:steps].each { |s| terminal.say "  #{s[:cmd]} (exit #{s[:exit_code]})" }
+            end
 
-            agents = AgentInstaller.install(env: project_config.env, force: force)
+            agents = AgentInstaller.install(env: project_config.env, provider: provider, force: force)
             terminal.say "role playbooks → #{terminal.path(agents[:dest_root])}"
             agents[:agents].each { |a| terminal.say "  #{a[:name]}: #{terminal.style_skill_action(a[:action])}" }
 
             CLI.record_outcome(Outcome.new(exit_code: 0))
           end
         end
+
+        private
+
+        # The one-shot is the full stack — pi or tart only. Validation runs
+        # before any step, so a rejected provider leaves zero side effects.
+        def validate_install_provider!(provider)
+          return if AgentInstaller::PROVIDERS.include?(provider.to_s)
+
+          if SkillInstaller::PROVIDERS.include?(provider.to_s)
+            raise Space::Core::Error,
+                  "#{provider} is a skills-only provider — architect install runs the full stack (skills, extension, playbooks) for pi or tart; for skills only, run: architect install-skills --provider #{provider}"
+          end
+
+          raise Space::Core::Error, "Unknown provider '#{provider}'. architect install supports: pi, tart"
+        end
       end
 
       module Routing

data/lib/space_architect/looplog.rb

@@ -3,6 +3,7 @@
 require "json"
 require "time"
 require "find"
+require_relative "loop_cost"
 
 module Space
   module Architect
@@ -31,6 +32,16 @@ module Space
     # the record's own timestamp (HH:MM:SS local) after the run tag; --list
     # shows last-activity HH:MM beside the age. Thinking text is NOT truncated —
     # set RUNLOG_THINK to clamp it if a run goes feral.
+    #
+    # [I95 loop-parity] tart records read alongside the pi roots, same
+    # rendering (B-Laws 1–4): the tart subagents home (~/.tart/subagents, run
+    # dirs identified by status.json, transcript = the newest
+    # <run>/sessions/**/*.jsonl) and the tart sessions root (~/.tart/sessions)
+    # narrowed to the space slug — agent-less session files list under the
+    # gem's existing "(session)" label (LoopCost::SESSION_AGENT). Both roots
+    # carry the gem's own reader-side env overrides (TART_SUBAGENTS_HOME /
+    # TART_SESSIONS_DIR, mirroring PI_SESSIONS_DIR's role) — not tart's
+    # identity-namespaced spawn-side keys, which belong to tart's spawner.
     module Looplog
       DEFAULT_LIMIT = 2000
       WINDOW_DEFAULT = 900 # seconds: staleness threshold
@@ -95,13 +106,165 @@ module Space
         # (agents spawned with cwd = the space) and the space's build/ tree (the
         # loop's headless --session-dir bootstraps root their whole transcript trees
         # there). Lane worktrees are the only huge subtrees under build/ — pruned.
+        # [I95 B-Law 1] the tart roots append additively; the pi roots and their
+        # scan law above are byte-stable. Dedup stays by transcript path.
         def discover(space, env)
           roots = [File.join(sessions_root(env), session_slug(space.to_s)), File.join(space.to_s, "build")]
                   .select { |root| File.directory?(root) }
                   .flat_map { |root| scan_root(root) }
+          roots += scan_tart_runs(tart_subagents_home(env), space.to_s)
+          roots += scan_tart_sessions(File.join(tart_sessions_root(env), session_slug(space.to_s)))
           roots.uniq { |t| t.path }
         end
 
+        # The gem's reader-side overrides (B-Law 1) — PI_SESSIONS_DIR's role for
+        # the tart roots. Deliberately NOT tart's identity-namespaced spawn-side
+        # keys: reading another harness's spawn env would couple the reader to
+        # its spawner law.
+        def tart_subagents_home(env)
+          env["TART_SUBAGENTS_HOME"] || File.join(Dir.home, ".tart", "subagents")
+        end
+
+        def tart_sessions_root(env)
+          env["TART_SESSIONS_DIR"] || File.join(Dir.home, ".tart", "sessions")
+        end
+
+        # [I95 B-Law 2] the run-record law: each <home>/<run-id>/ dir whose
+        # status.json parses is a run; it is IN SCOPE iff its spawn cwd is the
+        # space or under it (lane worktrees stay in scope and keep the tag_label
+        # lane-tag law via their recorded cwd). The transcript — the unit, pi-side
+        # parity — is the NEWEST <run>/sessions/**/*.jsonl; a run with no
+        # transcript is not listed. Malformed status.json or missing identity keys
+        # skip silently (discovery never raises — the pi-side discipline). The
+        # consumed keys are cwd + agent (both Strings across the real corpus; id
+        # falls back to the dir name); task may be null in real status.json files
+        # (measured: run 01a14df7-7750… carries task:null AND a real transcript),
+        # so a null/absent task tolerates to nil rather than erasing the run.
+        def scan_tart_runs(home, space)
+          return [] unless File.directory?(home)
+
+          Dir.children(home).filter_map do |entry| # paths:exempt — walks the tart subagents home's run dirs; per-run status.json discovery IS this module's contract (B-Law 2), mirroring scan_root's pi walk
+            run_dir = File.join(home, entry)
+            next unless File.directory?(run_dir)
+
+            status = tart_status(run_dir)
+            next unless status
+            next unless tart_in_space?(status["cwd"], space)
+
+            transcript, st = tart_newest_transcript(run_dir)
+            next unless transcript
+
+            run_id = status["id"].is_a?(String) ? status["id"] : entry
+            Transcript.new(transcript, run_id, status["agent"], st.mtime.to_f, st.size,
+                           status["cwd"], tart_task_line(status["task"]))
+          end
+        end
+
+        # [I95 B-Law 3] the session-record law: every *.jsonl under the tart slug
+        # dir (any depth, wt/ pruned as today) is a transcript with the gem's own
+        # agent-less label (LoopCost::SESSION_AGENT — no invented labels, no mode
+        # detection). Identity rides the line-1 session header (id, cwd); the
+        # task is the first user-message entry's first line. Malformed/empty
+        # files skip silently.
+        def scan_tart_sessions(slug_dir)
+          return [] unless File.directory?(slug_dir)
+
+          Find.find(slug_dir).filter_map do |p| # paths:exempt — any-depth discovery of the tart slug dir IS this module's contract (mirrors scan_root's pi walk)
+            if File.directory?(p)
+              Find.prune if File.basename(p) == "wt"
+              next
+            end
+            next unless p.end_with?(".jsonl")
+
+            header = tart_session_header(p)
+            next unless header
+
+            st = File.stat(p)
+            Transcript.new(p, header["id"], LoopCost::SESSION_AGENT, st.mtime.to_f, st.size,
+                           header["cwd"], tart_first_user_task(p))
+          end
+        end
+
+        def tart_status(run_dir)
+          status = JSON.parse(File.read(File.join(run_dir, "status.json")))
+          return unless status.is_a?(Hash) && status["cwd"].is_a?(String) && status["agent"].is_a?(String)
+
+          status
+        rescue JSON::ParserError, SystemCallError
+          nil
+        end
+
+        # The run's spawn cwd is the space or under it (B-Law 2) — expand BOTH
+        # sides, so a cwd or space spelled through a symlink (macOS /tmp →
+        # /private/tmp) still scopes correctly.
+        def tart_in_space?(cwd, space)
+          expanded = File.expand_path(cwd)
+          root = File.expand_path(space)
+          expanded == root || expanded.start_with?("#{root}/")
+        end
+
+        def tart_newest_transcript(run_dir)
+          Dir.glob(File.join(run_dir, "sessions", "**", "*.jsonl")) # paths:exempt — the NEWEST <run>/sessions/**/*.jsonl IS the transcript unit (B-Law 2); the recursive glob stays inside the run's own session tree
+             .filter_map do |p|
+               begin
+                 st = File.stat(p)
+                 st.file? ? [p, st] : nil
+               rescue SystemCallError
+                 nil
+               end
+             end
+             .max_by { |_, st| st.mtime }
+        end
+
+        def tart_session_header(path)
+          line = File.foreach(path).first
+          return unless line&.start_with?("{")
+
+          header = JSON.parse(line)
+          return unless header.is_a?(Hash) && header["type"] == "session" &&
+                        header["id"].is_a?(String) && header["cwd"].is_a?(String)
+
+          header
+        rescue JSON::ParserError, SystemCallError
+          nil
+        end
+
+        # Head-bounded like backscan's 64 KB window: the first user message sits
+        # at the head of real transcripts, and the bound keeps a feral file from
+        # stalling discovery.
+        def tart_first_user_task(path)
+          read = 0
+          File.open(path, "rb") do |f|
+            f.each_line do |line|
+              return nil if read > 64 * 1024
+
+              read += line.bytesize
+              next unless line.start_with?("{")
+
+              rec = begin
+                JSON.parse(line)
+              rescue JSON::ParserError
+                next
+              end
+              msg = rec["message"]
+              next unless rec["type"] == "message" && msg.is_a?(Hash) && msg["role"] == "user"
+
+              return tart_task_line(msg["content"].is_a?(String) ? msg["content"] : nil)
+            end
+          end
+          nil
+        rescue SystemCallError
+          nil
+        end
+
+        # The pi-side task clip law: first line, chomped, 110 (note_record's clip,
+        # applied to tart identities).
+        def tart_task_line(text)
+          return nil unless text.is_a?(String)
+
+          text.lines.first.to_s.chomp[0, 110]
+        end
+
         def scan_root(root)
           Find.find(root).filter_map do |p| # paths:exempt — walks the foreign pi sessions corpus and the space's build/ tree (nested session dirs included); any-depth discovery of *_transcript.jsonl IS this module's contract, mirroring the bin/looplog oracle
             if File.directory?(p)
@@ -159,6 +322,110 @@ module Space
           [cwd, task]
         end
 
+        # [I95 B-Law 4] the tart-record adapter: projects one tart session entry
+        # onto the pi record vocabulary so the ONE Renderer keeps the display
+        # law, the stamps, and the ✓/✗ lines — shared, not forked. Pi records
+        # (recordType-carriers) and foreign shapes pass through untouched, so
+        # the pi drain path is byte-stable. The tart vocabulary, measured over
+        # the real corpus: {type: session|message|custom_message}; message
+        # entries carry {role: user|assistant|tool, content: String} with
+        # assistant extras tool_calls (a Hash keyed by call id, values
+        # {id, name, arguments: Hash}), thinking (String), flat usage keys, and
+        # finish_reason ∈ tool_calls|stop|length|error.
+        def adapt_record(rec)
+          return [rec] unless rec.is_a?(Hash) && rec["recordType"].nil?
+
+          case rec["type"]
+          when "session"        then []   # header record: identity, not display
+          when "custom_message" then []   # wake/notify echoes: pi's system/custom law
+          when "message"        then tart_message_records(rec)
+          else [rec]                      # foreign vocabulary: the renderer's else-arm
+          end
+        end
+
+        def tart_message_records(rec)
+          msg = rec["message"]
+          return [] unless msg.is_a?(Hash)
+
+          ts = tart_ts(rec)
+          case msg["role"]
+          when "user"
+            # The exchange opener: no display of its own, exactly like pi's.
+            [{ "recordType" => "message", "role" => "user", "ts" => ts }]
+          when "assistant"
+            [tart_assistant_record(msg, ts)] + tart_tool_starts(msg, ts)
+          when "tool"
+            # Tart records carry no error flag — isError false (the ✗ arm stays
+            # pi-only; a tart error surfaces through finish_reason instead).
+            [{ "recordType" => "message", "role" => "toolResult", "text" => msg["content"].to_s,
+               "isError" => false, "ts" => ts }]
+          else # legacy/system roles (bashExecution, …): everything of interest shows elsewhere
+            []
+          end
+        end
+
+        # Block order is the shared display law's order (thinking dim, then the
+        # text, then the tool calls) — the real chronology of one assistant turn.
+        def tart_assistant_record(msg, ts)
+          blocks = []
+          thinking = msg["thinking"]
+          blocks << { "type" => "thinking", "thinking" => thinking } if thinking.is_a?(String) && !thinking.empty?
+          content = msg["content"]
+          blocks << { "type" => "text", "text" => content } if content.is_a?(String) && !content.empty?
+          tart_tool_calls(msg).each do |call|
+            blocks << { "type" => "toolCall", "id" => call["id"], "name" => call["name"],
+                        "arguments" => call["arguments"] }
+          end
+          {
+            "recordType" => "message", "role" => "assistant", "ts" => ts,
+            "stopReason" => tart_stop_reason(msg["finish_reason"]),
+            # Usage maps output_tokens→output, cache_write_tokens→the cache slot
+            # (B-Law 4); tart's cache_read_tokens is deliberately NOT mapped —
+            # no fabricated numbers. Cost is never fabricated.
+            "usage" => { "output" => msg["output_tokens"], "cacheRead" => msg["cache_write_tokens"] },
+            "message" => { "content" => blocks }
+          }
+        end
+
+        # tool_calls is a Hash keyed by call id across the real corpus (597/597);
+        # an Array of entries is tolerated defensively, anything else is absence.
+        def tart_tool_calls(msg)
+          calls = msg["tool_calls"]
+          entries = calls.is_a?(Hash) ? calls.each_value : calls.is_a?(Array) ? calls : []
+          entries.select { |call| call.is_a?(Hash) && call["name"] }
+        end
+
+        # The harness re-emits canonical args on tool_start in pi — the adapter
+        # synthesizes that record here, so the one-lined ⚒ law renders exactly
+        # as pi's (arguments are JSON-roundtripped values, so generate is safe).
+        def tart_tool_starts(msg, ts)
+          tart_tool_calls(msg).map do |call|
+            { "recordType" => "tool_start", "toolName" => call["name"].to_s,
+              "argsPayload" => JSON.generate(call["arguments"]), "ts" => ts }
+          end
+        end
+
+        # finish_reason → pi stopReason vocabulary (B-Law 4): the two shared
+        # semantics map, everything else — length, error, nil — passes verbatim
+        # ("error" keys the shared ✗ failed arm; "length" still closes with ✓).
+        def tart_stop_reason(finish_reason)
+          case finish_reason
+          when "tool_calls" then "toolUse"
+          when "stop"       then "end_turn"
+          else finish_reason
+          end
+        end
+
+        # The entry timestamp (ISO) carries the record stamp law unchanged, as
+        # epoch-ms so the shared exchange arithmetic (elapsed) works unchanged.
+        def tart_ts(rec)
+          return unless rec["timestamp"].is_a?(String)
+
+          Time.parse(rec["timestamp"]).to_f * 1000
+        rescue ArgumentError
+          nil
+        end
+
         # [architect-builder:67-core] when cwd is a lane worktree — the full
         # agent name plus the iteration ordinal and the lane name, resolved
         # against the space's known iteration ids (architecture/I<NN>-<name>.md)
@@ -351,7 +618,7 @@ module Space
             discover(@space, @env).sort_by { |t| -t.mtime }.each do |t|
               age_min = (now - t.mtime) / 60
               active = (now - t.mtime) < @window
-              cwd, task = backscan(t.path)
+              cwd, task = record_meta(t)
               @io.puts format("%s %-9s %5s %5.0fm %7sK  %s  %s",
                               active ? green("●") : dim("·"),
                               tag_label(t.agent, cwd, iteration_ids: iteration_ids),
@@ -387,8 +654,14 @@ module Space
             rescue JSON::ParserError
               next
             end
-            run.stamp = stamp_for(rec)
-            emit(run, run.renderer.render(rec))
+            # [I95 B-Law 4] one tart entry projects to several records (the
+            # message plus its synthesized tool starts); all share the entry's
+            # stamp, taken from the projected record so the epoch-ms arm of the
+            # unchanged stamp law renders tart rows local exactly like pi rows.
+            # Pi lines pass through as the single-element array — same bytes.
+            projected = adapt_record(rec)
+            run.stamp = stamp_for(projected.first || rec)
+            projected.each { |pi_rec| emit(run, run.renderer.render(pi_rec)) }
           end
         end
 
@@ -403,8 +676,17 @@ module Space
                                .map { |p| File.basename(p, ".md") }
         end
 
-        def adopt(t)
+        # [I95 B-Laws 2–3] tart transcripts carry identity on the record itself
+        # (the run's status.json / the session header); pi transcripts are
+        # backscanned. A nil tart slot falls through to the backscan, so a
+        # headerless tart file still shows a derived cwd.
+        def record_meta(t)
           cwd, task = backscan(t.path)
+          [t.cwd || cwd, t.task || task]
+        end
+
+        def adopt(t)
+          cwd, task = record_meta(t)
           tag = paint_tag(tag_label(t.agent, cwd, iteration_ids: iteration_ids), t.run_id)
           run = Run.new(t.path, t.run_id, t.agent, tag,
                         Renderer.new(limit: @limit, think_limit: @env["RUNLOG_THINK"]&.to_i, color: @color),

data/lib/space_architect/skill_installer.rb

@@ -6,7 +6,7 @@ require "pathname"
 module Space
   module Architect
     module SkillInstaller
-      PROVIDERS = %w[claude codex opencode pi].freeze
+      PROVIDERS = %w[claude codex opencode pi tart].freeze
 
       class << self
         def source_root
@@ -26,6 +26,9 @@ module Space
           when "pi"
             base = project ? Pathname.new(cwd) : Pathname.new(pi_agent_dir(env: env))
             base.join("skills")
+          when "tart"
+            base = project ? Pathname.new(cwd) : Pathname.new(Space::Core::XDG.home(env: env))
+            base.join(".tart", "skills")
           else
             raise Space::Core::Error, "Unknown provider '#{provider}'. Expected one of: #{PROVIDERS.join(', ')}"
           end

data/lib/space_architect/version.rb

@@ -2,6 +2,6 @@
 
 module Space
   module Architect
-    VERSION = "9.9.0"
+    VERSION = "9.9.2"
   end
 end

data/skill/architect-action/SKILL.md

@@ -89,11 +89,12 @@ human again until the loop needs them.
    a user command in the interactive session, and the human has disengaged.
    The launch is yours, and the tool is your equivalent of `/loop`: call
    `architect_loop` with `from` = the plan file path. The tool installs the
-   driver playbook into THIS session as operating instructions and schedules
-   the entry compaction — after which this session IS the loop driver: it
-   spawns and tends spec → builders → judge itself, one hop from the human.
-   Pass `compact: false` only if the human asks to keep full context. An
-   older extension without the driver-mode `architect_loop` is updated via
+   driver playbook into THIS session as operating instructions — and driving
+   starts in this same turn: the session spawns and tends spec → builders →
+   judge itself, one hop from the human. It compacts only after its first
+   child launch (`architect_compact`, never before — a compaction with no
+   child in flight aborts the turn with no wake source, and the loop stalls).
+   An older extension without the driver-mode `architect_loop` is updated via
    `architect install-extensions` — never spawned around.
 7. **Report the launch, then drive.** Tell the human: the plan path and how
    to watch — `architect looplog` (live), `--list` (inventory), `architect

data/skill/architect-discuss/SKILL.md

@@ -79,8 +79,8 @@ exception path — a loop that needs you and can't reach you does not
 improvise; it parks the facts and terminates. Exception reports
 (`notes/exception-<ts>.md`) and completion reports (`notes/report-<ts>.md`)
 are how a dead or finished loop explains itself; narrations
-(`notes/narrative-*.md`) are best-effort updates in between. Read them
-before resuming anything.
+(`notes/narrative-*.md`) are the rare prose refreshes — verdict-landed,
+exception, plan-complete. Read them before resuming anything.
 
 ## Ground rules
 

data/skill/architect-status/SKILL.md

@@ -39,7 +39,7 @@ tool result from this session — no recall, no conversation-only claims.
    - **Loop:** live or not; if live, which plan, which role runs are in
      flight and their ages; if not, when the last one settled and how it
      ended (report/exception).
-   - **Last settled event:** from the newest narrative — one line of fact.
+   - **Newest narrative:** what it records — one line of fact.
    - **Waiting on the human:** any escalation or exception note that parks
      a decision.
    - **Next:** what the plan or ARCHITECT.md says comes next.

metadata

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