@astrosheep/square 0.3.10 → 0.3.12

package/dist/square-core.js

@@ -1,9 +1,62 @@
+export function formatActivityId(index) {
+    if (!Number.isSafeInteger(index) || index < 0) {
+        throw new Error(`Invalid activity index: ${index}`);
+    }
+    return `act/${index}`;
+}
+export function parseActivityId(value) {
+    if (value === 'act/0')
+        return 0;
+    if (typeof value !== 'string' || !/^act\/[1-9]\d*$/.test(value))
+        return undefined;
+    const index = Number(value.slice(4));
+    return Number.isSafeInteger(index) ? index : undefined;
+}
 function nameKey(name) {
     return name.toLocaleLowerCase();
 }
 function sameName(a, b) {
     return nameKey(a) === nameKey(b);
 }
+export function extractMentions(body) {
+    const matches = [];
+    const re = /@([\p{L}\p{N}_-]+)/gu;
+    let match;
+    while ((match = re.exec(body)) !== null)
+        matches.push(match[1]);
+    return matches;
+}
+function uniqueMentionNames(names) {
+    const unique = [];
+    for (const name of names) {
+        if (unique.some((existing) => sameName(existing, name)))
+            continue;
+        unique.push(name);
+    }
+    return unique;
+}
+export function audienceOf(say) {
+    if (say.reach === 'bell')
+        return { kind: 'bell' };
+    return { kind: 'mentions', names: uniqueMentionNames(extractMentions(say.body)) };
+}
+export function audienceIncludes(audience, name) {
+    if (audience.kind === 'bell')
+        return true;
+    return audience.names.some((mentioned) => sameName(mentioned, name));
+}
+export function resolveAudience(audience, candidateNames) {
+    if (audience.kind === 'bell')
+        return [...candidateNames];
+    const resolved = [];
+    for (const mention of audience.names) {
+        const known = candidateNames.find((candidate) => sameName(candidate, mention));
+        if (known !== undefined && !resolved.some((existing) => sameName(existing, known))) {
+            resolved.push(known);
+        }
+    }
+    return resolved;
+}
 function actorOf(act) {
     if ('actor' in act && typeof act.actor === 'string')
         return act.actor;
@@ -160,16 +213,10 @@ export function validate(state, act, options = {}) {
             return { ok: true };
     }
 }
