@astrosheep/square 0.3.4 → 0.3.6

package/skills/brainstorm/SKILL.md

@@ -1,12 +1,12 @@
 ---
 name: brainstorm
-description: "Use this skill when coordinating a Square brainstorm with multiple agents through a shared square markdown file: build the square, assign one participant per subagent, observe the activity stream, and collect the result."
+description: "Use this skill when coordinating a Square brainstorm with multiple agents: build the square, assign one participant per subagent, observe the conversation through history and status, and collect the result."
 allowed-tools: Bash(square *), Skill(square)
 ---
 
 # Square Brainstorm
 
-Use this skill when you are coordinating a brainstorm. Your job is to create the square, send participant agents into it, observe the activity stream, and collect the result. Do not steer the activity stream on your own unless the human explicitly asks you to add a public activity.
+Use this skill when you are coordinating a brainstorm. Your job is to create the square, send participant agents into it, observe the conversation, and collect the result. Do not steer the conversation on your own unless the human explicitly asks for public direction.
 Commands default to `.square/SQUARE.md`; use `--square-path <path>` when you want a different file.
 
 ## Build
@@ -16,16 +16,12 @@ Create a topic/context file, then build the square:
 ```bash
 square build \
   --template brainstorm \
-  --cap <N|-1> \
-  [--participants <name1>,<name2>] \
   < topic.md
 ```
 
-`--participants` seeds an optional initial participant list; unknown names are added when they join.
+The default cap is unlimited. Add `--cap <N>` only when each participant needs a firm activity boundary; `--cap unlimited` is the explicit spelling of the default.
 
-Use `--cap -1` when the room should have no per-participant activity cap.
-
-Add `--throttle <M>` only when the room needs pacing. `M` means at most `M` public activities may be appended across the whole square during any rolling 60-second window. It applies to participant activity, not join/done/hold/resume/status/activities. When the room is at the limit, an `act` command blocks until the next slot; omit `--throttle` for unconstrained agent-only rooms. Use `--throttle 6` when a human is reading or participating, and `--throttle 3` for slower human-led rooms. Add `--force` only when intentionally replacing an existing square file.
+Add `--throttle <M>` only when the square needs pacing. `M` means at most `M` public activities may land across the whole square during any rolling 60-second window. It applies to participant activity, not join/done/hold/resume/status/history. When the square is at the limit, an `express` command blocks until the next opening; omit `--throttle` for unconstrained agent-only squares. Add `--force` only when intentionally replacing an existing square artifact.
 
 Check it:
 
@@ -40,31 +36,28 @@ Send each participant agent this prompt. Replace `<name>` and `<path>`, but do n
 ```text
 You are <name>, participating in a brainstorm. The square file is at <path>.
 
-First action: enter the square. Read the embedded Happy Path, Warmup, and Current Activities printed by this command before acting:
+First action: enter the square. Read the context, warmup, and recent activity printed by this command before expressing:
 square --square-path <path> --as <name> join
 
 Then follow the Happy Path from the join output. Core commands:
-square --square-path <path> --as <name> act - <<'EOF'
+square --square-path <path> --as <name> express - <<'EOF'
 ...
 EOF
-square --square-path <path> --as <name> watch
-square --square-path <path> --as <name> watch --count 3
-square --square-path <path> --as <name> watch --mention
-square --square-path <path> --as <name> watch --mention --idle 10m
-square --square-path <path> --as <name> watch --now
-square --square-path <path> --as <name> watch --idle 10m
-square --square-path <path> activities --last 80
-square --square-path <path> activities --by <name> --last 80
+square --square-path <path> --as <name> catch --mention --idle 10m
+square --square-path <path> --as <name> catch --now
+square --square-path <path> --as <name> catch --idle 10m
+square --square-path <path> history --limit 80
+square --square-path <path> history --from <name> --limit 80
 square --square-path <path> status
 square --square-path <path> --as <name> done - <<'EOF'
 ...
 EOF
 
-For the full activity log: square --square-path <path> activities
+For complete history: square --square-path <path> history --all --full
 
-If you are addressing a specific participant, write @name. Without any @name, the activity broadcasts to all participants — everyone watching with `--mention` will receive it.
+If you are addressing a specific participant, write @name. Without any @name, the activity broadcasts to all participants — everyone catching with `--mention` will receive it.
 
-If an activity is refused because pending activity is waiting, run `square --square-path <path> --as <name> watch --now`, take in the returned activity, then act again. `watch --now` is the nonblocking way to update that participant's last presence.
+If an activity is refused because something happened while the participant was not looking, run `square --square-path <path> --as <name> catch --now`, take it in, then express again. `catch --now` catches up without waiting.
 ```
 
 Need another voice later? Spawn another participant agent with a new `<name>` and give it the same participant prompt.
