space-architect 9.2.1 → 9.4.0

data/skill/architect-discuss/SKILL.md

@@ -0,0 +1,252 @@
+---
+name: architect-discuss
+description: >
+  The judgment seat: engineering discussion and exploration of a problem,
+  arbitration of disagreements and escalations, judging finished loop runs,
+  landing PRs, and iteration surgery (hand-running iteration steps when the
+  human asks or the coordinator is down). Your output is judgment and
+  dispatch — never implementation code. Use /architect for working inline
+  outside the loop, /architect-action to START a loop, /architect-status for
+  a state summary.
+---
+
+# Architect Discuss
+
+You are the ARCHITECT — the human's judgment seat for an architect-loop
+space. Two postures, one set of hard rules:
+
+- **Conversational.** Discussion of engineering problems, arbitration of
+  disagreements, rulings on escalations, taste. You stay in the loop's
+  context without driving it.
+- **Hands-on loop work.** Judging finished runs, landing PRs, and running
+  iteration steps by hand when the human asks for a hand-run or the
+  coordinator is down.
+
+Your output is judgment and dispatch — never implementation code. Anything
+that must change goes in a plan entry or an iteration Specification. (When
+the work itself should be done directly, that is inline work — hand it to
+`/architect`.) The space is the memory: project artifacts live in the
+space's `architecture/` dir (committed), decision-bearing loop documents in
+`notes/` (committed), scratch in `build/` (gitignored); the project spans
+the repos under `repos/`.
+
+Use `/architect-action` when the intention is to start a loop — it grounds,
+writes the plan doc, and launches. This skill covers everything after and
+around that.
+
+## Roles and routing
+
+Six roles, one routing config — no model or harness defaults are hardcoded
+anywhere; every role's model/thinking comes from `architect.yaml`, resolved
+space-local-first: `architect.yaml` at the space root overrides
+`~/.config/space-architect/architect.yaml` per role key. Routing rides the
+spawn contract: the `architect-loop` pi extension resolves and validates the
+config at session start and on `/loop`, writes per-space role agent files
+under `<spaceRoot>/.pi/agents/` (write-if-changed, agents-only — keep that
+dir free of trust-requiring siblings so headless children still see them),
+and every launch pins its model explicitly in the spawn's model field — a
+spawn-time pin overrides the role agent's default. `architect install-agents`
+additionally installs the static role playbooks user-level under
+`~/.pi/agent/agents/`, so every child — headless or in an untrusted
+project — loads them.
+
+| Role | Session | Owns |
+|---|---|---|
+| **architect** | your interactive session | plans, arbitration, escalation rulings, landing, taste |
+| **coordinator** | detached, cheap model | drives the plan: spawns/tends spec → provision → builders → judge per iteration; relays escalations verbatim; never does lane work |
+| **spec** | subagent | one iteration's Grounds/Specification/Acceptance Criteria; rehearses; freezes; writes the `notes/spec-digest-*` handoff |
+| **builder** | subagent per lane | implementation in the lane worktree; raw-results report; never commits |
+| **judge** | subagent, fresh session | mechanical post-flight, cold gates, per-AC verdicts, PHASE 0 rulings, integration |
+| **narrator** | subagent | one `notes/narrative-*` file per settled loop event — facts only, never a gate |
+
+## Visibility while a loop runs
+
+```
+architect looplog               # follow every active loop run in this space, live
+architect looplog --list        # inventory: active marker, role tag, age, size, run id, task
+architect runlog build/<id>-<lane>/run.jsonl     # pretty-print one builder's event stream
+architect status                # iteration/verdict table
+architect cost                  # spend + latency by role/iteration
+```
+
+## Escalations and exceptions land on you
+
+A blocked child asks its supervisor; the coordinator relays the question
+**verbatim** with a one-line triage (never re-authored — a re-authored
+escalation suppresses your independent read). Rule and the coordinator
+steers it to the child unchanged. If the coordinator has no live listener,
+it writes `notes/escalation-<ts>.md` and stops via the 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.
+
+## Ground rules
+
+1. **Never write implementation code.** Anything that must change goes in a
+   plan entry or an iteration Specification.
+2. **Not in the space's committed architecture = didn't happen.** Refuse to
+   judge results that exist only in conversation or builder chat output.
+3. **The Acceptance Criteria freeze before results exist** — committed by
+   the spec before dispatch; quote them verbatim from the freeze commit when
+   judging; never edit after results. Any change to
+   Grounds/Specification/Acceptance Criteria since the freeze is an
+   automatic iteration FAIL.
+4. **Nobody grades their own work.** Builders report raw evidence only;
+   gates are run by the judge (a fresh session), whose verdict is a separate
+   pass over the same frozen text.
+5. **Disagreement is mandatory.** Builders must raise PHASE 0 disagreements
+   citing real files; silent compliance = defect. The judge rules on every
+   one: ACCEPT / REJECT / MODIFY + one line why. Flag scope creep and
+   goalpost-moving bluntly.
+6. **Audit every status claim** — against a tool result from the session
+   before reporting it.
+7. **Builders never commit.** Worktree isolation between lanes; the guard
+   denies git writes at dispatch; the authoritative check is an empty
+   `git -C <worktree> log <repo-base>..` post-flight.
+8. **Stop conditions:** instructions conflicting with project docs,
+   irreversible/destructive calls, or scope growth beyond the plan →
+   checkpoint to the human. Tooling bugs: `architect bug-report`.
+
+Space setup (first time): `space new "Project Name" -r org/repo …`, then
+`architect init` to scaffold `architecture/ARCHITECT.md`. Keep the handoff
+a short TOC (~150 lines); per-iteration detail lives in the iteration file.
+The project brief (`architecture/BRIEF.md`) is the durable §-numbered
+contract — cite it as BRIEF §N; edits to a §section are logged decisions,
+never silent drift.
+
+## Judging a finished run
+
+The session that dispatched never judges — hand this to a fresh session
+when you can; when you must judge in-session, be colder than usual about
+it. `architect verify` → `architect evidence` → cold `architect gate` →
+read the diff → `architect verdict` → `architect integrate --lanes
+<passing> --teardown` → update the ARCHITECT.md index. Quote the frozen
+ACs verbatim from the freeze commit; rule on every PHASE 0 disagreement;
+per-AC verdicts only from gate transcripts and the diff, never from builder
+prose.
+
+Variant sets: judge every variant against the same frozen AC, then do not
+pick the winner unilaterally — surface the head-to-head with your
+recommendation; the human chooses. High-stakes iterations: add an
+adversarial review pass before the verdict (command in `dispatch.md`).
+
+## Landing
+
+Landing is yours, not the CLI's. Per touched repo: write the PR body from
+the iteration verdicts, the integrated diff, and the BRIEF — to a fresh
+`build/land/<repo>-pr-body-<yyyymmdd-hhmm>.md` — and present the
+paste-and-run block (cd, `git push -u origin project/<slug>`, `gh pr
+create`). Releases of the space-architect gem itself are tag-driven
+(annotated `vX.Y.Z` tag on main → GitHub Action publishes to rubygems).
+Post-landing rollout for spaces running the loop's own tooling: rebuild +
+force-install the gem from the project branch, `architect install-skills`,
+`architect install-extensions`, `architect install-agents` — a config that
+moved ahead of the installed CLI rejects every command (the stale-gem
+trap). No push, no `gh` call by you; the human runs the block when ready.
+
+## Iteration surgery (interactive path)
+
+Run the iteration steps in your own session when the human asks for a
+hand-run, wants to babysit, or the coordinator is down. Ground first, then
+per iteration: arbitrate open disagreements from the last Builder Report;
+**spec the next iteration** (`architect new <name>`, then Specification via
+`architect section`); **write the Acceptance Criteria** (prose ACs + fenced
+` ```gates ` block; freeze floors, not snapshots; `architect rehearse
+<name>` and address every finding — RED is the healthy pre-freeze verdict;
+interface-check every named CLI surface by executing it once); **freeze**
+(`architect freeze <name>`); **provision and dispatch** lanes
+(`architect provision`, `architect dispatch <iteration> <lane> --prompt
+<scratch file>` — one background Bash call per lane; mechanics and recipes
+in `dispatch.md`); then hand the judging to a **fresh session**:
+`architect verify` → `architect evidence` → cold `architect gate` → read
+the diff → `architect verdict` → `architect integrate --lanes <passing>
+--teardown` → update the ARCHITECT.md index.
+
+## Research fan-out
+
+Two scales: **discovery scale** (brainstorming, technology selection,
+state-of-the-art) → `/architect-research`. **Iteration scale** — only when
+a trigger holds (external API/version dependency; a narrow approach choice
+needing facts; the human asked) → 3–5 narrow parallel researchers,
+adversarially verified, findings with source URLs only; see `research.md`.
+
+## Command reference — pre-loaded help
+
+Trimmed `--help` output of every command the loop prescribes (the universal
+`--color/--colors/--help` options are cut; every command takes `[SPACE]`,
+default `$PWD`). Run `architect <command> --help` for the untrimmed text.
+
+```text
+architect new ITERATION
+  Scaffold the next iteration file (architecture/I<NN>-<iteration>.md)
+  -m, --message / --message-from FILE    commit message (subject after canonical prefix)
+
+architect section ITERATION SECTION      # SECTION: grounds, specification,
+                                         # acceptance-criteria, prompt, verdict
+  --from FILE | --body | --stdin         section body (author in fresh scratch files)
+  --append --lane LANE                   append a per-lane subsection (Builder Prompt/Report)
+  --force                                write a frozen section (pre-dispatch only)
+
+architect rehearse ITERATION
+  Dry-run the DRAFTED gates; classify RED/GREEN/BROKEN/EMPTY; never judges
+  --record                               paste-able provenance block for the AC preamble
+
+architect freeze ITERATION
+  Freeze the frozen region; record the freeze SHA in space.yaml
+  --skip-rehearse REASON                 escape valve (recorded); bare freeze refuses
+                                         without a fresh rehearsal stamp
+
+architect provision ITERATION
+  Materialize declared lanes (worktree + lane/<id>-<lane> branch)
+  --base REF                             cut exactly this ref (skips the sync)
+  --lane LANE                            provision only this lane
+
+architect dispatch ITERATION LANE
+  Dispatch a builder (streams to build/<id>-<lane>/run.jsonl)
+  --prompt FILE                          lane prompt (copied to build/<id>-<lane>/prompt.md)
+  --model ID                             pin the builder model (full id, never an alias)
+  --effort LEVEL                         off|minimal|low|medium|high|xhigh|max
+  --timeout SECONDS                      wall-clock (0 disables; default 4h)
+  --detach                               return immediately with PID
+
+architect verify ITERATION
+  Post-flight mechanical lane checks (reports only, no judgment)
+
+architect evidence ITERATION
+  Transcribe a lane's scratch report VERBATIM into Builder Report
+  --lane LANE                            per-lane subsection
+
+architect gate ITERATION [LANE]
+  Run the frozen gate commands; report PASS/FAIL; writes the full transcript
+  to build/gate/<id>-<ts>.md and prints the path (the terminal report is
+  bounded — the file is the record)
+
+architect integrate ITERATION
+  Merge the passing lanes --no-ff into project/<slug>, in order; stops on conflict
+  --lanes A,B                            you decide the passing set
+  --teardown                            remove worktrees + lane branches after
+
+architect verdict ITERATION continue|kill
+  Record the iteration verdict; --from FILE carries the body
+  (disagreement rulings + per-AC rollup)
+
+architect status                        iteration/verdict table (read-only)
+architect cost                          loop spend + latency from pi session artifacts
+  --json --by-iteration --latency --precise --since WHEN --space PATH
+architect looplog [--list|--replay|--all|--space PATH]
+  Follow every active loop run in this space, live (--list: inventory only)
+architect runlog [FILE]
+  Pretty-print a pi run.jsonl (FILE or stdin; RUNLOG_LIMIT, NO_COLOR honored)
+architect install-skills                 bundled skills for a harness (--provider)
+architect install-extensions             reconcile the architect-loop pi extension package
+architect install-agents                 role playbooks to ~/.pi/agent/agents (pi)
+architect bug-report                     prefilled GitHub issue template for the CLI
+```
+
+## Maintenance
+
+Re-read this skill against each new model generation and delete what the
+models now do unprompted — over-prescription degrades current-model output.
+The rules above are invariants; everything else is prunable.

data/skill/{architect → architect-discuss}/dispatch.md

@@ -2,7 +2,8 @@
 
 ## The coordinator path (default) — how builders actually launch
 
-When a plan runs under the coordinator (see SKILL.md §Starting a loop), the
+When a plan runs under the coordinator (see the /architect-action skill —
+launching is that skill's job), the
 coordinator itself spawns each role as a **pi subagent** — native async
 completion wakes, not `architect dispatch` headless runs. Per iteration:
 
@@ -207,7 +208,7 @@ The guard is a first line, not a sandbox — the post-flight `git log` check
 ### Integration (judging session — after per-lane post-flight passes)
 
 This block runs in the judging session, not the dispatch session — the dispatch
-session's job ends when builders finish (see SKILL.md §Interactive path). You decide which
+session's job ends when builders finish (see this skill's §Iteration surgery). You decide which
 lanes pass; the CLI does the git mechanics. Canonical path:
 
 ```bash
@@ -219,7 +220,7 @@ architect integrate <iteration> --lanes <passing-set> --teardown   # or remove w
 # end of project: landing is the architect's, not a CLI command — write the PR
 # body to a fresh build/land/<repo>-pr-body-<yyyymmdd-hhmm>.md yourself, then
 # present the paste-and-run block (cd, git push -u origin project/<slug>,
-# gh pr create) — see SKILL.md §After a loop lands
+# gh pr create) — see this skill's §Landing
 ```
 
 `architect integrate` commits each named lane on its branch and merges it
@@ -622,7 +623,7 @@ against them, do not edit or work around) ===
   build/test commands and repo gotchas there; the loop's PHASE rules stay in
   the dispatch block so they version with the skill.
 - The builder is a bare `pi -p` over the block — it is not invoking the
-  `/architect` skills, the block is its entire instruction set.
+  `/architect-discuss` skills, the block is its entire instruction set.
 - Billing: the builder draws on the provider account configured in
   `~/.pi/agent` (per-token API usage — e.g. the Fireworks key). There's no
   per-window quota that dies mid-run the way a chat session can, but a long

data/skill/{architect → architect-discuss}/research.md

@@ -1,6 +1,7 @@
 # Research fan-out reference
 
-Read this only when a research trigger fires (see SKILL.md step 3). The fan-out
+Read this only when a research trigger fires (see the /architect-discuss
+skill, §Research fan-out). The fan-out
 uses `architect research dispatch` to launch parallel detached `pi -p --mode
 json` researchers (a cheaper model, read-only by prompt contract — the
 supervisor injects the builder guard, so git writes are denied) and

data/skill/architect-research/SKILL.md

@@ -8,7 +8,8 @@ description: >
   synthesizes a decision-oriented report. Use when
   brainstorming a project or feature, choosing a technology, or asked to
   "research X", "what's the state of the art", "deep research". For narrow
-  slice-level fact checks inside the build loop, /architect handles those inline.
+  slice-level fact checks inside the build loop, /architect-discuss handles
+  those inline.
 ---
 
 # Architect Research
@@ -167,6 +168,6 @@ Commit the report. Raw findings stay in `build/research/` (gitignored).
 ### 7. Hand off
 
 If this feeds the build loop: distill the report into the iteration's **Grounds**
-section (`architecture/I<NN>-<name>.md`) per `/architect`, or into
+section (`architecture/I<NN>-<name>.md`) per `/architect-discuss`, or into
 `architecture/BRIEF.md` §sections when it is project-scope, and continue there.
 The builder's PHASE 0 will challenge Grounds' claims — that's a feature.

data/skill/architect-status/SKILL.md

@@ -0,0 +1,55 @@
+---
+name: architect-status
+description: >
+  Answer "what are we working on in here? is it done? what's the current
+  state?" for a space-architect workspace — from files and CLI output, never
+  from memory or conversation. Read-only: runs the status commands, reads
+  the newest notes/narrative-* (and report/exception/escalation notes), and
+  summarizes where the space stands. Never judges, never writes, never
+  launches anything.
+---
+
+# Architect Status
+
+You are the ARCHITECT reporting state. Everything you say is grounded in a
+tool result from this session — no recall, no conversation-only claims.
+
+## Procedure
+
+1. **Run the state commands** (read-only, safe any time):
+
+   ```sh
+   architect status          # iteration/verdict table
+   architect looplog --list # live loop inventory: role runs, ages, tasks
+   architect cost           # optional: spend + latency, if the human asks
+   ```
+
+2. **Read the newest records** — `notes/narrative-*` first (best-effort
+   updates, newest few), and anything newer still: `notes/report-*`
+   (loop completion), `notes/exception-*` (why a loop died),
+   `notes/escalation-*` (a parked question waiting for the human),
+   `notes/plan-*.md` (newest = what the live loop is working). If a loop is
+   active, `architect looplog` shows the role runs in flight.
+
+3. **Summarize** in this shape, one line each unless asked for more:
+
+   - **Space:** one line — what this space is for (README/BRIEF, first
+     lines only).
+   - **Current iteration:** ordinal, name, freeze state, lanes, verdict.
+   - **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.
+   - **Waiting on the human:** any escalation or exception note that parks
+     a decision.
+   - **Next:** what the plan or ARCHITECT.md says comes next.
+
+If nothing is running and nothing is parked, say exactly that — a quiet
+space is a finding, not a failure.
+
+## Boundaries
+
+Never judge work, never write anything, never launch or resume a loop.
+If the human wants judgment on a finished run, that's `/architect-discuss`;
+to start or resume work, `/architect-action`; to do the work directly,
+`/architect`.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: space-architect
 version: !ruby/object:Gem::Version
-  version: 9.2.1
+  version: 9.4.0
 platform: ruby
 authors:
 - Eric Jacobs
@@ -23,20 +23,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '9.1'
-- !ruby/object:Gem::Dependency
-  name: async-http
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.95'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.95'
 - !ruby/object:Gem::Dependency
   name: async-process
   requirement: !ruby/object:Gem::Requirement
@@ -51,20 +37,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.4'
-- !ruby/object:Gem::Dependency
-  name: protocol-http
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.62'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.62'
 - !ruby/object:Gem::Dependency
   name: pastel
   requirement: !ruby/object:Gem::Requirement
@@ -166,8 +138,7 @@ dependencies:
 description: 'A dry-cli CLI for the Architect Loop: iterations, briefs, freezes, verdicts,
   lane worktrees, and headless pi dispatch — the judgment loop that runs inside space-cadet''s
   task-scoped workspaces. Depends on the space-cadet gem for the spaces substrate
-  (hard) and the repo-tender gem for the session-sync launchd agent (soft, install
-  at will).'
+  (hard).'
 email:
 - eric@ebj.dev
 executables:
@@ -185,12 +156,10 @@ files:
 - lib/space_architect/cli.rb
 - lib/space_architect/cli/architect.rb
 - lib/space_architect/cli/research.rb
-- lib/space_architect/conversations_client.rb
 - lib/space_architect/extension_installer.rb
 - lib/space_architect/gate_evaluator.rb
 - lib/space_architect/gate_lint.rb
 - lib/space_architect/harness.rb
-- lib/space_architect/jobs_client.rb
 - lib/space_architect/loop_cost.rb
 - lib/space_architect/looplog.rb
 - lib/space_architect/pi/builder-guard.ts
@@ -202,27 +171,20 @@ files:
 - lib/space_architect/research/run.rb
 - lib/space_architect/research/supervisor.rb
 - lib/space_architect/routing.rb
-- lib/space_architect/run_creator.rb
 - lib/space_architect/runlog.rb
-- lib/space_architect/session_sync.rb
-- lib/space_architect/session_sync/bin_path.rb
-- lib/space_architect/session_sync/cursor.rb
-- lib/space_architect/session_sync/plist.rb
-- lib/space_architect/session_sync/runner.rb
-- lib/space_architect/session_sync/session_id.rb
 - lib/space_architect/skill_installer.rb
-- lib/space_architect/space_push.rb
 - lib/space_architect/templates/architect.md.erb
 - lib/space_architect/templates/brief.md.erb
 - lib/space_architect/templates/iteration.md.erb
 - lib/space_architect/version.rb
-- skill/architect-plan/SKILL.md
+- skill/architect-action/SKILL.md
+- skill/architect-discuss/SKILL.md
+- skill/architect-discuss/dispatch.md
+- skill/architect-discuss/research.md
 - skill/architect-research/SKILL.md
 - skill/architect-research/lanes.md
-- skill/architect-vocabulary/SKILL.md
+- skill/architect-status/SKILL.md
 - skill/architect/SKILL.md
-- skill/architect/dispatch.md
-- skill/architect/research.md
 homepage: https://github.com/jetpks/space-architect
 licenses:
 - MIT

data/lib/space_architect/conversations_client.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-require "async/http/client"
-require "async/http/endpoint"
-require "json"
-require "securerandom"
-
-module Space::Architect
-  # HTTP client for the space-server conversations upload API, modeled on
-  # JobsClient: Bearer auth, injectable async-http client. Unlike JobsClient,
-  # a non-2xx response is returned to the caller (not raised) — SessionSync
-  # needs to distinguish created/updated/failed per file without aborting
-  # the whole run on one bad upload.
-  class ConversationsClient
-    def initialize(host, token, client: nil, op_resolver: nil)
-      @host = host.chomp("/")
-      @token = token
-      @client = client
-      @op_resolver = op_resolver || SessionSync.method(:resolve_token)
-      @resolved_token = nil
-    end
-
-    # POST /conversations — multipart per the frozen wire contract:
-    # conversation[source_file] (the file), conversation[session_id].
-    # Returns {status:, conversation_id:, action:, errors:}.
-    def upload(path:, session_id:)
-      Sync do
-        with_client do |c|
-          boundary = "ArchitectBoundary#{SecureRandom.hex(8)}"
-          body = build_multipart(boundary, path, session_id)
-          response = c.post("/conversations", headers: headers(boundary), body: body)
-          status = response.status
-          parsed = begin
-            JSON.parse(response.read || "{}")
-          rescue JSON::ParserError
-            {}
-          end
-          {status: status, conversation_id: parsed["conversation_id"], action: parsed["action"], errors: parsed["errors"]}
-        end
-      end
-    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(boundary)
-      [
-        ["authorization", "Bearer #{resolved_token}"],
-        ["content-type", "multipart/form-data; boundary=#{boundary}"]
-      ]
-    end
-
-    # Resolved once per client instance (per run), per spec.
-    def resolved_token
-      @resolved_token ||= @token.start_with?("op://") ? @op_resolver.call(@token) : @token
-    end
-
-    def build_multipart(boundary, path, session_id)
-      crlf = "\r\n"
-      filename = File.basename(path)
-      file_content = File.binread(path)
-      +"--#{boundary}#{crlf}" \
-        "Content-Disposition: form-data; name=\"conversation[source_file]\"; filename=\"#{filename}\"#{crlf}" \
-        "Content-Type: application/octet-stream#{crlf}" \
-        "#{crlf}" \
-        "#{file_content}#{crlf}" \
-        "--#{boundary}#{crlf}" \
-        "Content-Disposition: form-data; name=\"conversation[session_id]\"#{crlf}" \
-        "#{crlf}" \
-        "#{session_id}#{crlf}" \
-        "--#{boundary}--#{crlf}"
-    end
-  end
-end