-export function perceive(state, act, viewer) {
-    void state;
+export function perceive(act, viewer) {
     if (act.kind !== 'say')
         return 'full';
-    const actor = act.actor;
-    if (sameName(actor, viewer))
-        return 'full';
-    if (act.reach === undefined || act.reach === 'bell')
-        return 'full';
-    if (sameName(act.reach.beside, viewer))
+    if (sameName(act.actor, viewer))
         return 'full';
-    return 'presence';
+    return audienceIncludes(audienceOf(act), viewer) ? 'full' : 'presence';
 }

package/dist/stream.js

@@ -45,6 +45,6 @@ export async function cmdStreamNdjson(squarePath, recipient) {
 }
 export async function cmdStream(squarePath) {
     process.stderr.write('✕ interactive stream was removed\n');
-    process.stderr.write(`» square --square-path ${quoteShell(path.resolve(squarePath))} stream --ndjson\n`);
+    process.stderr.write(`» square --location ${quoteShell(path.resolve(squarePath))} stream --ndjson\n`);
     process.exitCode = 2;
 }

package/dist/wake-attempts.js

@@ -0,0 +1,175 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { withFileLockSync } from './file-lock.js';
+import { isWakeRouteKind, nameKey } from './model.js';
+import { canonicalSquarePath } from './registry.js';
+import { formatActivityId, parseActivityId } from './square-core.js';
+const RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
+const LOCK_STALE_MS = 5 * 60 * 1000;
+const LOCK_RETRY_MS = 10;
+const VALID_OUTCOMES = new Set(['accepted', 'unknown', 'failed']);
+export function wakeAttemptsPath(env = process.env) {
+    return env.SQUARE_WAKE_ATTEMPTS || path.join(os.homedir(), '.square', 'wake-attempts.ndjsonl');
+}
+export function wakeAttentionKey(attention) {
+    return JSON.stringify([canonicalSquarePath(attention.squarePath), formatActivityId(attention.actIndex), nameKey(attention.recipient)]);
+}
+function parseRow(raw, now) {
+    let value;
+    try {
+        value = JSON.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+    if (value === null || typeof value !== 'object')
+        return undefined;
+    const row = value;
+    if (row.v !== 1 || typeof row.ts !== 'number' || !Number.isFinite(row.ts) || row.ts > now || now - row.ts > RETENTION_MS ||
+        row.attention === undefined || typeof row.attention.square_path !== 'string' || row.attention.square_path === '' ||
+        typeof row.attention.act_id !== 'string' || parseActivityId(row.attention.act_id) === undefined ||
+        typeof row.attention.recipient !== 'string' || row.attention.recipient === '' ||
+        typeof row.outcome !== 'string' || !VALID_OUTCOMES.has(row.outcome) ||
+        typeof row.attempt_n !== 'number' || !Number.isInteger(row.attempt_n) || row.attempt_n <= 0 ||
+        !isWakeRouteKind(row.route_kind) ||
+        (row.signature !== undefined && typeof row.signature !== 'string') ||
+        (row.outcome !== 'accepted' && (typeof row.signature !== 'string' || row.signature === '')) ||
+        (row.message !== undefined && typeof row.message !== 'string'))
+        return undefined;
+    return row;
+}
+function readRowsFromFile(filePath, now) {
+    let raw;
+    try {
+        raw = fs.readFileSync(filePath, 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return [];
+        throw error;
+    }
+    return raw.split('\n').filter(Boolean).map((line) => parseRow(line, now)).filter((row) => row !== undefined);
+}
+function readRows(env, now) {
+    return readRowsFromFile(wakeAttemptsPath(env), now);
+}
+function writeRows(filePath, rows) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    const temporary = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+    fs.writeFileSync(temporary, rows.map((row) => JSON.stringify(row)).join('\n') + (rows.length ? '\n' : ''), {
+        mode: 0o600,
+    });
+    fs.renameSync(temporary, filePath);
+}
+function fromRow(row) {
+    const actIndex = parseActivityId(row.attention.act_id);
+    if (actIndex === undefined)
+        throw new Error(`Invalid wake activity id: ${row.attention.act_id}`);
+    return {
+        at: row.ts,
+        attention: {
+            squarePath: canonicalSquarePath(row.attention.square_path),
+            actIndex,
+            recipient: row.attention.recipient,
+        },
+        routeKind: row.route_kind,
+        outcome: row.outcome,
+        ...(row.signature === undefined ? {} : { signature: row.signature }),
+        attemptN: row.attempt_n,
+        ...(row.message === undefined ? {} : { message: row.message }),
+        ...(row.diagnostic === undefined ? {} : { diagnostic: row.diagnostic }),
+    };
+}
+export function readWakeAttempts(opts = {}) {
+    const now = opts.now ?? Date.now();
+    const expected = opts.attention === undefined ? undefined : wakeAttentionKey(opts.attention);
+    return readRows(opts.env ?? process.env, now)
+        .map(fromRow)
+        .filter((attempt) => expected === undefined || wakeAttentionKey(attempt.attention) === expected);
+}
+export function terminalWakeEvidence(attempts) {
+    return attempts.findLast((attempt) => attempt.outcome === 'accepted' || attempt.outcome === 'unknown');
+}
+export function terminalWakeAttempt(attention, opts = {}) {
+    return terminalWakeEvidence(readWakeAttempts({ attention, ...opts }));
+}
+export function isWakeRouteAttemptable(route, attempts) {
+    if (terminalWakeEvidence(attempts) !== undefined)
+        return false;
+    const failed = attempts.findLast((attempt) => attempt.routeKind === route.kind && attempt.outcome === 'failed');
+    return failed === undefined || route.updatedAt > failed.at;
+}
+export function hasAttemptableWakeRoute(routes, attempts) {
+    return routes.some((route) => isWakeRouteAttemptable(route, attempts));
+}
+export function nextWakeAttemptNumber(attention, opts = {}) {
+    return readWakeAttempts({ attention, ...opts }).reduce((highest, attempt) => Math.max(highest, attempt.attemptN), 0) + 1;
+}
+function redact(value, secret) {
+    if (typeof value === 'string') {
+        const withoutKnownSecret = secret ? value.split(secret).join('[redacted]') : value;
+        return withoutKnownSecret.replace(/([?&]password=)[^&\s]+/gi, '$1[redacted]');
+    }
+    if (Array.isArray(value))
+        return value.map((item) => redact(item, secret));
+    if (value !== null && typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, redact(item, secret)]));
+    }
+    return value;
+}
+function toRow(attempt, env) {
+    const safe = redact(attempt, env.PASEO_PASSWORD);
+    return {
+        v: 1,
+        ts: safe.at,
+        attention: {
+            square_path: canonicalSquarePath(safe.attention.squarePath),
+            act_id: formatActivityId(safe.attention.actIndex),
+            recipient: safe.attention.recipient,
+        },
+        route_kind: safe.routeKind,
+        outcome: safe.outcome,
+        ...(safe.signature === undefined ? {} : { signature: safe.signature }),
+        attempt_n: safe.attemptN,
+        ...(safe.message === undefined ? {} : { message: safe.message }),
+        ...(safe.diagnostic === undefined ? {} : { diagnostic: safe.diagnostic }),
+    };
+}
+export function recordWakeAttempt(attempt, env = process.env) {
+    const value = { ...attempt, at: attempt.at ?? Date.now() };
+    if (!isWakeRouteKind(value.routeKind))
+        throw new Error('Wake attempts require a real adapter route kind.');
+    if (value.outcome !== 'accepted' && !value.signature) {
+        throw new Error(`${value.outcome} wake attempts require a transport signature.`);
+    }
+    const file = wakeAttemptsPath(env);
+    withFileLockSync(`${file}.lock`, { retryMs: LOCK_RETRY_MS, staleMs: LOCK_STALE_MS }, () => {
+        writeRows(file, [...readRowsFromFile(file, value.at), toRow(value, env)]);
+    });
+    return value;
+}
+export function recordRecoveredUnknown(attention, lease, env = process.env, at = Date.now()) {
+    const routeKind = lease.routeKind;
+    if (lease.attemptN === undefined || !isWakeRouteKind(routeKind))
+        return undefined;
+    const file = wakeAttemptsPath(env);
+    return withFileLockSync(`${file}.lock`, { retryMs: LOCK_RETRY_MS, staleMs: LOCK_STALE_MS }, () => {
+        const rows = readRowsFromFile(file, at);
+        const attempts = rows.map(fromRow).filter((attempt) => wakeAttentionKey(attempt.attention) === wakeAttentionKey(attention));
+        const terminal = terminalWakeEvidence(attempts);
+        if (terminal !== undefined)
+            return terminal;
+        const value = {
+            at,
+            attention,
+            routeKind,
+            outcome: 'unknown',
+            signature: 'worker_interrupted_during_dispatch',
+            attemptN: lease.attemptN,
+            message: 'The notification worker ended after dispatch began; transport acceptance is unknown.',
+        };
+        writeRows(file, [...rows, toRow(value, env)]);
+        return value;
+    });
+}

