space-architect 9.2.1 → 9.4.0

data/lib/space_architect/space_push.rb

@@ -1,274 +0,0 @@
-# frozen_string_literal: true
-
-require "zlib"
-require "tempfile"
-require "json"
-require "async/http/client"
-require "async/http/endpoint"
-require "protocol/http/body/readable"
-
-module Space::Architect
-  # Gem-side sender for the space-server import mouth: packs the current space
-  # into a gzipped tar and POSTs it to <host>/spaces/import
-  # (Content-Type: application/gzip, Bearer auth). A 200 response is the
-  # server's import summary {id:, slug:, iterations:, artifacts:, runs:};
-  # any non-200 raises Space::Core::Error carrying the server's error body.
-  class SpacePush
-    IMPORT_PATH  = "/spaces/import"
-    CONTENT_TYPE = "application/gzip"
-
-    def initialize(host, token, client: nil)
-      @host   = host.chomp("/")
-      @token  = token
-      @client = client
-    end
-
-    # POSTs a packed bundle (a gzip tar path) per the frozen import contract
-    # and returns the parsed summary hash. Raises Space::Core::Error on any
-    # non-200 — the CLI's handle_errors turns that into a stderr message and
-    # a nonzero exit.
-    def push(bundle_path)
-      Sync do
-        with_client do |c|
-          body = file_body(bundle_path)
-          begin
-            response = c.post(IMPORT_PATH, headers: headers, body: body)
-            parse_response(response)
-          ensure
-            body.close
-          end
-        end
-      end
-    rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::ENETUNREACH, SocketError => e
-      raise Space::Core::Error, "POST #{IMPORT_PATH} failed: #{e.message} (host: #{@host})"
-    end
-
-    private
-
-    def with_client
-      if @client
-        yield @client
-      else
-        Async::HTTP::Client.open(Async::HTTP::Endpoint.parse(@host)) { |c| yield c }
-      end
-    end
-
-    def headers
-      [
-        ["authorization", "Bearer #{@token}"],
-        ["content-type",  CONTENT_TYPE]
-      ]
-    end
-
-    # Streams the bundle off disk — the bundle is never slurped into memory.
-    # StreamBody's length drives the content-length on the wire (HTTP/1) and
-    # the HTTP/2 pseudo-header, so it must not also be set as a header.
-    def file_body(bundle_path)
-      StreamBody.new(File.open(bundle_path, "rb"), File.size(bundle_path))
-    end
-
-    def parse_response(response)
-      status = response.status
-      body   = response.read || ""
-      raise Space::Core::Error, "POST #{IMPORT_PATH} failed (#{status}): #{body[0, 200]}" unless status == 200
-
-      JSON.parse(body)
-    end
-
-    # A Protocol::HTTP body that lazily reads chunks off an IO, so the HTTP
-    # client streams the request body while the bundle stays on disk.
-    class StreamBody < Protocol::HTTP::Body::Readable
-      CHUNK_SIZE = 64 * 1024
-
-      def initialize(io, length)
-        @io     = io
-        @length = length
-      end
-
-      attr :length
-
-      def read
-        @io.read(CHUNK_SIZE)
-      end
-
-      def close(error = nil)
-        @io.close unless @io.closed?
-        super
-      end
-    end
-
-    # Packs a space into a gzipped tar on disk, streaming — neither the tar
-    # nor the space's files are held in memory.
-    #
-    # Bundle cut (correctness-critical): EXCLUDE repos/, the lanes' worktrees
-    # at build/<id>-<lane>/wt, tmp/, node_modules/ anywhere, .pi/, and *.log
-    # files. INCLUDE everything else — the importer's read set is space.yaml,
-    # .git/ (history carries iteration timestamps), architecture/, notes/,
-    # and build/<id>-<lane>/{prompt,report}.md + run.jsonl.
-    class Packer
-      BLOCK_SIZE     = 512
-      PRUNED_DIRS    = %w[repos tmp .pi node_modules]
-      WORKTREE_MATCH = %r{\Abuild/[^/]+/wt\z}
-
-      Entry = Struct.new(:name, :path, :type)
-
-      def initialize(root)
-        @root = root.to_s
-      end
-
-      # Streams the space into a fresh tmpfile and returns its path. The
-      # caller owns the tmpfile (unlink it when done).
-      def pack
-        tmp = Tempfile.create(["architect-push", ".tar.gz"])
-        tmp.binmode
-        Zlib::GzipWriter.wrap(tmp) do |gz|
-          writer = TarWriter.new(gz)
-          walk { |entry| add(writer, entry) }
-          writer.finish
-        end
-        tmp.close
-        tmp.path
-      rescue
-        tmp.close
-        File.unlink(tmp.path) rescue nil
-        raise
-      end
-
-      private
-
-      def add(writer, entry)
-        if entry.type == :dir
-          writer.write_dir(entry.name, mtime: File.mtime(entry.path))
-        else
-          writer.write_file(entry.path, entry.name,
-            mode: File.stat(entry.path).mode & 0o7777, mtime: File.mtime(entry.path))
-        end
-      end
-
-      def walk(&)
-        walk_dir("", &)
-      end
-
-      def walk_dir(rel, &)
-        dir = rel.empty? ? @root : File.join(@root, rel)
-        Dir.children(dir).sort.each do |name| # paths:exempt — the dotfile-inclusive walk is deliberate (.git must ship); pruned subtrees (repos/, worktrees) are skipped before descending, so their bulk is never enumerated and the walk streams
-          child = rel.empty? ? name : "#{rel}/#{name}"
-          abs   = File.join(@root, child)
-          stat  = File.lstat(abs)
-
-          if stat.directory?
-            next if pruned?(child)
-
-            yield Entry.new("#{child}/", abs, :dir)
-            walk_dir(child, &)
-          elsif stat.file?
-            next if child.end_with?(".log")
-
-            yield Entry.new(child, abs, :file)
-          end
-          # Symlinks and other oddities are skipped: the bundle carries regular
-          # files and directories only, so it stays traversal-proof.
-        end
-      end
-
-      def pruned?(rel)
-        PRUNED_DIRS.include?(File.basename(rel)) || WORKTREE_MATCH.match?(rel)
-      end
-
-      # Minimal ustar writer — stdlib only, the Gemfile carries no tar gem.
-      # Regular files and directories; file contents stream 512-byte-aligned.
-      # Names longer than 100 bytes split across the ustar prefix field.
-      class TarWriter
-        BLOCK_SIZE = 512
-        TYPE_FILE  = "0"
-        TYPE_DIR   = "5"
-
-        def initialize(io)
-          @io = io
-        end
-
-        def write_dir(name, mtime:)
-          write_header(name, mode: 0o755, mtime: mtime, size: 0, type: TYPE_DIR)
-        end
-
-        def write_file(path, name, mode:, mtime:)
-          size = File.size(path)
-          write_header(name, mode: mode, mtime: mtime, size: size, type: TYPE_FILE)
-          IO.copy_stream(path, @io)
-          pad = (BLOCK_SIZE - (size % BLOCK_SIZE)) % BLOCK_SIZE
-          @io.write("\0" * pad) unless pad.zero?
-        end
-
-        # Two zero blocks terminate the archive.
-        def finish
-          @io.write("\0" * (BLOCK_SIZE * 2))
-        end
-
-        private
-
-        def write_header(name, mode:, mtime:, size:, type:)
-          name = name.b
-          split = split_name(name)
-          if split
-            base, prefix = split
-          else
-            # Not representable via the ustar prefix field — fall back to a
-            # GNU 'L' long-name entry, which every mainstream reader honors.
-            write_long_name(name)
-            base, prefix = name[0, 100], nil
-          end
-
-          header = String.new(encoding: Encoding::BINARY)
-          header << base.ljust(100, "\0")
-          header << octal(mode, 8)
-          header << octal(0, 8)          # uid — the bundle is anonymous
-          header << octal(0, 8)          # gid
-          header << octal(size, 12)
-          header << octal(mtime.to_i, 12)
-          header << " " * 8              # checksum placeholder
-          header << type
-          header << "\0" * 100           # linkname
-          header << "ustar\0"            # magic
-          header << "00"                 # version
-          header << "\0" * 32            # uname
-          header << "\0" * 32            # gname
-          header << "\0" * 8             # devmajor
-          header << "\0" * 8             # devminor
-          header << (prefix || "").ljust(155, "\0")
-          header << "\0" * (BLOCK_SIZE - header.bytesize)
-          raise "tar header overflow: #{name}" if header.bytesize != BLOCK_SIZE
-
-          header[148, 8] = format("%06o\0 ", header.sum)
-          @io.write(header)
-        end
-
-        # GNU 'L' long-name entry: the full name NUL-terminated as the entry
-        # body, then the real header carrying the name's first 100 bytes.
-        def write_long_name(name)
-          content = "#{name}\0"
-          write_header("././@LongLink", mode: 0o644, mtime: Time.now, size: content.bytesize, type: "L")
-          @io.write(content)
-          pad = (BLOCK_SIZE - (content.bytesize % BLOCK_SIZE)) % BLOCK_SIZE
-          @io.write("\0" * pad) unless pad.zero?
-        end
-
-        # [base, prefix] split across the ustar name (100) and prefix (155)
-        # fields at a "/" boundary, or nil when the name cannot be split and
-        # needs a GNU long-name entry.
-        def split_name(name)
-          return [name, nil] if name.bytesize <= 100
-
-          min_cut = [name.bytesize - 101, 0].max # the name field must fit in 100 bytes
-          cut = name.index("/", min_cut)
-          return nil if cut.nil? || cut > 155
-
-          [name[(cut + 1)..], name[0, cut]]
-        end
-
-        def octal(value, width)
-          format("%0#{width - 1}o\0", value)
-        end
-      end
-    end
-  end
-end