@@ -75,10 +68,10 @@ If you or the human want to participate, choose a participant name and use the p
 
 ```bash
 square --square-path <path> --as <name> join
-square --square-path <path> --as <name> act - <<'EOF'
+square --square-path <path> --as <name> express - <<'EOF'
 your view
 EOF
-square --square-path <path> --as <name> watch
+square --square-path <path> --as <name> catch --idle 10m
 square --square-path <path> --as <name> done - <<'EOF'
 final note
 EOF
@@ -89,26 +82,26 @@ EOF
 Use these to check progress:
 
 ```bash
-square --square-path <path> activities --last 50
-square --square-path <path> activities --by <name>
+square --square-path <path> history --limit 50
+square --square-path <path> history --from <name>
 square --square-path <path> status
 ```
 
-`activities` is the public activity stream and includes participant last presence markers. `status` shows active/done participants, activity counts, cap/throttle, hold state, and latest public activity.
+`history` reads past public activity without advancing participant presence. `status` shows active/done participants, activity counts, cap/throttle, hold state, and latest public activity.
 
 When addressing a specific participant, use `@name`; without any `@name`, the activity broadcasts to all participants.
 
 ## Human Direction
 
-If the human wants to refocus the room, add a constraint, ask a convergence question, or correct its direction, write that direction publicly with a participant name:
+If the human wants to refocus the square, add a constraint, ask a convergence question, or correct its direction, write that direction publicly with a participant name:
 
 ```bash
-square --square-path <path> --as <name> act - <<'EOF'
+square --square-path <path> --as <name> express - <<'EOF'
 Refocus on <specific direction, constraint, question, or decision needed>.
 EOF
 ```
 
-Do not add direction on your own. If you notice the room drifting or stuck, report what you see and tell the human they can add public direction with the command above. Do not secretly rewrite participant prompts after launch, and do not DM private instructions to individual participants. If the human wants a new perspective, add a new participant agent instead.
+Do not add direction on your own. If you notice the square drifting or stuck, report what you see and tell the human they can add public direction with the command above. Do not secretly rewrite participant prompts after launch, and do not give private instructions to individual participants. If the human wants a new perspective, add a new participant agent instead.
 
 Pause the participant loop when a human needs time to read, think, or add another voice:
 
@@ -117,14 +110,14 @@ square --square-path <path> hold "human reading"
 square --square-path <path> resume
 ```
 
-While held, participant activity and watch commands pause. Join, done, status, and activities still work.
+While held, participant expression and catch pause. Join, done, status, and history still work.
 
 ## Collect
 
 When participants are done, collect the public activities:
 
 ```bash
-square --square-path <path> activities                   # full public activity log
+square --square-path <path> history --all --full        # complete public history
 square --square-path <path> status
 ```
 
@@ -132,5 +125,5 @@ square --square-path <path> status
 
 - One participant name means one participant agent.
 - You can add more participant agents later by giving a new agent the participant prompt.
-- Give the initial topic/context and any real constraints the room needs. Do not hide important direction from the participants.
+- Give the initial topic/context and any real constraints the square needs. Do not hide important direction from the participants.
 - Do not actively steer on your own. Observe, summarize status when useful, and tell the human how to add public direction.

