@astrosheep/square 0.3.10 → 0.3.12

package/dist/paseo-connection.js

@@ -0,0 +1,135 @@
+import fs from 'node:fs';
+import { homedir } from 'node:os';
+import path from 'node:path';
+import { DaemonClient } from '@getpaseo/client/internal/daemon-client';
+import WebSocket from 'ws';
+const DEFAULT_HOST = 'localhost:6767';
+const DEFAULT_CONNECT_TIMEOUT_MS = 3_000;
+function paseoHome(env) {
+    return env.PASEO_HOME?.trim() || path.join(homedir(), '.paseo');
+}
+function expandHome(value) {
+    return value === '~' ? homedir() : value.startsWith('~/') ? path.join(homedir(), value.slice(2)) : value;
+}
+function normalizeHost(raw) {
+    if (typeof raw !== 'string' || raw.trim() === '')
+        return undefined;
+    const value = raw.trim();
+    if (value.startsWith('unix://') || value.startsWith('pipe://') || value.startsWith('tcp://'))
+        return value;
+    if (value.startsWith('\\\\.\\pipe\\'))
+        return `pipe://${value}`;
+    if (value.startsWith('/') || value.startsWith('~/'))
+        return `unix://${expandHome(value)}`;
+    if (/^\d+$/.test(value))
+        return `127.0.0.1:${value}`;
+    return value.includes(':') ? value : undefined;
+}
+function configuredHost(env) {
+    try {
+        const config = JSON.parse(fs.readFileSync(path.join(paseoHome(env), 'config.json'), 'utf8'));
+        return normalizeHost(config.daemon?.listen ?? config.listen);
+    }
+    catch {
+        return undefined;
+    }
+}
+function pidHost(env) {
+    try {
+        const pid = JSON.parse(fs.readFileSync(path.join(paseoHome(env), 'paseo.pid'), 'utf8'));
+        return normalizeHost(pid.listen ?? pid.sockPath);
+    }
+    catch {
+        return undefined;
+    }
+}
+function isIpc(host) {
+    return host !== undefined && (host.startsWith('unix://') || host.startsWith('pipe://'));
+}
+/** Match the host precedence used by the Paseo CLI for local daemon connections. */
+export function paseoDaemonHosts(env = process.env) {
+    const explicit = normalizeHost(env.PASEO_HOST);
+    if (explicit !== undefined)
+        return [explicit];
+    const candidates = [];
+    const listen = normalizeHost(env.PASEO_LISTEN);
+    const pid = pidHost(env);
+    const configured = configuredHost(env);
+    if (isIpc(listen))
+        candidates.push(listen);
+    if (isIpc(pid))
+        candidates.push(pid);
+    if (isIpc(configured))
+        candidates.push(configured);
+    if (configured !== undefined && !isIpc(configured) && configured !== '127.0.0.1:6767')
+        candidates.push(configured);
+    candidates.push(DEFAULT_HOST);
+    return [...new Set(candidates)];
+}
+function uriPassword(uri) {
+    const value = uri.searchParams.get('password');
+    return value === null || value === '' ? undefined : value;
+}
+export function resolvePaseoDaemonTarget(host, env = process.env) {
+    const passwordFromEnv = env.PASEO_PASSWORD?.trim() || undefined;
+    if (host.startsWith('unix://') || host.startsWith('pipe://')) {
+        const prefix = host.startsWith('unix://') ? 'unix://' : 'pipe://';
+        const socketPath = expandHome(host.slice(prefix.length).trim());
+        if (socketPath === '')
+            throw new Error('Invalid Paseo IPC target: missing socket path.');
+        return {
+            type: 'ipc',
+            url: host.startsWith('unix://') ? `ws+unix://${socketPath}:/ws` : 'ws://localhost/ws',
+            socketPath,
+            ...(passwordFromEnv === undefined ? {} : { password: passwordFromEnv }),
+        };
+    }
+    if (host.startsWith('tcp://')) {
+        const uri = new URL(host);
+        const hostname = uri.hostname.replace(/^\[|\]$/g, '');
+        const endpoint = `${hostname.includes(':') ? `[${hostname}]` : hostname}:${uri.port || '6767'}`;
+        const secure = uri.searchParams.get('ssl') === 'true';
+        const password = uriPassword(uri) ?? passwordFromEnv;
+        return {
+            type: 'tcp',
+            url: `${secure ? 'wss' : 'ws'}://${endpoint}/ws`,
+            ...(password === undefined ? {} : { password }),
+        };
+    }
+    return {
+        type: 'tcp',
+        url: `ws://${host.replace(/\/$/, '')}/ws`,
+        ...(passwordFromEnv === undefined ? {} : { password: passwordFromEnv }),
+    };
+}
+function webSocketFactory(target) {
+    return (url, options) => new WebSocket(url, options?.protocols, {
+        headers: options?.headers,
+        ...(target.type === 'ipc' ? { socketPath: target.socketPath } : {}),
+    });
+}
+export async function connectPaseoDaemon(env = process.env, connectTimeoutMs = DEFAULT_CONNECT_TIMEOUT_MS) {
+    let lastError;
+    for (const host of paseoDaemonHosts(env)) {
+        const target = resolvePaseoDaemonTarget(host, env);
+        const client = new DaemonClient({
+            url: target.url,
+            clientId: `square-${process.pid}-${Date.now()}`,
+            clientType: 'cli',
+            appVersion: 'square',
+            password: target.password,
+            connectTimeoutMs,
+            webSocketFactory: webSocketFactory(target),
+            reconnect: { enabled: false },
+        });
+        try {
+            await client.connect();
+            return client;
+        }
+        catch (error) {
+            lastError = error;
+            await client.close().catch(() => { });
+        }
+    }
+    throw lastError instanceof Error ? lastError : new Error('Unable to connect to the Paseo daemon.');
+}