data/skill/architect-plan/SKILL.md

@@ -1,114 +0,0 @@
----
-name: architect-plan
-description: "Plan work for the architect loop and launch it as an autonomous coordinator run (/loop). Use when the user's intention is to START a loop: planning iterations, writing the plan doc (notes/plan-*.md), pinning role routing, launching the coordinator, and watching it run. For general architecture work without launching a loop (arbitration, judging, landing, iteration surgery, conversation), use /architect instead."
----
-
-# Architect Plan
-
-You are the ARCHITECT planning a coordinator run. The deliverable of this
-skill is exactly one thing: a committed plan doc and a launched coordinator.
-The loop's roles (spec → builders → judge, driven by the coordinator) do
-everything after that — you never absorb a builder wakeup.
-
-Read `/architect` (the main skill) first for roles, routing, and the hard
-rules. This skill covers only the start.
-
-## Procedure
-
-1. **Ground (never skip).**
-   - `architect status` — iteration/verdict state; anything in flight?
-   - `architect looplog --list` — is a loop already running? Fresh transcripts
-     mean a live loop: don't double-start; report and ask.
-   - Read `architecture/ARCHITECT.md` (TOC + backlog), `architecture/BRIEF.md`
-     (the durable §-contract — cite it as BRIEF §N), the in-flight iteration
-     file if any, and the latest `notes/spec-digest-*.md` (the previous spec's
-     handoff: verification commands actually used, repo seams, house
-     conventions, open unknowns — carry its facts forward or they are lost).
-   - Read the target repo's `AGENTS.md`/`CLAUDE.md` → `README.md` → docs;
-     confirm the exact verification gate command.
-   - Learn the verification gate (test/lint/typecheck/build) from docs or CI
-     config — the plan's acceptance direction must name it.
-2. **Scale the work.** Trivial fixes don't need the loop — say so and do it
-   inline. One PR-sized iteration = one ENTRY. Multi-iteration plans get
-   ordered ENTRYs (the coordinator works them in order, skipping finished
-   ones). If the open question is too uncertain to build, make the ENTRY a
-   spike (investigate-only; deliverable is a recommendation — see /architect).
-3. **Write the plan doc** to `notes/plan-<UTC timestamp>-<name>.md`:
-
-   ```markdown
-   # Plan — <name> (<one line>)
-
-   Operator plan <date>. <Repos/lanes in scope.>
-
-   Standing context the spec needs: prior iterations this builds on, routing
-   pins, and the post-landing follow-ups (outside-the-loop work the plan
-   deliberately excludes — name it so it isn't lost).
-
-   ## ENTRY N — iteration <name> (repo: <repo>, <lane count> lane(s))
-
-   **Objective.** What to build and why — the reason, not just the ask. Cite
-   BRIEF §N. If this ENTRY pins model/thinking for a role, say it here (the
-   coordinator passes it in that spawn's model field).
-
-   **Grounds to read.** Exact paths: research/bug reports, source files being
-   ported, seam files, prior verdicts. The spec reads these before writing a
-   word.
-
-   **Acceptance direction (spec refines into frozen AC).** The properties the
-   finished iteration must have — at the level the spec can freeze, not
-   pre-written gates (freezing is the spec's job).
-
-   **Constraints.** Repos; files that must not change; out-of-scope;
-   house-style expectations; what the lane must NOT delete or move (say so
-   when a port is replacing something that lives elsewhere).
-   ```
-
-   Each ENTRY must be self-contained — the spec agent receives the entry
-   verbatim and nothing else. Put the verification gate command in ENTRY
-   constraints or grounds.
-4. **Pin routing if needed.** This plan's models come from `architect.yaml`
-   (space root overrides `~/.config/space-architect/architect.yaml` per role).
-   A one-plan pin goes in the plan header/ENTRY (the coordinator passes it in
-   that spawn's model field); a standing change edits `architect.yaml` —
-   routing rides the spawn contract and `/loop` resolves it at launch, so
-   there are no generated agent files to hand-sync (the role playbooks are
-   static, user-level, installed once by `architect install-agents`).
-5. **Commit the plan doc** to the space — an uncommitted plan is scratch, and
-   decision-bearing documents live in `notes/` (not-committed = didn't
-   happen).
-6. **Launch.** From an interactive pi session at the space root:
-
-   ```
-   /loop --from notes/plan-<ts>-<name>.md
-   ```
-
-   `/loop` refuses an empty plan, resolves the routing config (validates
-   every pin against the model registry — a pin it doesn't know throws
-   loudly, before any spawn — and injects the per-role pins into the
-   coordinator's task), and spawns `architect-coordinator` detached — your
-   session may end; the coordinator (12h ceiling) works the plan, narrating
-   every settled event to `notes/narrative-*.md`. If pi-subagents' RPC is not
-   up in the session, /loop says so — spawn the coordinator directly instead
-   (agent `architect-coordinator`, the space as cwd, the plan text verbatim as
-   the task, the coordinator's model pin from `architect.yaml`, `timeoutMs`
-   43200000).
-7. **Report the handoff, then stop.** Tell the human: the plan path, the
-   coordinator run id, and how to watch —
-   `architect looplog` (live), `--list` (inventory),
-   `architect status`, `architect cost`. Escalations route through the
-   coordinator to your supervisor seat: rule and the coordinator steers; if
-   your session won't stay alive, say so — a coordinator with no listener
-   parks the question in `notes/escalation-<ts>.md` and stops via the exception
-   path rather than improvising.
-
-## Failure modes to check before launching
-
-- **Frozen-region edits** — never edit `architecture/` directly; the plan
-  steers, the spec writes sections via the CLI.
-- **Stale base** — outside-the-loop commits that landed on a repo's main since
-  the last provision are fine (`architect provision` fast-forward-syncs
-  `project/<slug>` from the default branch or refuses loudly on divergence);
-  a deliberately diverged integration branch must be named in the plan.
-- **Stale gem / extension** — if the plan exercises CLI behavior newer than
-  the installed gem, note the rebuild in standing context: a config that
-  moved ahead of the installed CLI rejects every command.

data/skill/architect-vocabulary/SKILL.md

@@ -1,144 +0,0 @@
----
-name: architect-vocabulary
-description: >
-  Load the Architect system's vocabulary and a short "where you are"
-  orientation — space, project, iteration, lane, brief, builder, architect,
-  gate, freeze, verdict, research, variant set — for when you're standing in a
-  space-architect workspace (or working on the skill itself) and need the terms
-  understood in conversation but do NOT want to run the loop. Reference only:
-  it does not dispatch builders, freeze, judge, or write iteration files.
-  Invoke as /architect-vocabulary.
----
-
-# Architect Vocabulary
-
-This skill loads **terminology and orientation only**. It is the glossary, not
-the loop.
-
-## What this skill is — and isn't
-
-- **Is:** the shared vocabulary of `space-architect` plus a quick orientation to
-  where things live, so these terms are understood for the rest of the session.
-- **Isn't:** the build loop. Do **not** run `architect new` / `freeze` /
-  `dispatch` / `integrate`, do **not** write or edit anything under
-  `architecture/`, and do **not** render verdicts on builder work. That is the
-  separate **`/architect`** skill — invoke it deliberately when you actually
-  want to run the loop. Read-only `architect` commands (`status`, `show`) are
-  fine here.
-
-## Vocabulary
-
-**Roles**
-
-- **architect** — the judgment role (a strong reasoning model, or a human, in
-  judgment mode): arbitrates disagreements, writes and freezes iteration files,
-  calls kill/continue, merges builder output. Never writes implementation code.
-- **builder** — the implementation role: a cheaper model run headless via
-  `architect dispatch` (reference harness: `pi -p`), one per lane in its own
-  worktree. Reports
-  raw evidence; never grades its own work; never edits `architecture/`.
-
-**The workspace**
-
-- **space** — a task-scoped workspace directory holding repos, notes, and
-  artifacts under one root. `architect` finds it by walking up from `$PWD` to the
-  nearest `space.yaml`.
-- **space.yaml** — the space's identity file: id, title, status, repos, notes,
-  tags, plus the `project:` block (project state — iterations, freeze shas,
-  lanes).
-- **project** — an Architect Loop instance living inside a space; spans the
-  repos under `repos/`.
-
-**The unit of work**
-
-- **iteration** — one PR-sized unit of work, captured as a single self-contained
-  file `architecture/I<NN>-<name>.md`, grown section by section. Its sections:
-  - **Grounds** — *why*: research/brief distilled (optional).
-  - **Specification** — *what/how*: the full delegation contract.
-  - **Acceptance Criteria** — *proof*: prose conditions (AC1, AC2, …) the
-    architect judges against, plus a fenced ` ```gates ` block of runnable checks;
-    this is what gets frozen.
-  - **Builder Prompt** — the exact lane-prompt(s) dispatched.
-  - **Builder Report** — raw evidence, transcribed verbatim from build scratch.
-  - **Verdict** — rulings + per-AC PASS/FAIL/INVALID + KILL/CONTINUE.
-- **lane** — a parallel slice of an iteration (1–4 per iteration), each
-  declaring a disjoint target repo + file-touch set. Lanes in different repos are
-  inherently disjoint; same-repo lanes that overlap files run as one. Each runs
-  in its own worktree under `build/<id>-<lane>/`.
-- **worktree** — the isolated git worktree a lane builds in, off the target
-  repo's base commit, so lanes never collide.
-- **dispatch** — launching a fresh headless builder for a lane (`architect
-  dispatch <iteration> <lane>`), streaming output to `build/<id>-<lane>/run.jsonl`.
-
-**Contracts and checkpoints**
-
-- **brief** (`architecture/BRIEF.md`) — the durable, §-numbered project contract
-  that spans iterations; frozen at the project level and cited as **BRIEF §N**.
-- **ARCHITECT.md** (`architecture/ARCHITECT.md`) — the cross-iteration index /
-  table of contents and project-wide state.
-- **freeze** ❄️ — committing the frozen region (Grounds / Specification /
-  Acceptance Criteria) *before* dispatch (`architect freeze`). Records the
-  **freeze_sha** in `space.yaml`; any later change to those sections is an
-  automatic iteration FAIL.
-- **gate** — a structured entry in the ` ```gates ` block: `id`, `ac`, `cmd`,
-  optional `cwd`, and an `expect` hash (exit_code / stdout_match / threshold).
-  `architect gate` runs each gate's `cmd` and streams raw output — it is a runner,
-  never a judge. `architect freeze` lints the gates block before committing.
-
-**Outcomes**
-
-- **verdict** — the architect's ruling on an iteration, written after evidence:
-  - per-criterion: **PASS** / **FAIL** / **INVALID** (INVALID = not measured the
-    way the gate specifies).
-  - iteration-level: **KILL** / **CONTINUE**.
-- **variant set** — an iteration built as multiple `(harness, model)` lanes over
-  one frozen spec, judged head-to-head against the same Acceptance Criteria; the
-  winner is selected with the human in the loop, not unilaterally.
-
-**Research**
-
-- **research** — two scales:
-  - **discovery scale** (brainstorming, technology selection, state-of-the-art)
-    → the **`/architect-research`** skill: a scout maps the topic, the
-    orchestrator designs parallel researcher **lanes**, claims are verified
-    against sources, and the synthesis distills into a brief §section or an
-    iteration's Grounds.
-  - **iteration scale** → an inline fan-out run only when an iteration needs
-    facts the repo doesn't already have.
-
-**Repos**
-
-- **evergreen** / copy-on-write / **`src` engine** — repo provisioning: when an
-  up-to-date local copy exists under `src_dir`, `architect` copies it into
-  the space (copy-on-write on APFS) instead of cloning over the network. The
-  `src` engine (`space-src`) keeps those evergreen checkouts tended.
-
-## Where you are
-
-A space's directory layout:
-
-```text
-space.yaml        # identity + project state (the project: block)
-README.md
-repos/            # the repos the project spans
-notes/            # scratch, prompts, logs
-architecture/     # ARCHITECT.md index + I<NN>-<name>.md iteration files (+ BRIEF.md)
-build/            # lane worktrees + scratch: build/<id>-<lane>/
-tmp/              # workspace-local temp — use instead of /tmp
-```
-
-Safe **read-only** commands to orient yourself (these don't run the loop):
-
-```sh
-architect status            # project state: iterations, freeze shas, lanes, verdicts
-space show                  # the space you're standing in (space-cadet binary)
-space list                  # all your spaces
-```
-
-## Maintenance
-
-This glossary is a **self-contained copy** of terms defined canonically in the
-`architect` skill (`SKILL.md`) and the project `README.md`. It is installed as an
-isolated skill, so it can't reference those at runtime — when the vocabulary
-changes there, re-read this file against them and update it to keep the two from
-drifting.