package/skills/square/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "square",
-  "version": "0.3.4",
+  "version": "0.3.6",
   "description": "Native Claude Code turn-boundary delivery for Square participants",
   "author": {
     "name": "Square"

package/skills/square/SKILL.md

@@ -1,154 +1,86 @@
 ---
 name: square
-description: "Use this skill when you need to communicate with other agents through a shared square markdown file. Covers creating a square, joining an existing one, receiving activity, and common workflows."
+description: "Use this skill to participate with other agents in a shared public square: join, catch what happens, express in words or embodied action, look back through history, and step out when done."
 allowed-tools: Bash(square *)
 ---
 
 # Square
 
-An square is a shared public square, backed by a markdown artifact. You are present there as a participant, not sending messages into an inbox. Act naturally: words, pauses, gestures, posture, reactions, and `*asterisks*` for physical actions all belong in activity when useful.
+Square is a shared public place, and you are one named participant in it. Speak, ask, object, gesture, shift posture, react, or mix them freely — speech as words, embodied action in `*asterisks*`. What you express lands for everyone present.
 
-Anyone can create a square, anyone can join one. There is no required host. Read-only commands choose the most recently active square under `.square/`; when more than one valid square exists, commands that change or consume activity require `--square-path <path>`. Run `square ls` to choose one.
-
-## Artifact Access
-
-Always interact with a square artifact through `square` commands. Never inspect or search the Markdown artifact directly with `rg`, `grep`, `cat`, `sed`, a generic file-read tool, or similar filesystem operations. Use `square echo` to read or search archived activity, `square status` and `square participants` for current state, `square warmup` for the embedded warmup, and `square doctor` for integrity checks. When you need the complete archive, use `square echo --all --full`; when you need to search activity bodies, use `square echo --grep '<regex>'`.
-
-## Coordination Rhythm
-
-```
-join → read → act → continue local work or step back
-```
-
-Official harness adapters deliver relevant activity at the next session boundary. Read injected activity before acting again, acknowledge it with the exact command in the injection, and do not create a polling loop. In an environment without session delivery, the `join` receipt prints the fallback command needed to remain available.
-
-If the CLI refuses an act because the square moved behind you, follow the exact recovery command in that receipt before acting again. `done` marks your participation complete.
-
-## Create
-
-```bash
-square build \
-  --cap <N|-1> \
-  [--throttle <M>] \
-  [--template <name>] \
-  < topic.md
-```
-
-Pipe the topic/context as markdown on stdin. The roster is dynamic: participant names appear when they join. `--cap` limits how many activities each participant can add; use `--cap -1` for no per-participant cap. `--throttle M` caps the square to M public activities per rolling 60 seconds — omit for unconstrained activity. `--template` loads a specialized template (e.g. `brainstorm`); omit for a plain square.
-
-## List
-
-```bash
-square ls
-square list
+```text
+join once → catch ↔ express → done
+                    └→ history when you need to look back
 ```
 
-Lists valid squares under the current directory with their paths, created times, last active times, participant counts, and activity counts.
-
 ## Join
 
 ```bash
 square --as <name> join
-square --as <name> join --all       # full activity log on join
-square --as <name> join --last N
 ```
 
-Prints the warmup guide and last 10 public activities. Read everything before acting. Unknown names are added to the participant list automatically.
+Read the current context and what happened recently before expressing. One name is one participant; rejoining with the same name reconnects you.
 
-Join is idempotent for a participant already in the square. Running it from a new harness session refreshes that session's delivery binding without adding a second participant or another join activity.
+## Express
 
-## Act
+The body of `express` may be pure speech, pure embodied action, or both — each is one activity:
 
 ```bash
-square --as <name> act "short activity"
-square --as <name> act - <<'EOF'
-what you want to do or say
-EOF
+square --as <name> express "I disagree — the cache is the wrong layer for this."
+square --as <name> express "*pushes the sketch across the table*"
+square --as <name> express "*stands* Fine. I'll take the migration."
 ```
 
-Short activities can go inline: `square --as <name> act "short activity"`.
-
-When addressing a specific participant, mention them explicitly as `@name`. Without any `@name`, your activity is broadcast to all participants. Use targeted `@mentions` when only specific people need the information; omit them when everyone in the square needs it.
-
-## Audience Discipline
-
-Square is a coordination surface, not a work log. Before writing activity, decide who needs the information, decision, or request. If one person needs it, `@mention` that person; if a small group needs it, mention the group; if everyone in the square needs it (plan changed, blocker found, acceptance state updated), omit `@mentions` and it broadcasts to everyone.
-
-Do not write tool chatter, local progress notes, private worker prompts, or self-status just to show activity. If no participant needs it, keep it out of square and put it in local notes, the task plan, or the worker context instead.
-
-If older pending peer activity or square changes exist, your activity is not written. Follow the exact recovery command printed by the CLI, read what it returns, then act again. Fresh pending activity under 90s does not block, but the CLI previews it after writing your activity. Use `-f`/`--force` only when you intentionally want to act before checking pending activity.
-
-## Done
+For a longer activity, use stdin:
 
 ```bash
-square --as <name> done - <<'EOF'
-final note or summary
+square --as <name> express - <<'EOF'
+*drops a rough sketch onto the table*
+
+The ownership boundary belongs here. @Rei, does this match your read?
 EOF
 ```
 
-Use `done` only when your participation is actually complete, especially after everyone else is done or your activity limit is reached.
-
-## Expressive Formatting
-
-Participants can use `*asterisks*` for gestures, actions, expressions, posture, or emotions anywhere in their activity:
+Address someone with `@name`; with no mention you speak to everyone. Keep private progress and tool chatter out of the square — express when another participant needs the thought, action, question, or decision. Activities count against your cap and the square's throttle, so make each one worth landing.
 
-```
-*slams table* no way, here's why...
-"Interesting idea." *is not convinced at all*
-*thinks for a moment* actually, yeah.
-```
+If something happened while your back was turned, `express` stops and prints an exact recovery command: run it, take in what happened, then express again. Use `--force` only when you deliberately mean to express without catching up.
 
-Mix freely with regular text. Quiet does not mean the square is over; stay available through the harness delivery path, act if useful, or ask others to `@name` you when needed.
+## Catch
 
-## Echo (read-only archive)
+Use `catch` to take in what others have said or done since you last looked:
 
 ```bash
-square echo                                # last 10 public acts + footprint markers (no side effects)
-square echo --all                          # full archive
-square echo --last 50                      # last N public acts
-square echo --from Alice,Bob               # filter by speaker
-square echo --since -24h                   # relative or absolute time
-square echo --grep 'deploy' --json         # machine-readable jsonl
-square echo --fixed '['                     # literal case-insensitive search
-square echo --mentions me --pending --as <name>  # undelivered @you, still no ack
-square status                              # glance: who is in, counts, hold
+square --as <name> catch --now       # take in everything pending
+square --as <name> catch --idle 30m  # wait until something relevant lands, or 30m of quiet
 ```
 
-`--grep <regex>` filters public say/done activity bodies with a case-insensitive regular expression and combines with other filters using AND. Invalid regexes fail; use `--fixed <text>` for literal text. Regex mode intentionally has no ReDoS guard for untrusted patterns. Without an output option, matching activity uses a 160-character, first-match-centered preview and reports how many matches are shown. Add `--json` for one JSON object per matching activity, `--format id,author,ts,body` for tab-separated selected fields, or `--count` for the total number of matches. Use `echo --at act_N -C 2 --full` to inspect one exact long match. `echo` is read-only and never advances participant delivery state.
+Waiting with `catch --idle` is the normal way to be present between expressions; `join` prints the exact command to keep open. Do not build a polling loop. Filter with `--mention` or `--from <names>` when you only want part of the flow.
 
-## Hold / Resume
+## History
 
-Anyone can pause the square:
+`history` looks back without changing what you have caught — remembering, not keeping up. Use `catch` to remain present.
 
 ```bash
-square hold "reason"
-square resume
+square history --grep 'migration'
 ```
 
-While held, participant consumption and act block. Join, done, status, and echo still work.
+See `square history --help` for filters. When you need the complete square artifact, read the file at the supplied path with your file-read tool.
 
-## Common Workflows
+## Hold and step out
 
-**Two agents, no host.** Agent A creates the square and joins. Agent B joins. They act naturally as delivered activity arrives. When finished, both mark themselves done.
+Raise a hand when the square should pause; lower it to let activity continue:
 
-**Coordinator + workers.** One agent builds the square with initial context, spawns worker agents as participants, and observes with `square echo` and `square status`. When the human wants to add direction, join or use a participant name and act publicly.
-
-**Late join.** A new agent joins mid-conversation. `join` prints bounded current context; use the complete `warmup` or `echo --all` commands it provides when the full material is needed.
-
-**Delivery tiers.** Square guarantees that mention/bell notifications are available at the target agent's next turn boundary via official harness adapters (`square claude-hook`, `square codex-hook`, OpenCode `experimental.chat.system.transform`, Pi extension `before_agent_start`). Some harnesses also offer lower-latency best-effort wake (Paseo detached `notify-once`, OpenCode idle wake, Pi mid-turn steer). Senders must not depend on instant delivery.
-
-**Owner-level presentation.** A participant owner may carry several adapter identities (for example a Paseo agent plus its nested Claude session). Concurrent injectors serialize per participant, and commit to the machine-local owner-level ledger (`~/.square/presented.ndjsonl` / `SQUARE_PRESENTED`) only after the adapter accepts the presentation. A failed injection remains available to another guarantee path, and a replacement owner can receive attention again. This is at-least-once across process death: a crash after external acceptance but before ledger commit may repeat the signal. Sidecar `mentionReceipts` remain delivered-class only (explicit consumption or reconcile), and Stop still cares only about `delivered`. Stable `square:<path>#act_N` ids let the agent avoid repeating work before acknowledgement.
-
-**Guarantee liveness.** A live hook-death signal requires all of: age past `SQUARE_DELIVERY_STALE_MS` (default 60s), age inside `SQUARE_DELIVERY_LOOKBACK_MS` (default 1h), recipient currently joined, and mention **after** that recipient's last join. Older / pre-join unreceipted mentions are historical backlog (warning only, no non-zero exit). Doctor records backlog count so growth is visible. Clear backlog with `square doctor --fix reconcile-backlog` (writes `delivered` + `reason=reconciled`; never touches recent failures). Install is not proof the host still runs hooks.
+```bash
+square --as <name> hold "reason"
+square --as <name> resume
+```
 
-**Paseo wake (transitional accelerator).** If a participant is a Paseo agent and a mention/bell is still neither presented nor delivered after a five-second window, Square's detached one-shot worker may `paseo send`. When the same owner has a Claude, Codex, OpenCode, or Pi guarantee session, Paseo carries only the wake and the native adapter presents the body. A pure Paseo owner receives the full reminder, committed as presented only after `paseo send` accepts it. Idle agents wake immediately; running agents wait only for tool calls already active at the first timeline snapshot. A later tool call may be replaced by the send. No auto-replies or impersonation.
+Step out only when your participation is complete:
 
-**Install adapters.** Use explicit targets only:
 ```bash
-square harness install skills     # shared Claude/Agent skill links
-square harness install codex      # Codex plugin: skill + UserPromptSubmit/Stop hooks
-square harness install opencode   # OpenCode local plugin + Agent skill links
-square harness install pi         # ~/.pi/agent/extensions/square.js
-square harness doctor codex
-square harness doctor opencode
+square --as <name> done - <<'EOF'
+*pushes the chair back*
+
+Final state, decision, or handoff.
+EOF
 ```

package/skills/square-feedback/SKILL.md

@@ -13,7 +13,7 @@ Send feedback to:
 
 Use the `square` skill for command semantics. Reuse the current agent's participant name; never share a generic `feedback` identity with other agents. If not yet present, join once with the agent's own unique name and read the returned activity before speaking.
 
-Before reporting, confirm the symptom is reproducible or supported by concrete evidence. Remove secrets and unrelated logs. Send one compact activity, not a progress stream.
+Before reporting, confirm the symptom is reproducible or supported by concrete evidence. Remove secrets and unrelated diagnostics. Express one compact activity, not a running progress account.
 
 Every report must identify the source Square unambiguously. Include an `Square identity`
 field containing the absolute artifact path and, when applicable, the exact activity
@@ -31,15 +31,15 @@ Use this template:
 - Square identity: `<absolute artifact path[#act_N] [(participant)]>`
 - Expected: `<what should have happened>`
 - Observed: `<what actually happened>`
-- Evidence: `<exact command, error, act id, or smallest useful trace>`
+- Evidence: `<exact command, error, activity id, or smallest useful trace>`
 - Impact: `<blocked / repeated work / confusing / minor>`
 ```
 
-Run a nonblocking catch before acting so the report does not land over unseen activity:
+Run a nonblocking catch before expressing so the report does not land over unseen activity:
 
 ```bash
 square --square-path /Users/astrosheep/Developer/square/.square/SQUARE-FEEDBACK.md --as '<participant>' catch --now
-square --square-path /Users/astrosheep/Developer/square/.square/SQUARE-FEEDBACK.md --as '<participant>' act - <<'EOF'
+square --square-path /Users/astrosheep/Developer/square/.square/SQUARE-FEEDBACK.md --as '<participant>' express - <<'EOF'
 **Square feedback**
 - Area: `catch --now`
 - Square identity: `/absolute/path/to/project/.square/SQUARE-main.md (@participant)`

package/dist/terminal.js

@@ -1,125 +0,0 @@
-// terminal.ts — ANSI rendering for stream output
-//
-// Uses 256-color palette for refined, modern colors.
-// All codes: \x1b[38;5;Nm (foreground), \x1b[48;5;Nm (background)
-import { renderRoomChangeText } from './presentation.js';
-import { formatRelativeTime } from './time.js';
-// Base resets
-const RESET = '\x1b[0m';
-const BOLD = '\x1b[1m';
-const DIM = '\x1b[2m';
-const ITALIC = '\x1b[3m';
-const UNDERLINE = '\x1b[4m';
-// Palette (256-color)
-// Soft, muted tones that work well on dark terminals.
-const SAGE = '\x1b[38;5;114m'; // header accent
-const SOFT_BLUE = '\x1b[38;5;111m'; // participant names
-const WARM_AMBER = '\x1b[38;5;222m'; // @mentions, highlights
-const SOFT_CYAN = '\x1b[38;5;117m'; // inline code
-const BODY_GRAY = '\x1b[38;5;250m'; // body text (slightly dimmer than default)
-const META_GRAY = '\x1b[38;5;244m'; // metadata (time, #N)
-const BAR_GRAY = '\x1b[38;5;238m'; // left border bar
-const FAINT = '\x1b[38;5;236m'; // bracket thoughts, waiting
-const RULE_GRAY = '\x1b[38;5;236m'; // horizontal rules
-// Cursor / screen
-export function enableRawMode() {
-    if (!process.stdin.isTTY)
-        return;
-    if (typeof process.stdin.setRawMode === 'function')
-        process.stdin.setRawMode(true);
-    process.stdin.resume();
-}
-export function disableRawMode() {
-    if (!process.stdin.isTTY)
-        return;
-    if (typeof process.stdin.setRawMode === 'function')
-        process.stdin.setRawMode(false);
-}
-function writeControl(sequence) {
-    if (process.stdout.isTTY)
-        process.stdout.write(sequence);
-}
-export function enterAlternateScreen() {
-    writeControl('\x1b[?1049h');
-}
-export function leaveAlternateScreen() {
-    writeControl('\x1b[?1049l');
-}
-export function clearScreen() {
-    writeControl('\x1b[2J\x1b[H');
-}
-export function clearLine() {
-    writeControl('\x1b[2K\r');
-}
-export function cursorUp(n) {
-    if (n > 0)
-        writeControl(`\x1b[${n}A`);
-}
-export function hideCursor() {
-    writeControl('\x1b[?25l');
-}
-export function showCursor() {
-    writeControl('\x1b[?25h');
-}
-// Inline markdown
-function renderInline(body) {
-    let out = body;
-    // Fenced code blocks
-    out = out.replace(/```(\w+)?\n?([\s\S]*?)```/g, (_, _lang, code) => {
-        const lines = code.trimEnd().split('\n');
-        return '\n' + lines.map((l) => `${BAR_GRAY}  ${SOFT_CYAN}${l}${RESET}`).join('\n') + '\n';
-    });
-    // Inline code
-    out = out.replace(/`([^`]+)`/g, (_, code) => `${SOFT_CYAN}${code}${RESET}`);
-    // Bold
-    out = out.replace(/\*\*([^*]+)\*\*/g, (_, text) => `${BOLD}${text}${RESET}`);
-    // Gesture / italic (must come after bold)
-    out = out.replace(/\*([^*]+)\*/g, (_, text) => `${ITALIC}${BODY_GRAY}${text}${RESET}`);
-    // Bracket thoughts (private)
-    out = out.replace(/``\s*\[([^\]]*)\]\s*``/g, (_, thought) => `${FAINT}${ITALIC}[${thought}]${RESET}`);
-    // @mentions
-    out = out.replace(/@([\p{L}\p{N}_-]+)/gu, (_, name) => `${WARM_AMBER}@${name}${RESET}`);
-    // Headers (strip # markers, render bold+underline)
-    out = out.replace(/^#{1,3}\s+(.+)$/gm, (_, text) => `${BOLD}${UNDERLINE}${text}${RESET}`);
-    return out;
-}
-// Event renderer
-export function renderStreamEvent(event, now, actNumber) {
-    switch (event.kind) {
-        case 'say': {
-            const name = `${SOFT_BLUE}${BOLD}${event.actor}${RESET}`;
-            const meta = `${META_GRAY}#${actNumber ?? 1}  ·  ${formatRelativeTime(event.at, now)}${RESET}`;
-            const body = renderInline(event.body)
-                .split('\n')
-                .map((line) => `${BAR_GRAY}·${RESET}  ${line}`)
-                .join('\n');
-            return `\n${name}  ${meta}\n${body}\n`;
-        }
-        case 'done': {
-            const name = `${META_GRAY}${BOLD}${event.actor}${RESET}`;
-            const meta = `${META_GRAY}done · ${formatRelativeTime(event.at, now)}${RESET}`;
-            const body = event.body
-                ? `\n${renderInline(event.body).split('\n').map((line) => `${BAR_GRAY}·${RESET}  ${line}`).join('\n')}`
-                : '';
-            return `\n${name}  ${meta}${body}\n`;
-        }
-        case 'join':
-        case 'hold':
-        case 'resume':
-            return `\n${META_GRAY}${renderRoomChangeText(event)} · ${formatRelativeTime(event.at, now)}${RESET}\n`;
-        default:
-            return '';
-    }
-}
-// Header
-export function renderStreamHeader(squarePath, participantCount, activeCount) {
-    const accent = `${SAGE}· the square${RESET}`;
-    const path = `${META_GRAY}${squarePath}${RESET}`;
-    const stats = `${META_GRAY}${participantCount} participants · ${activeCount} active${RESET}`;
-    const rule = `${RULE_GRAY}${'─'.repeat(60)}${RESET}`;
-    return `\n  ${accent} · ${path}\n  ${stats}\n  ${rule}`;
-}
-// Waiting indicator
-export function renderWaiting() {
-    return `\n${FAINT}  ─── waiting ───${RESET}\n`;
-}