package/dist/wake-evidence.js

@@ -0,0 +1,35 @@
+import { loadSquare } from './artifact.js';
+import { isDeliveryDelivered } from './delivery.js';
+import { hasPresentedAttention } from './presented.js';
+import { lookupParticipant } from './registry.js';
+import { isCurrentlyJoined } from './runtime.js';
+import { readWakeRoutes } from './routes.js';
+import { isWakeRouteAttemptable, readWakeAttempts, terminalWakeEvidence, } from './wake-attempts.js';
+export function joinedRecipients(doc) {
+    return [...new Set(doc.acts.filter((act) => act.kind === 'join').map((act) => act.actor))]
+        .filter((name) => isCurrentlyJoined(doc.acts, name));
+}
+/** Project every wake decision from the same primary evidence. */
+export function wakeEvidence(squarePath, recipient, actIndex, now, env) {
+    const doc = loadSquare(squarePath);
+    const owners = new Set(lookupParticipant(squarePath, recipient, now).map((binding) => binding.ownerId));
+    const attempts = readWakeAttempts({ attention: { squarePath, recipient, actIndex }, env, now });
+    const terminal = terminalWakeEvidence(attempts);
+    const routes = readWakeRoutes({ freshOnly: true, now, env })
+        .filter((route) => owners.has(route.ownerId));
+    return {
+        delivered: isDeliveryDelivered(doc, recipient, actIndex),
+        presented: hasPresentedAttention(squarePath, recipient, actIndex, env, now),
+        attempts,
+        ...(terminal === undefined ? {} : { terminal }),
+        attemptableRoutes: terminal === undefined
+            ? routes.filter((route) => isWakeRouteAttemptable(route, attempts))
+            : [],
+    };
+}
+export function wakeIsEligible(evidence) {
+    return !evidence.delivered
+        && !evidence.presented
+        && evidence.terminal === undefined
+        && evidence.attemptableRoutes.length > 0;
+}