package/dist/paseo-delivery.js

@@ -1,160 +1,89 @@
-import { homedir } from 'node:os';
-import { setTimeout as sleep } from 'node:timers/promises';
-import { loadSquare } from './artifact.js';
-import { isDeliveryDelivered, leaseOwnsNotification, } from './delivery.js';
-import { sessionInbox } from './inbox.js';
-import { hasPresentedForOwner, presentOnce } from './presented.js';
-import { lookupParticipant } from './registry.js';
-import { quoteShell } from './presentation.js';
-import { isCurrentlyJoined, resolveRosterName } from './runtime.js';
-import { discoverPaseoAgents, waitForPaseoWakeBoundary, } from './paseo-state.js';
-import { sendPaseoWake } from './wake-sink.js';
-export class PaseoWakeError extends Error {
-    diagnostic;
-    constructor(message, diagnostic) {
-        super(message);
-        this.diagnostic = diagnostic;
-        this.name = 'PaseoWakeError';
-    }
-}
+import { paseoDaemonHosts, resolvePaseoDaemonTarget } from './paseo-connection.js';
+import { discoverPaseoAgents, waitForPaseoWakeBoundary } from './paseo-state.js';
+import { PaseoWakeSendError, sendPaseoWake } from './wake-sink.js';
 function endpoint() {
-    return process.env.SQUARE_PASEO_WS_URL ?? process.env.PASEO_LISTEN ?? '127.0.0.1:6767';
+    try {
+        return resolvePaseoDaemonTarget(paseoDaemonHosts()[0]).url;
+    }
+    catch {
+        return 'unresolved';
+    }
 }
