@astrosheep/square 0.3.5 → 0.3.7

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/hooks/hooks.json

@@ -1,18 +1,7 @@
 {
-  "description": "Bounded Square inbox checks at supported Claude Code turn boundaries",
+  "description": "Bounded Square inbox admission between Claude Code agent steps",
   "hooks": {
-    "UserPromptSubmit": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "command": "square claude-hook",
-            "timeout": 5
-          }
-        ]
-      }
-    ],
-    "Stop": [
+    "PostToolBatch": [
       {
         "hooks": [
           {

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/harness-lifecycle.js

@@ -1,102 +0,0 @@
-import path from 'node:path';
-export class HarnessLifecycleError extends Error {
-    host;
-    phase;
-    retryCommand;
-    constructor(host, phase, retryCommand, cause) {
-        super(`${host} ${phase} failed: ${cause instanceof Error ? cause.message : String(cause)}\n» ${retryCommand}`);
-        this.host = host;
-        this.phase = phase;
-        this.retryCommand = retryCommand;
-        this.name = 'HarnessLifecycleError';
-    }
-}
-function containsPath(root, target) {
-    const relative = path.relative(path.resolve(root), path.resolve(target));
-    return relative === '' || (!relative.startsWith(`..${path.sep}`) && relative !== '..' && !path.isAbsolute(relative));
-}
-function staleRegistrations(inventory, managedRoot, desired) {
-    return inventory.marketplaces.filter((registration) => registration.local &&
-        containsPath(managedRoot, registration.source) &&
-        (registration.name !== desired.marketplaceName || path.resolve(registration.source) !== path.resolve(desired.marketplaceRoot)));
-}
-function pluginIdForRegistration(desired, registration) {
-    if (registration.pluginIds !== undefined && registration.pluginIds.length > 0)
-        return registration.pluginIds;
-    const pluginName = desired.pluginId.split('@', 1)[0];
-    return [`${pluginName}@${registration.name}`];
-}
-/**
- * Reconcile a host from Square-owned desired state. Cleanup deliberately begins
- * only after plugin activation and hook verification, so an old registration is
- * still usable when staging, registration, install, or verification fails.
- */
-export async function reconcileInstall(homeDir, protocol, retryCommand = `square harness install ${protocol.host}`) {
-    let staged;
-    let activated = false;
-    let phase = 'stage';
-    try {
-        const before = await protocol.inspectInventory(homeDir);
-        const managedRoot = protocol.managedRoot(homeDir);
-        const current = before.marketplaces.find((registration) => registration.name === protocol.marketplaceName &&
-            registration.local &&
-            containsPath(managedRoot, registration.source));
-        const marketplaceRoot = current?.source ?? path.join(managedRoot, 'marketplaces', protocol.marketplaceName);
-        staged = await protocol.stageBundle(homeDir, marketplaceRoot);
-        const stale = staleRegistrations(before, protocol.managedRoot(homeDir), staged.desired);
-        if (current === undefined) {
-            phase = 'register';
-            await protocol.registerMarketplace(homeDir, staged.desired);
-        }
-        phase = 'install';
-        await protocol.installOrUpdate(homeDir, staged.desired);
-        phase = 'verify';
-        await protocol.verifyPluginAndHooks(homeDir, staged.desired);
-        activated = true;
-        phase = 'cleanup';
-        for (const registration of stale) {
-            for (const pluginId of pluginIdForRegistration(staged.desired, registration)) {
-                await protocol.removePlugin(homeDir, pluginId, registration.name);
-            }
-            await protocol.removeMarketplace(homeDir, registration.name);
-            if (path.resolve(registration.source) !== path.resolve(staged.desired.marketplaceRoot)) {
-                await protocol.removeManagedSource?.(registration.source);
-            }
-        }
-        await protocol.retireDirectDelivery?.(homeDir);
-        await staged.finalize?.();
-        return await protocol.inspectInventory(homeDir);
-    }
-    catch (error) {
-        if (!activated && staged !== undefined) {
-            try {
-                await staged.rollback();
-            }
-            catch {
-                // The original failure is the actionable phase; rollback is best effort.
-            }
-        }
-        if (error instanceof HarnessLifecycleError)
-            throw error;
-        throw new HarnessLifecycleError(protocol.host, phase, retryCommand, error);
-    }
-}
-export async function reconcileUninstall(homeDir, protocol) {
-    const inventory = await protocol.inspectInventory(homeDir);
-    const root = protocol.managedRoot(homeDir);
-    const pluginName = protocol.pluginId.split('@', 1)[0];
-    for (const registration of inventory.marketplaces) {
-        if (!registration.local || !containsPath(root, registration.source))
-            continue;
-        for (const pluginId of registration.pluginIds ?? [`${pluginName}@${registration.name}`]) {
-            await protocol.removePlugin(homeDir, pluginId, registration.name);
-        }
-        await protocol.removeMarketplace(homeDir, registration.name);
-        await protocol.removeManagedSource?.(registration.source);
-    }
-    await protocol.retireDirectDelivery?.(homeDir);
-    await protocol.removeManagedRoot?.(homeDir);
-}
-export function staleManagedRegistrations(inventory, managedRoot, desired) {
-    return staleRegistrations(inventory, managedRoot, desired);
-}

package/dist/square-store.js

@@ -1,111 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { setTimeout as sleep } from 'node:timers/promises';
-import { emptyRuntimeState, loadSquare, renderSquareDoc, saveRuntimeSidecar } from './artifact.js';
-import { SquareError } from './model.js';
-import { LOCK_RETRY_MS, LOCK_STALE_MS, touchPresenceCursor } from './runtime.js';
-/**
- * The persistence boundary for Square documents. Callers may derive a plan from
- * a loaded document, but only the store indexes acts and writes artifact/runtime
- * state while the per-square lock is held.
- */
-export class SquareStore {
-    async transact(squarePath, operation) {
-        return withSquareLock(squarePath, async () => operation(loadSquare(squarePath)));
-    }
-    /** Recovery paths inspect raw text under the store lock before publishing a repair. */
-    async transactText(squarePath, operation) {
-        return withSquareLock(squarePath, async () => {
-            try {
-                return await operation(fs.readFileSync(squarePath, 'utf8'));
-            }
-            catch (error) {
-                if (error.code === 'ENOENT') {
-                    throw new SquareError('not_found', `square file not found: ${squarePath}`);
-                }
-                throw error;
-            }
-        });
-    }
-    /** Create the initial artifact under the same per-square lock as later commits. */
-    async create(squarePath, options) {
-        return withSquareLock(squarePath, () => {
-            if (fs.existsSync(squarePath) && !options.force) {
-                throw new SquareError('conflict', `Refusing to overwrite existing square: ${squarePath}\nPass -f to overwrite.`);
-            }
-            const dir = path.dirname(squarePath);
-            const base = path.basename(squarePath);
-            const temporary = path.join(dir, `.${base}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`);
-            fs.mkdirSync(dir, { recursive: true });
-            fs.writeFileSync(temporary, options.text);
-            fs.renameSync(temporary, squarePath);
-            saveRuntimeSidecar(squarePath, emptyRuntimeState(0));
-            return options.result;
-        });
-    }
-    apply(doc, acts, mutateRuntime) {
-        const indexed = [];
-        for (const act of acts) {
-            const stored = { ...act, index: doc.runtime.nextActIndex };
-            doc.runtime.nextActIndex += 1;
-            doc.acts.push(stored);
-            if (stored.actor !== undefined) {
-                touchPresenceCursor(doc, stored.actor, stored.at, stored.kind === 'join' ? 'join' : 'api', stored.index);
-            }
-            indexed.push({ act: stored, index: stored.index });
-        }
-        mutateRuntime?.(doc.runtime);
-        return { acts: indexed };
-    }
-    commitOnce(squarePath, doc, result) {
-        writeSquareDoc(squarePath, doc);
-        return result;
-    }
-}
-export const squareStore = new SquareStore();
-export function writeSquareDoc(squarePath, doc) {
-    const dir = path.dirname(squarePath);
-    const base = path.basename(squarePath);
-    const tempPath = path.join(dir, `.${base}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`);
-    fs.writeFileSync(tempPath, renderSquareDoc(doc));
-    fs.renameSync(tempPath, squarePath);
-    saveRuntimeSidecar(squarePath, doc.runtime);
-}
-export function appendAct(squarePath, doc, act) {
-    const applied = squareStore.apply(doc, [act]);
-    squareStore.commitOnce(squarePath, doc, undefined);
-    return applied.acts[0].act;
-}
-export async function withSquareLock(squarePath, fn) {
-    const lockPath = `${squarePath}.lock`;
-    const lockDir = path.dirname(lockPath);
-    fs.mkdirSync(lockDir, { recursive: true });
-    while (true) {
-        try {
-            const fd = fs.openSync(lockPath, 'wx');
-            fs.writeFileSync(fd, `${process.pid}\n${Date.now()}\n`, 'utf8');
-            fs.closeSync(fd);
-            try {
-                return await fn();
-            }
-            finally {
-                try {
-                    fs.unlinkSync(lockPath);
-                }
-                catch { }
-            }
-        }
-        catch (err) {
-            const errno = err;
-            if (errno.code !== 'EEXIST')
-                throw err;
-            try {
-                const stat = fs.statSync(lockPath);
-                if (Date.now() - stat.mtimeMs > LOCK_STALE_MS)
-                    fs.unlinkSync(lockPath);
-            }
-            catch { }
-            await sleep(LOCK_RETRY_MS);
-        }
-    }
-}

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`;
-}