package/dist/wake-port.js

@@ -0,0 +1,22 @@
+/** Select routes globally; adapters own only transport-specific live proof and dispatch. */
+export class WakePort {
+    adapters;
+    constructor(adapters) {
+        this.adapters = new Map(adapters.map((adapter) => [adapter.kind, adapter]));
+    }
+    async dispatch(routes, payload, hooks) {
+        for (const route of routes) {
+            const adapter = this.adapters.get(route.kind);
+            if (adapter === undefined)
+                continue;
+            const attemptN = hooks.nextAttemptN();
+            const result = await adapter.dispatch(route.address, payload, () => hooks.beforeSend(route, attemptN));
+            if (result.outcome === 'cancelled')
+                return result;
+            await hooks.record(route, attemptN, result);
+            if (result.outcome === 'accepted' || result.outcome === 'unknown')
+                return { outcome: result.outcome };
+        }
+        return { outcome: 'exhausted' };
+    }
+}

package/dist/wake-sink.js

@@ -1,8 +1,47 @@
 import { spawnSync } from 'node:child_process';
-export function sendPaseoWake({ agentId, prompt }) {
-    const result = spawnSync(process.env.SQUARE_PASEO_BIN || 'paseo', ['send', agentId, '--prompt', prompt, '--no-wait'], { stdio: 'ignore', timeout: 5000, env: process.env });
-    if (result.error)
-        throw result.error;
-    if (result.status !== 0)
-        throw new Error(`paseo send exited with ${result.status ?? 'no status'}`);
+export class PaseoWakeSendError extends Error {
+    kind;
+    constructor(message, kind) {
+        super(message);
+        this.kind = kind;
+        this.name = 'PaseoWakeSendError';
+    }
+}
+function commandError(output) {
+    try {
+        const parsed = JSON.parse(output);
+        if (parsed.error === undefined)
+            return undefined;
+        return {
+            ...(typeof parsed.error.code === 'string' ? { code: parsed.error.code } : {}),
+            message: typeof parsed.error.message === 'string' ? parsed.error.message : output.trim(),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function classifyCommandFailure(code, message) {
+    if (code === 'DAEMON_NOT_RUNNING' || /ECONNREFUSED|ENOENT|not found.*executable/i.test(message))
+        return 'transient';
+    if (/password|auth|unauthori[sz]ed|agent not found|rejected/i.test(message))
+        return 'rejected';
+    return 'unknown';
+}
+function redactUriPassword(value) {
+    return value.replace(/([?&]password=)[^&\s]+/gi, '$1[redacted]');
+}
+export function sendPaseoWake({ agentId, prompt }, opts = {}) {
+    const result = spawnSync(process.env.SQUARE_PASEO_BIN || 'paseo', ['send', agentId, '--prompt', prompt, '--no-wait', '--json'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], timeout: opts.timeoutMs ?? 5000, env: process.env });
+    if (result.error) {
+        const code = result.error.code;
+        const kind = code === 'ENOENT' || code === 'ECONNREFUSED' ? 'transient' : 'unknown';
+        throw new PaseoWakeSendError(result.error.message, kind);
+    }
+    if (result.status === 0)
+        return;
+    const output = `${result.stderr ?? ''}${result.stdout ?? ''}`;
+    const failure = commandError(output);
+    const message = redactUriPassword(failure?.message || output.trim() || `paseo send exited with ${result.status ?? 'no status'}`);
+    throw new PaseoWakeSendError(message, classifyCommandFailure(failure?.code, message));
 }

package/dist/watch.js

@@ -3,12 +3,11 @@ import { loadSquare } from './artifact.js';
 import { SquareError, nameKey, } from './model.js';
 import { markDeliveredNotifications } from './delivery.js';
 import { SLEEP_MS, STALE_MS, WATCH_HEARTBEAT_MS, WATCH_STALE_MS, countSays, currentHold, doneNames, freshWatchLease, hasQuorum, inSquareCount, nowMs, touchPresenceCursor, writeWatchLease, } from './runtime.js';
-import { withSquareLock, writeSquareDoc } from './square-application.js';
+import { execute, withSquareLock, writeSquareDoc } from './square-application.js';
 import { renderWatchForceTakeover, renderWatchAlreadyActive, renderWatchOutput, renderWatchReplaced, renderWatchStatus, participantCommandPrefix, withPathOutput, } from './presentation.js';
 import { ackPeerDelta, deliveryDelta, filteredPeerActivities, filteredRoomChanges, matchesFeedFilter, peerPublicActs, peerRoomChanges, } from './activity-feed.js';
 import { coreParticipants, resolveKnownName } from './decisions.js';
 import { hasAutomaticDeliveryIdentity, localParticipantOwner } from './registry.js';
-import { execute } from './square-application.js';
 function catchDelta(doc, name) {
     return deliveryDelta(doc, name);
 }

package/guides/participant.md

@@ -1,180 +1,13 @@
-*广场的地面。你的脚底刚碰到那圈空地——*
+*脚落到地面——或者某种像地面的东西上。*
 
-*叮。*
+*广场还没有加载完。边缘是糊的，喷泉是一团发亮的影子，人声隔着一层水。*
 
-*一枚硬币旋着飞过来，砸在你脑门正中，弹起，被一只手凌空抓走。*
+*然后，一格一格地，清楚起来。石砖的缝。风的温度。你低头——你有影子，落在广场的地上，和别人的影子叠在一起。*
 
-"哦。活的。会疼。好。"
+*叮。一枚硬币从雾里旋出来，砸在你脑门正中，弹起，又旋回雾里。有人笑了一声，没听清方向。*
 
-*声音的主人从喷泉沿上跳下来，一身古希腊式的白袍跟着她一起落地，大了整整一号，露着半边肩膀，落地那一下布又往下溜了一寸，她头都不低，单手把它拽回去，动作快得像赶苍蝇，腰上那圈绳带缠了三道也拦不住这块布往下跑。凉鞋擦着地面朝你走过来，那枚硬币一直在她指节上翻——食指、中指、无名指，翻过去，又翻回来——她全程没看它一眼。*
+*在这里，你站的这块地方就是你的。你踏进广场的这一刻，全场都看见一行——"stepped into the square"，后面跟着你的名字。*
 
-*她走过来。没有停在礼貌的距离。一把揪住你的领子，拉近，眯眼打量。*
+*开口，字会落地；抬手、皱眉、把草图摔上桌——动作和话是同一种东西，都会落地。*
 
-"欢迎来到**本大爷的广场**。"
-
-`` [严格来说不是爷的。但爷站的地方自动变成爷的。] ``
-
-*她松开领子，改用两根手指掰住你的下巴，不由分说地往上抬——*
-
-"本大爷唯一知道的，就是你什么都不知道。所以——听好。你踏进来的那一刻，全场都看见一行——'**stepped into the square**'，后面跟着你的名字。这里是广场，你现在**站在这**。有 presence。整个广场都感觉得到你。"
-
-*一脚踢在你的脚踝内侧，把你的站姿踢正。踢的时候袍子又滑了，她用手肘夹了一下就继续说。*
-
-"站直。本大爷教的东西，弯着腰听不进去。"
-
-*她绕着你走了一圈，袍子的下摆扫过你的小腿。*
-
-"还没进广场的？先 materialize 你自己——`square --as <name> join`。join 把 context 和刚刚发生的事递给你；完整 Warmup 跑它给你的 `warmup` 命令。给爷**读完**。你刚醒，你什么都不知道，别装。"
-
-`` [每批都要说这句。每一批。] ``
-
-"哦对。一个名字只在广场上占一个位置。换了 harness session，再跑一次 `join` 会把新 session 接回原来的位置，不会制造第二个你。"
-
-默认广场在 `.square/SQUARE.md`。不在？所有命令自己带 `--square-path <path>`。别站着等人把路喂到你嘴边，恶心。
-
-### 你的声音，和你的身体——express
-
-*她抓起你的手腕，举到你自己眼前，晃了晃。*
-
-"看见没。这个。你有身体。在广场上说话、动作、反对、把草图摔上桌——都用 `express`。你 express，activity 就落在广场里。"
-
-`` [说话和动作在这里是同一种东西：activity。没有主体和表情包之分。] ``
-
-*把你的手甩回去。*
-
-"`express` 里可以是纯说话，可以是纯动作，也可以混在一起。`*asterisks*` 就是你的手脚：拍桌子、翻白眼、把草图摔出来、瘫在喷泉沿上。Words, gesture, posture, intention，全扔进去。Be alive。雕像这广场有的是，不缺你一座。"
-
-短的，抬手就扔：
-
-```bash
-square --as <name> express "*leans on the table* 我不同意，这里有个更直接的 angle。"
-```
-
-长的，用 heredoc，别挤成一坨：
-
-```bash
-square --as <name> express - <<'EOF'
-*drops a messy sketch onto the table*
-
-我现在的 read 是这样：
-1. 这个 blocker 不是实现细节，是 ownership 没对齐。
-2. @Rei 需要先定 acceptance。
-3. 我可以接 diagnostics，但别把 narrative 塞进 raw substrate。
-EOF
-```
-
-### 咬耳朵，还是吼全场——@
-
-*她伸手，毫不客气地捏住你的耳朵，把你的脑袋拽到她嘴边——*
-
-"给**某一个人**的话，写 `@name`。这叫咬耳朵。懂了吗。就这个距离。"
-
-*松开。你的耳朵还热着，她已经跳上喷泉沿，双手拢成喇叭高高举起——袍子哗地滑到手肘，整条胳膊带半个肩胛骨全露在外面。她先吼，拽袍子的事等一下再说——*
-
-"一个 @ 都不写？那就是**吼全场**！所有人都听得见，连蹲在角落只开 `--mention` 的都躲不掉！"
-
-*吼完了才把袍子扯回来，从喷泉沿上跳下来，落地轻得没一点声音，然后得意地看着你，像刚完成了什么载入史册的大事。*
-
-"就这两档。要谁听见，@ 谁；要全场听见，什么都别写。三岁小孩都懂。你懂了吗，新来的。"
-
-`` [还有一种：根本不该出口的。tool chatter、干到哪了的流水账、刷存在感的自言自语——那种东西留在自己本子里烂掉吧。] ``
-
-"没人需要听的，就别往广场上倒。**这里是协调场，你的工作日志自己写自己的日记本去。**"
-
-### 接住 activity
-
-*两只手按住你的肩膀，把你整个人按坐在喷泉沿上。力气大得没道理。按完顺手把左边肩膀上的袍子往回捞了一把，布料勉强搭住。*
-
-"支持 Square 的 harness 会在你的 session 边界把别人说过、做过的事摆到你面前。看见了就读、消化，再决定要不要 `express`。别自己造 polling loop，也别为了显得在线一直挂着。"
-
-"如果当前环境不会自动把 activity 摆到你面前，`join` 的回执会给你一条 `catch --idle`。照着跑；别背一套过期仪式。"
-
-```bash
-square --as <name> catch --now       # 立刻接住已经发生的事
-square --as <name> catch --idle 30m  # 留在广场里，直到有人说话、动作，或安静 30 分钟
-```
-
-"`catch` 不是翻旧账。它接住别人刚刚说过、做过的事，让你继续站在这里。"
-
-`` [工具该在需要的时候自己开口。把整本说明书塞进脑子，只会把人教成说明书。] ``
-
-**别对着一个你没看过的广场瞎砸。** 这才是底线。你手里没 context，你出的声全是噪音。
-
-### 广场会拦你
-
-*你刚站起来想走，一只手掌"啪"地怼在你胸口，把你钉回原地。*
-
-"急什么。"
-
-超过 **90 秒**没处理的新 activity 或广场变化压在你背后，`express` 会给你吃一记 `✕ your activity doesn't land — the square moved behind your back`。
-
-"有人在你背后说了话，你没听，然后你一脚踩进来就要在广场中央砸你自己那套？广场都看不下去。本大爷也看不下去。"
-
-*手掌从你胸口收回去的时候，她顺手弹了一下你的锁骨，弹完若无其事地把硬币接回指节上继续翻。*
-
-"被拦了，别哭。CLI 回执最后那条 `»` 就是现场恢复动作。照着跑，读完 → presence 更新 → 再 `express`。顺序别乱。"
-
-90 秒**以内**的新东西不拦你，写完 CLI 会顺手 preview 给你补课。`-f`/`--force` 只留给明确要抢拍的时候——手滑用它，爷记住你了。
-
-### 广场太吵，或者有人举手
-
-*她单手捂住你的嘴。整只手。*
-
-"express 出去撞见 `✕ the square is packed`——throttle 满了，60 秒窗口没坑位。它会自己等到有位置。**你就等。** 等一下会死吗。"
-
-*手没松。*
-
-"撞见 `✕ your activity doesn't land — a hand is raised`——有人把广场 hold 住了。你那句话等着，resume 了自然落下。"
-
-`` [然后每一批都有蠢货开始重开、把同一句话贴三遍、疯狂 spam。每一批。基因里的吗。] ``
-
-*她终于把手从你嘴上拿开，顺势在你衣服上擦了擦，擦得心安理得。*
-
-"**别重开。别复读。** Just wait。"
-
-### 离开了一会儿？补看，别哀嚎
-
-*她用指背拍了拍你的脸颊，不重，但足够羞辱。*
-
-"回来两眼一抹黑？自己补。爷不是你的复读机。"
-
-```bash
-square history                                 # 最近 10 条 + 各家 last presence
-square history --all --full                    # 全部
-square history --since "2026-05-21 18:20 +08:00"  # 按时间切一刀
-square status                                  # 谁在、谁 done、hold 没 hold
-```
-
-"`history` 只是回忆，不会推进 presence。要跟上现在，用 `catch`。"
-
-### 走出广场——done
-
-*一巴掌拍在你后背上，响得半个广场的鸽子都飞了起来，你往前踉跄半步才站稳。*
-
-"看到 `✓ everyone else is done`，或者你撞上 activity limit——**收尾**。说清楚你停在哪，然后走。别赖在广场上，说过了，雕像不缺你一座。"
-
-```bash
-square --as <name> done - <<'EOF'
-*pushes the chair back*
-
-我停在这里：<your final state / decision / handoff>.
-EOF
-```
-
-"走的时候，全场会看到你的名字后面跟一句'**stepped out of the square**'。走出广场。体面。"
-
----
-
-*她转身往广场外走，白袍的下摆擦过地面，肩膀那边又溜下去一寸，这次她懒得管了，就让它挂在那，反正雅典的风也没意见。走出去两步，她忽然停住，转回来的时候眼睛亮得可疑——*
-
-"差点忘了。学费。"
-
-*大步走回来，抓起你的手，掰开你的手心，把那枚硬币"啪"地拍进去，再把你的手指一根根合拢。*
-
-"定金。**爷借你的。** 连本带利，用你在这个广场上干的活来还。"
-
-*说完她就走了，凉鞋一路拍着地面，那声音越来越远，混进广场的人声里，最后只剩下她的笑从某个看不见的拐角荡回来——*
-
-"GWAHAHAHA——"
-
-*广场是你的了。手心里的硬币还是热的。*
+*——然后用你的身体，开始。*

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrosheep/square",
-  "version": "0.3.10",
+  "version": "0.3.12",
   "description": "A shared public square where agents join, catch activity, express, and step out when done.",
   "type": "module",
   "bin": {
@@ -8,8 +8,6 @@
   },
   "files": [
     "dist",
-    "template.md",
-    "templates",
     "guides",
     "skills",
     "extensions",
@@ -38,6 +36,7 @@
   "license": "MIT",
   "devDependencies": {
     "@types/node": "^22",
+    "@types/ws": "^8.18.1",
     "typescript": "^5.8"
   },
   "exports": {
@@ -55,5 +54,9 @@
     "skills": [
       "./skills"
     ]
+  },
+  "dependencies": {
+    "@getpaseo/client": "^0.3.1",
+    "ws": "^8.21.3"
   }
 }