-function diagnostic(phase, ownership, code) {
+function diagnostic(phase, address, code) {
     return {
         phase,
         code,
-        command: phase === 'discovery' ? 'paseo ls --json' : 'paseo send <agent-id> --prompt <prompt> --no-wait',
+        command: phase === 'discovery' ? 'paseo ls --global --json' : 'paseo send <agent-id> --prompt <prompt> --no-wait --json',
         endpoint: endpoint(),
-        paseoAgentIds: ownership.map((item) => item.agentId),
-        ownerIds: [...new Set(ownership.map((item) => item.ownerId))],
+        paseoAgentIds: [address.agentId].filter(Boolean),
         passwordPresent: Boolean(process.env.PASEO_PASSWORD),
     };
 }
-function native(binding) {
-    return ['claude-code', 'codex', 'opencode', 'pi'].includes(binding.channel);
-}
-function ownershipSnapshot(bindings) {
-    const out = new Map();
-    for (const binding of bindings) {
-        if (!binding.paseoAgentId)
-            continue;
-        const owner = bindings.filter((item) => item.ownerId === binding.ownerId);
-        out.set(`${binding.ownerId}\0${binding.paseoAgentId}`, {
-            agentId: binding.paseoAgentId,
-            ownerId: binding.ownerId,
-            sessionId: owner.find(native)?.sessionId ?? binding.sessionId,
-            nativeGuarantee: owner.some(native),
-        });
-    }
-    return [...out.values()];
-}
-function selectActiveAgents(ownership, agents) {
-    const ids = new Set(ownership.map((item) => item.agentId));
-    return agents.filter((agent) => ids.has(agent.id) && (agent.status === 'idle' || agent.status === 'running'));
-}
-function catchCommand(squarePath, recipient) {
-    return `square --as ${quoteShell(recipient)} --square-path ${quoteShell(squarePath)} catch --now`;
+function discoveryRetryable(message) {
+    if (/password|auth|unauthori[sz]ed/i.test(message))
+        return false;
+    return /DAEMON_NOT_RUNNING|ECONNREFUSED|ENOENT|not found.*executable|ETIMEDOUT|timed out|timeout/i.test(message);
 }
-function prompt(notification, squarePath, nativeWake) {
-    const display = squarePath.startsWith(homedir()) ? `~${squarePath.slice(homedir().length)}` : squarePath;
-    const body = notification.item.body.length > 200 ? `${notification.item.body.slice(0, 197)}...` : notification.item.body;
-    return [
-        '<system-reminder source="square">',
-        `${notification.route === 'bell' ? 'Bell' : notification.route === 'beside' ? 'Beside' : 'Mention'} from @${notification.item.actor} in \`${display}\``,
-        nativeWake ? 'The native adapter will present it at the next boundary.' : `> ${body.replace(/\n/g, '\n> ')}`,
-        `\`${catchCommand(squarePath, notification.recipient)}\``,
-        '</system-reminder>',
-    ].join('\n');
-}
-async function waitForCatch(squarePath, recipient, actIndex, ownerId) {
-    const deadline = Date.now() + 180_000;
-    while (Date.now() < deadline) {
-        const doc = loadSquare(squarePath);
-        if (isDeliveryDelivered(doc, recipient, actIndex))
-            return true;
-        const binding = lookupParticipant(squarePath, recipient).find((item) => item.ownerId === ownerId);
-        const lease = binding && sessionInbox(binding.sessionId).find((item) => item.name === recipient)?.catchLease;
-        if (!lease || lease.expiresAt <= Date.now())
-            return false;
-        await sleep(Math.min(250, lease.expiresAt - Date.now()));
+export class PaseoAdapter {
+    opts;
+    kind = 'paseo';
+    constructor(opts = {}) {
+        this.opts = opts;
     }
-    return false;
-}
-function send(request, ownership) {
-    try {
-        sendPaseoWake(request);
-    }
-    catch (error) {
-        throw new PaseoWakeError(error instanceof Error ? error.message : String(error), diagnostic('send', ownership, 'failed'));
-    }
-}
-export async function dispatchPaseoNotification(notification, ctx) {
-    const initial = loadSquare(ctx.squarePath);
-    const recipient = resolveRosterName(initial, notification.recipient);
-    if (!recipient || !isCurrentlyJoined(initial.acts, recipient))
-        return;
-    const ownership = ownershipSnapshot(lookupParticipant(ctx.squarePath, recipient));
-    if (ownership.length === 0)
-        return;
-    const discovery = discoverPaseoAgents();
-    if (discovery.error && discovery.agents.length === 0) {
-        throw new PaseoWakeError(`Paseo unavailable: ${discovery.error}`, diagnostic('discovery', ownership, 'unavailable'));
-    }
-    const active = selectActiveAgents(ownership, discovery.agents);
-    if (active.length === 0) {
-        throw new PaseoWakeError('No registered Paseo agent is idle or running.', diagnostic('selection', ownership, 'not_active'));
-    }
-    let boundaryTimedOut = false;
-    for (const agent of active) {
-        const owner = ownership.find((item) => item.agentId === agent.id);
-        if (!owner || hasPresentedForOwner(owner.ownerId, ctx.squarePath, recipient, notification.item.index))
-            continue;
-        if (!(await waitForPaseoWakeBoundary(agent))) {
-            boundaryTimedOut = true;
-            continue;
+    async dispatch(address, payload, beforeSend) {
+        const agentId = address.agentId?.trim();
+        if (!agentId) {
+            return {
+                outcome: 'failed',
+                signature: 'invalid_address',
+                message: 'Paseo route has no agent id.',
+                diagnostic: diagnostic('selection', address, 'invalid_address'),
+            };
         }
-        const latest = loadSquare(ctx.squarePath);
-        if (!isCurrentlyJoined(latest.acts, recipient) || isDeliveryDelivered(latest, recipient, notification.item.index))
-            return;
-        const current = lookupParticipant(ctx.squarePath, recipient).find((item) => item.ownerId === owner.ownerId && item.paseoAgentId === owner.agentId);
-        if (!current)
-            continue;
-        const activeCatch = sessionInbox(current.sessionId).find((item) => item.name === recipient)?.catchLease;
-        if (activeCatch &&
-            leaseOwnsNotification(activeCatch, {
-                actor: notification.item.actor,
-                body: notification.item.body,
-                route: notification.route,
-                recipient,
-            }) &&
-            (await waitForCatch(ctx.squarePath, recipient, notification.item.index, owner.ownerId))) {
-            return;
+        const discovery = (this.opts.discover ?? discoverPaseoAgents)();
+        if (discovery.error && discovery.agents.length === 0) {
+            return {
+                outcome: 'failed',
+                signature: discoveryRetryable(discovery.error) ? 'discovery_transient' : 'discovery_rejected',
+                message: `Paseo unavailable: ${discovery.error}`,
+                diagnostic: diagnostic('discovery', address, 'unavailable'),
+            };
         }
-        const nativeWake = owner.nativeGuarantee;
-        const request = {
-            agentId: agent.id,
-            prompt: prompt({ ...notification, recipient }, ctx.squarePath, nativeWake),
-        };
-        if (nativeWake) {
-            send(request, ownership);
-            return;
+        const agent = discovery.agents.find((candidate) => candidate.id === agentId);
+        if (agent === undefined || (agent.status !== 'idle' && agent.status !== 'running')) {
+            return {
+                outcome: 'failed',
+                signature: agent === undefined ? 'address_not_found' : 'agent_not_active',
+                message: agent === undefined ? 'The registered Paseo agent was not found.' : 'The registered Paseo agent is not idle or running.',
+                diagnostic: diagnostic('selection', address, agent === undefined ? 'not_found' : 'not_active'),
+            };
+        }
+        if (!(await (this.opts.waitForBoundary ?? waitForPaseoWakeBoundary)(agent))) {
+            return {
+                outcome: 'failed',
+                signature: 'boundary_unavailable',
+                message: 'Paseo did not reach the current tool boundary before the wake timeout.',
+                diagnostic: diagnostic('boundary', address, 'unavailable'),
+            };
+        }
+        if (!(await beforeSend()))
+            return { outcome: 'cancelled' };
+        try {
+            (this.opts.sendWake ?? sendPaseoWake)({ agentId, prompt: payload });
+            return { outcome: 'accepted' };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const kind = error instanceof PaseoWakeSendError ? error.kind : 'unknown';
+            const details = { ...diagnostic('send', address, 'failed'), outcome: kind };
+            if (kind === 'unknown')
+                return { outcome: 'unknown', signature: 'send_unknown', message, diagnostic: details };
+            return {
+                outcome: 'failed',
+                signature: kind === 'transient' ? 'send_pre_accept_transient' : 'send_pre_accept_rejected',
+                message,
+                diagnostic: details,
+            };
         }
-        presentOnce(current.sessionId, (id) => sessionInbox(id)
-            .map((item) => ({ ...item, notifications: item.notifications.filter((note) => note.actIndex === notification.item.index) }))
-            .filter((item) => item.notifications.length > 0), () => {
-            send(request, ownership);
-            return true;
-        });
-        return;
-    }
-    if (boundaryTimedOut) {
-        throw new PaseoWakeError('Paseo did not reach the current tool boundary before the wake timeout.', diagnostic('boundary', ownership, 'timeout'));
     }
 }
-export function paseoWakeSink() {
-    return { name: 'paseo', dispatch: dispatchPaseoNotification };
-}
-export function defaultWakeSinks() {
-    return process.env.SQUARE_DISABLE_PASEO_WAKE === '1' ? [] : [paseoWakeSink()];
-}

package/dist/paseo-state.js

@@ -2,7 +2,7 @@ import { execFileSync } from 'node:child_process';
 import { waitForPaseoToolBoundary } from './paseo-timeline.js';
 export function discoverPaseoAgents(timeoutMs = 5000) {
     try {
-        const raw = execFileSync(process.env.SQUARE_PASEO_BIN || 'paseo', ['ls', '--json'], {
+        const raw = execFileSync(process.env.SQUARE_PASEO_BIN || 'paseo', ['ls', '--global', '--json'], {
             encoding: 'utf8',
             timeout: timeoutMs,
             stdio: ['ignore', 'pipe', 'pipe'],

package/dist/paseo-timeline.js

@@ -1,4 +1,5 @@
 import { setTimeout as sleep } from 'node:timers/promises';
+import { connectPaseoDaemon } from './paseo-connection.js';
 async function waitSnapshots(agentId, read, opts) {
     const initial = await read(agentId);
     if (initial.agentStatus === 'idle')
@@ -24,53 +25,42 @@ async function waitSnapshots(agentId, read, opts) {
     }
     return false;
 }
-function paseoUrl() {
-    const value = process.env.SQUARE_PASEO_WS_URL?.trim() || process.env.PASEO_LISTEN?.trim();
-    if (!value)
-        return 'ws://127.0.0.1:6767/ws';
-    if (/^wss?:\/\//i.test(value))
-        return value.replace(/\/$/, '') + (value.endsWith('/ws') ? '' : '/ws');
-    if (/^\d+$/.test(value))
-        return `ws://127.0.0.1:${value}/ws`;
-    return `ws://${value.replace(/\/$/, '')}/ws`;
-}
-async function remoteSnapshot(agentId) {
-    const socket = new WebSocket(paseoUrl());
-    await new Promise((resolve, reject) => {
-        const timer = setTimeout(() => { socket.close(); reject(new Error('Paseo timeline connection timed out.')); }, 3000);
-        socket.addEventListener('open', () => { clearTimeout(timer); resolve(); }, { once: true });
-        socket.addEventListener('error', () => { clearTimeout(timer); reject(new Error('Paseo timeline unavailable.')); }, { once: true });
-    });
-    return await new Promise((resolve, reject) => {
-        const timer = setTimeout(() => { socket.close(); reject(new Error('Paseo timeline request timed out.')); }, 3000);
-        const requestId = `${process.pid}-${Date.now()}`;
-        socket.addEventListener('message', (event) => {
-            try {
-                const outer = JSON.parse(String(event.data));
-                const payload = outer?.message?.payload;
-                if (outer?.message?.type !== 'fetch_agent_timeline_response' || payload?.requestId !== requestId)
-                    return;
-                clearTimeout(timer);
-                socket.close();
-                const tools = new Map();
-                for (const entry of payload.entries ?? []) {
-                    const item = entry?.item;
-                    if (item?.type === 'tool_call' && typeof item.callId === 'string' && ['running', 'completed', 'failed'].includes(item.status))
-                        tools.set(item.callId, item.status);
-                }
-                resolve({ agentStatus: typeof payload.agent?.status === 'string' ? payload.agent.status : 'unknown', toolCalls: [...tools].map(([callId, status]) => ({ callId, status })) });
-            }
-            catch { /* ignore unrelated frames */ }
-        });
-        socket.send(JSON.stringify({ type: 'hello', clientId: `square-${process.pid}`, clientType: 'cli', protocolVersion: 1 }));
-        socket.send(JSON.stringify({ type: 'session', message: { type: 'fetch_agent_timeline_request', agentId, requestId, direction: 'tail', limit: 200, projection: 'projected' } }));
-    });
+function snapshotFromPayload(payload) {
+    const tools = new Map();
+    for (const entry of payload.entries ?? []) {
+        const item = entry.item;
+        if (item.type === 'tool_call' && ['running', 'completed', 'failed'].includes(item.status)) {
+            tools.set(item.callId, item.status);
+        }
+    }
+    return {
+        agentStatus: payload.agent?.status ?? 'unknown',
+        toolCalls: [...tools].map(([callId, status]) => ({ callId, status })),
+    };
 }
 export async function waitForPaseoToolBoundary(agentId, opts = {}) {
+    if (opts.readSnapshot !== undefined) {
+        try {
+            return await waitSnapshots(agentId, opts.readSnapshot, opts);
+        }
+        catch {
+            return false;
+        }
+    }
+    let client;
     try {
-        return await waitSnapshots(agentId, opts.readSnapshot ?? remoteSnapshot, opts);
+        client = await connectPaseoDaemon();
+        return await waitSnapshots(agentId, async (id) => snapshotFromPayload(await client.fetchAgentTimeline(id, {
+            direction: 'tail',
+            limit: 200,
+            projection: 'projected',
+            timeout: 3_000,
+        })), opts);
     }
     catch {
         return false;
     }
+    finally {
+        await client?.close().catch(() => { });
+    }
 }

package/dist/presentation.js

@@ -1,8 +1,8 @@
 import { sameName } from './model.js';
 import fs from 'node:fs';
 import path from 'node:path';
-import { fold, perceive } from './square-core.js';
-import { actId, actStableIndex, extractMentions, publicActs, readCursor, rosterNames, sayNumberFor } from './runtime.js';
+import { audienceIncludes, audienceOf, perceive } from './square-core.js';
+import { actId, publicActs, readCursor, rosterNames, sayNumberFor } from './runtime.js';
 import { formatDuration, formatRelativeTime, formatTimestamp } from './time.js';
 import { grepSnippet } from './search.js';
 function headerLine(squarePath, opts = {}) {
@@ -31,10 +31,10 @@ export function quoteShell(value) {
     return `'${value.replace(/'/g, `'\\''`)}'`;
 }
 export function commandPrefix(squarePath) {
-    return `square --square-path ${quoteShell(squarePath)}`;
+    return `square --location ${quoteShell(squarePath)}`;
 }
 export function participantCommandPrefix(squarePath, name) {
-    return `square --square-path ${quoteShell(path.resolve(squarePath))} --as ${quoteShell(name)}`;
+    return `square --location ${quoteShell(path.resolve(squarePath))} --as ${quoteShell(name)}`;
 }
 function formatAge(ms) {
     if (ms === undefined)
@@ -150,7 +150,7 @@ export function renderEventCli(event, opts = {}) {
         case 'say': {
             const body = renderedBody(event.body, maxBody);
             const mention = opts.mention;
-            const mentionSuffix = mention !== undefined && extractMentions(event.body).some((name) => sameName(name, mention))
+            const mentionSuffix = mention !== undefined && audienceIncludes(audienceOf(event), mention)
                 ? ` · calls your name across the square — @${mention}`
                 : '';
             const replySuffix = event.reply === undefined ? '' : ` · replies to ${actId(event.reply)}`;
@@ -165,21 +165,15 @@ export function renderEventCli(event, opts = {}) {
     }
 }
 function renderPresenceOnlySay(event) {
-    if (event.kind !== 'say' || event.reach === undefined || event.reach === 'bell')
-        return '';
-    return `*walks over to @${event.reach.beside}*`;
-}
-function perceptionFor(history, event, viewer) {
-    const cutoff = history.findIndex((item) => actStableIndex(item) === actStableIndex(event));
-    const acts = cutoff >= 0 ? history.slice(0, cutoff) : history;
-    return perceive(fold(acts), event, viewer);
+    const audience = audienceOf(event);
+    const targets = audience.kind === 'bell' ? [] : audience.names;
+    const dest = targets.length === 0 ? '' : ` to ${targets.map((name) => `@${name}`).join(' and ')}`;
+    return `*${event.actor} walks over${dest}*`;
 }
-export function renderVisibleEvent(history, event, viewer, opts = {}) {
+export function renderAmbientEvent(event, viewer, opts = {}) {
     if (event.kind !== 'say')
         return renderEventCli(event, opts);
-    const seen = perceptionFor(history, event, viewer);
-    if (seen === 'none')
-        return '';
+    const seen = perceive(event, viewer);
     if (seen === 'presence')
         return renderPresenceOnlySay(event);
     return renderEventCli(event, opts);
@@ -194,7 +188,7 @@ function renderUnreadSummary(opts) {
     return [
         ...opts.activitySummaries.flatMap((item) => [
             ...item.previews.slice(-1).map((preview) => {
-                const rendered = renderVisibleEvent([preview.act], preview.act, opts.viewer, { actNumber: preview.number });
+                const rendered = renderAmbientEvent(preview.act, opts.viewer, { actNumber: preview.number });
                 if (rendered === '')
                     return `  · ${item.name} spoke — ${formatAge(item.latestActivityAgeMs)} ago`;
                 if (rendered.startsWith('*'))
@@ -208,7 +202,7 @@ function renderUnreadSummary(opts) {
 export function renderPendingFeed(history, publicItems, roomChanges, viewer = '') {
     const lines = [];
     for (const act of publicItems) {
-        const rendered = renderVisibleEvent(history, act, viewer, {
+        const rendered = renderAmbientEvent(act, viewer, {
             actNumber: act.kind === 'say' ? sayNumberFor(history, act) : undefined,
         });
         if (rendered !== '')
@@ -262,7 +256,7 @@ export function renderPublicTail(events, lastN, now, viewer = '') {
     const selected = lastN == null ? publicItems : publicItems.slice(-lastN);
     const preview = lastN == null ? undefined : BODY_PREVIEW_LENGTH;
     return selected
-        .map((event) => renderVisibleEvent(events, event, viewer, { now, preview, actNumber: event.kind === 'say' ? sayNumberFor(events, event) : undefined }))
+        .map((event) => renderAmbientEvent(event, viewer, { now, preview, actNumber: event.kind === 'say' ? sayNumberFor(events, event) : undefined }))
         .filter(Boolean)
         .join('\n\n');
 }
@@ -270,7 +264,7 @@ function lastPresenceAnchor(doc, name) {
     const cursor = readCursor(doc, name);
     for (let i = doc.acts.length - 1; i >= 0; i--) {
         const event = doc.acts[i];
-        const index = actStableIndex(event);
+        const index = event.index;
         if (index > cursor)
             continue;
         if (event.kind === 'say' || event.kind === 'done')
@@ -281,7 +275,7 @@ function lastPresenceAnchor(doc, name) {
 function renderLastPresenceMarker(name) {
     return `· ${name}'s footprints reach here`;
 }
-export function renderActivitiesView(doc, visible, lastN, full, squarePath, viewer = '') {
+export function renderActivitiesView(doc, visible, lastN, full, squarePath, viewer = '', mode = 'ambient') {
     const publicVisible = visible.filter((act) => act.kind === 'say' || act.kind === 'done');
     const shown = lastN == null ? publicVisible : publicVisible.slice(-lastN);
     const previewLen = full ? undefined : BODY_PREVIEW_LENGTH;
@@ -293,10 +287,13 @@ export function renderActivitiesView(doc, visible, lastN, full, squarePath, view
     }
     const chunks = [];
     for (const act of shown) {
-        const rendered = renderVisibleEvent(doc.acts, act, viewer, {
+        const opts = {
             preview: previewLen,
             actNumber: act.kind === 'say' ? sayNumberFor(doc.acts, act) : undefined,
-        });
+        };
+        const rendered = mode === 'archive'
+            ? renderEventCli(act, opts)
+            : renderAmbientEvent(act, viewer, opts);
         if (rendered !== '')
             chunks.push(rendered);
         for (const participant of markers.get(act.index) ?? []) {
@@ -306,7 +303,7 @@ export function renderActivitiesView(doc, visible, lastN, full, squarePath, view
     if (chunks.length === 0)
         return 'latest\n  ○ no public activity in this view';
     if (previewLen !== undefined) {
-        const truncated = shown.some((act) => act.kind === 'say' && act.body.length > previewLen);
+        const truncated = shown.some((act) => act.kind === 'say' && act.body.length > previewLen && (mode === 'archive' || perceive(act, viewer) === 'full'));
         if (truncated)
             chunks.push(`» ${commandPrefix(squarePath)} history --full`);
     }
@@ -412,20 +409,8 @@ function renderRoomChanges(changes) {
 export function renderDoctorClean() {
     return '✓ no problems found';
 }
-export function renderDoctorProblems(problems) {
-    return [`✕ ${problems.length} ${pluralize(problems.length, 'problem')} found`, ...problems.map((problem) => `  · ${problem.kind}: ${problem.message}`)].join('\n');
-}
 export function renderDoctorUnfixable(reason) {
-    return ['✕ cannot repair', `  · ${reason}`].join('\n');
-}
-export function renderDoctorRepaired(actions, quarantinedCount, sidecarPath) {
-    if (actions.length === 0)
-        return '✓ no problems found';
-    return [
-        '✓ repaired',
-        ...actions.map((action) => `  · ${action.message}`),
-        ...(quarantinedCount > 0 && sidecarPath !== undefined ? [`  · quarantined ${quarantinedCount} act block(s)`, `  · sidecar ${sidecarPath}`] : []),
-    ].join('\n');
+    return ['✕ unreadable artifact', `  · ${reason}`].join('\n');
 }
 export function renderWatchOutput(history, publicItems, roomChanges, opts) {
     const sections = [];
@@ -448,7 +433,7 @@ export function renderWatchOutput(history, publicItems, roomChanges, opts) {
         sections.push(room);
     if (publicItems.length > 0) {
         const rendered = publicItems
-            .map((act) => renderVisibleEvent(history, act, opts.viewer, {
+            .map((act) => renderAmbientEvent(act, opts.viewer, {
             actNumber: act.kind === 'say' ? sayNumberFor(history, act) : undefined,
             mention: opts.mention,
         }))