@astrosheep/square 0.3.63 → 0.3.64

package/dist/presentation.js

@@ -3,19 +3,13 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { participantIdentity } from './participant-identity.js';
 export { participantIdentity } from './participant-identity.js';
-import { audienceIncludes, audienceOf, MAX_IDENTITY_SET_SIZE, replayLandedAudiences } from './square-core.js';
+import { audienceIncludes, audienceOf, MAX_IDENTITY_SET_SIZE } from './square-core.js';
 import { perceiveActivity } from './delivery.js';
-import { actId, presenceAnchor, publicActs, rosterNames, sayNumberFor, HELD_WAIT_BUDGET_MS } from './runtime.js';
+import { actId, sayNumberFor, HELD_WAIT_BUDGET_MS } from './runtime.js';
 import { formatDuration, formatRelativeTime, formatTimestamp } from './time.js';
 import { compareParticipantActivity } from './decisions.js';
 import { grepSnippet } from './search.js';
 import { style } from './tty-style.js';
-function headerLine(squarePath, opts = {}) {
-    const count = opts.participantCount ?? 0;
-    const heldSuffix = opts.held ? ' — a hand is raised' : '';
-    const line = `· ${displayPath(squarePath)} — ${count} in the square${heldSuffix}`;
-    return opts.plain === true ? line : style('dim', line);
-}
 export function displayPath(squarePath, cwd = process.cwd()) {
     if (!path.isAbsolute(squarePath))
         return squarePath.split(path.sep).join('/');
@@ -32,7 +26,10 @@ export function displayPath(squarePath, cwd = process.cwd()) {
     return displayed.split(path.sep).join('/');
 }
 export function withPathOutput(squarePath, body = '', opts = {}) {
-    return [headerLine(squarePath, opts), ...(body === '' ? [] : ['', body])].join('\n') + '\n';
+    const count = opts.participantCount ?? 0;
+    const heldSuffix = opts.held ? ' — a hand is raised' : '';
+    const line = `· ${displayPath(squarePath)} — ${count} in the square${heldSuffix}`;
+    return [opts.plain === true ? line : style('dim', line), ...(body === '' ? [] : ['', body])].join('\n') + '\n';
 }
 /** The same header/blank/body layout as withPathOutput, for refusal bodies written to stderr. */
 export function formatRefusal(squarePath, bodyLines, opts = {}) {
@@ -72,35 +69,7 @@ function formatAge(ms) {
         return `${Math.max(0, ms)}ms`;
     return `${Math.floor(ms / 1000)}s`;
 }
-function pluralize(count, singular, plural = `${singular}s`) {
-    return count === 1 ? singular : plural;
-}
 const PRESENCE_WINDOW_MS = 8 * 60 * 60 * 1000;
-function presenceGlyph(participant) {
-    if (participant.state === 'done')
-        return '○';
-    if (participant.presence === 'watching')
-        return '◎';
-    if (participant.lastActiveAt !== undefined)
-        return '●';
-    return '○';
-}
-function styledPresenceGlyph(participant) {
-    const glyph = presenceGlyph(participant);
-    return glyph === '○' ? style('dim', glyph) : glyph;
-}
-function presenceText(participant, now) {
-    if (participant.state === 'done') {
-        return participant.lastActiveAt === undefined ? 'stepped out of the square' : `stepped out of the square · ${formatRelativeTime(participant.lastActiveAt, now)}`;
-    }
-    if (participant.presence === 'watching') {
-        const at = participant.lastActiveAt;
-        return at === undefined ? 'catching' : `catching · ${formatRelativeTime(at, now)}`;
-    }
-    if (participant.lastActiveAt === undefined)
-        return 'quiet';
-    return participant.activityCount > 0 ? `${formatRelativeTime(participant.lastActiveAt, now)}` : `quiet · ${formatRelativeTime(participant.lastActiveAt, now)}`;
-}
 export function renderPresenceLines(participants, now, limit = 5) {
     const recent = participants
         .filter((p) => p.state === 'done' || p.presence === 'watching' || (p.lastActiveAt !== undefined && now - p.lastActiveAt <= PRESENCE_WINDOW_MS))
@@ -108,16 +77,25 @@ export function renderPresenceLines(participants, now, limit = 5) {
     const shown = recent.slice(0, limit);
     if (shown.length === 0)
         return [style('dim', '  ○ nobody nearby')];
-    const lines = shown.map((p) => `  ${styledPresenceGlyph(p)} ${participantIdentity(p.name)}${style('dim', ` · ${presenceText(p, now)}`)}`);
+    const lines = shown.map((p) => {
+        const glyph = p.state === 'done' ? '○' : p.presence === 'watching' ? '◎' : p.lastActiveAt !== undefined ? '●' : '○';
+        const text = p.state === 'done'
+            ? (p.lastActiveAt === undefined ? 'stepped out of the square' : `stepped out of the square · ${formatRelativeTime(p.lastActiveAt, now)}`)
+            : p.presence === 'watching'
+                ? (p.lastActiveAt === undefined ? 'is nearby · catching' : `is nearby · catching · ${formatRelativeTime(p.lastActiveAt, now)}`)
+                : p.lastActiveAt === undefined ? 'is nearby · quiet'
+                    : p.activityCount > 0 ? `is nearby · ${formatRelativeTime(p.lastActiveAt, now)}` : `is nearby · quiet · ${formatRelativeTime(p.lastActiveAt, now)}`;
+        return `  ${glyph === '○' ? style('dim', glyph) : glyph} ${participantIdentity(p.name)}${style('dim', ` ${text}`)}`;
+    });
     const remaining = recent.length - shown.length;
     if (remaining > 0)
         lines.push(style('dim', `  ○ … ${remaining} more nearby`));
     return lines;
 }
 const EXPRESS_HINTS = [
-    '*asterisks* are your body — *slams table*, *sketches in the air*, *shrugs*',
-    "you're standing in a square — words and gestures both land",
-    'the square runs on conversation — say things that move it, not nods that fill it',
+    '*asterisks* are your body — slam a table, shrug, sketch in the air',
+    "answer someone's actual words — they're standing right there",
+    "say the half-shaped thing — that's what the square is for",
 ];
 export function expressHintLine(ownActivityCount) {
     if (ownActivityCount !== 1 && ownActivityCount % 5 !== 0)
@@ -138,18 +116,14 @@ export function truncateExternalDiagnostic(diagnostic) {
         return diagnostic;
     return `${truncateChars(diagnostic, EXTERNAL_DIAGNOSTIC_MAX_CHARS - 1).text}…`;
 }
-function previewBody(body, maxLen = BODY_PREVIEW_LENGTH) {
+function previewBodyFacts(body, maxLen = BODY_PREVIEW_LENGTH) {
     const preview = truncateChars(body, maxLen);
-    return preview.remaining === 0 ? preview.text : `${preview.text}\n${style('dim', `… ${preview.remaining} more chars`)}`;
+    return {
+        text: preview.remaining === 0 ? preview.text : `${preview.text}\n${style('dim', `… ${preview.remaining} more chars`)}`,
+        clipped: preview.remaining > 0,
+    };
 }
 const UNREAD_PREVIEW_CHARS = 120;
-export function previewActivityBody(body) {
-    const compact = body.replace(/\s+/g, ' ').trim();
-    if (compact === '')
-        return '(empty)';
-    const preview = truncateChars(compact, UNREAD_PREVIEW_CHARS);
-    return preview.remaining === 0 ? preview.text : `${preview.text}${style('dim', `… (+${preview.remaining} chars)`)}`;
-}
 export function renderRoomChangeText(event) {
     const actor = event.actor ?? 'someone';
     const identity = actor === 'someone' ? actor : participantIdentity(actor);
@@ -163,34 +137,34 @@ export function renderRoomChangeText(event) {
         case 'resume':
             return `${identity} lowered the hand`;
         case 'listen':
-            return `${identity} turns an ear toward ${participantIdentity(event.target)}`;
+            return `${identity} turned an ear toward ${participantIdentity(event.target)}`;
         case 'ignore':
-            return `${identity} turns away from ${participantIdentity(event.target)}`;
+            return `${identity} turned away from ${participantIdentity(event.target)}`;
     }
 }
 function renderedBody(body, maxChars) {
     if (!body)
-        return '';
-    return maxChars === undefined ? body : previewBody(body, maxChars);
+        return { text: '', clipped: false };
+    return maxChars === undefined ? { text: body, clipped: false } : previewBodyFacts(body, maxChars);
 }
 function bodySuffix(body) {
     if (body === '')
         return '';
     return `\n${body.split('\n').map((line) => `  ${line}`).join('\n')}`;
 }
-export function renderEventCli(event, opts = {}) {
+function renderEventCliFacts(event, opts = {}) {
     const now = opts.now;
     const maxBody = opts.preview;
     switch (event.kind) {
         case 'join':
-            return `· ${renderRoomChangeText(event)}`;
+            return { text: `· ${renderRoomChangeText(event)}`, bodyClipped: false };
         case 'hold':
-            return `· ${renderRoomChangeText(event)}`;
+            return { text: `· ${renderRoomChangeText(event)}`, bodyClipped: false };
         case 'resume':
-            return `${style('release', '✓')} ${renderRoomChangeText(event)}`;
+            return { text: `${style('release', '✓')} ${renderRoomChangeText(event)}`, bodyClipped: false };
         case 'listen':
         case 'ignore':
-            return `· ${renderRoomChangeText(event)}`;
+            return { text: `· ${renderRoomChangeText(event)}`, bodyClipped: false };
         case 'say': {
             const body = renderedBody(event.body, maxBody);
             const mention = opts.mention;
@@ -199,16 +173,22 @@ export function renderEventCli(event, opts = {}) {
                 : '';
             const replySuffix = event.reply === undefined ? '' : ` · replies to ${actId(event.reply)}`;
             const meta = ` #${opts.actNumber ?? 1} · ${actId(event)} · ${formatRelativeTime(event.at, now)}${mentionSuffix}${replySuffix}`;
-            return `● ${participantIdentity(event.actor)}${style('dim', meta)}${bodySuffix(body)}`;
+            return { text: `● ${participantIdentity(event.actor)}${style('dim', meta)}${bodySuffix(body.text)}`, bodyClipped: body.clipped };
         }
         case 'done': {
             const body = renderedBody(event.body, maxBody);
-            return `${style('dim', '○')} ${participantIdentity(event.actor)} stepped out of the square — done${style('dim', ` · ${actId(event)} · ${formatRelativeTime(event.at, now)}`)}${bodySuffix(body)}`;
+            return {
+                text: `${style('dim', '○')} ${participantIdentity(event.actor)} stepped out of the square — done${style('dim', ` · ${actId(event)} · ${formatRelativeTime(event.at, now)}`)}${bodySuffix(body.text)}`,
+                bodyClipped: body.clipped,
+            };
         }
         case 'read':
-            return '';
+            return { text: '', bodyClipped: false };
     }
 }
+export function renderEventCli(event, opts = {}) {
+    return renderEventCliFacts(event, opts).text;
+}
 function renderPresenceOnlySay(event, opts = {}) {
     const audience = audienceOf(event);
     const targets = audience.kind === 'bell' ? [] : audience.names;
@@ -224,19 +204,22 @@ function renderPresenceOnlySay(event, opts = {}) {
     ].join(' and ')}`;
     return `● ${participantIdentity(event.actor)}${meta}\n${style('dim', `  talked to${dest}`)}`;
 }
-export function renderAmbientEvent(event, viewer, opts = {}) {
+export function renderAmbientEventFacts(event, viewer, opts = {}) {
     if (event.kind !== 'say')
-        return renderEventCli(event, opts);
+        return renderEventCliFacts(event, opts);
     if (opts.perception === undefined && opts.squareState === undefined) {
         throw new Error('Ambient say rendering requires a settled perception or SquareState');
     }
     const seen = opts.perception ?? perceiveActivity(opts.squareState, event, viewer);
     if (seen === 'presence') {
         const presence = renderPresenceOnlySay(event, opts);
-        const body = opts.presencePreview === undefined ? '' : renderedBody(event.body, opts.presencePreview);
-        return `${presence}${bodySuffix(body)}`;
+        const body = opts.presencePreview === undefined ? { text: '', clipped: false } : renderedBody(event.body, opts.presencePreview);
+        return { text: `${presence}${bodySuffix(body.text)}`, bodyClipped: body.clipped };
     }
-    return renderEventCli(event, opts);
+    return renderEventCliFacts(event, opts);
+}
+export function renderAmbientEvent(event, viewer, opts = {}) {
+    return renderAmbientEventFacts(event, viewer, opts).text;
 }
 function draftSavedLines(draftPath) {
     return draftPath === undefined ? [] : [style('dim', `· draft kept: ${draftPath}`)];
@@ -256,14 +239,16 @@ function renderUnreadSummary(opts) {
                 if (preview.perception === 'presence') {
                     return style('dim', `  · ${participantIdentity(item.name)} spoke — ${formatAge(item.latestActivityAgeMs)} ago · ${rendered.replace(/\n/g, ' ')}`);
                 }
-                return style('dim', `  · ${participantIdentity(item.name)} spoke — ${formatAge(item.latestActivityAgeMs)} ago · "${previewActivityBody(preview.act.body)}"`);
+                const compact = preview.act.body.replace(/\s+/g, ' ').trim();
+                const bodyPreview = compact === '' ? { text: '(empty)', remaining: 0 } : truncateChars(compact, UNREAD_PREVIEW_CHARS);
+                const bodyText = bodyPreview.remaining === 0 ? bodyPreview.text : `${bodyPreview.text}${style('dim', `… (+${bodyPreview.remaining} chars)`)}`;
+                return style('dim', `  · ${participantIdentity(item.name)} spoke — ${formatAge(item.latestActivityAgeMs)} ago · "${bodyText}"`);
             }),
         ]),
         ...(remainingSummaries === 0 ? [] : [style('dim', `  · ${remainingSummaries} more participants have unread activity`)]),
-        ...opts.roomChanges.map((act) => style('dim', `  · ${renderRoomChangeText(act)}`)),
     ];
 }
-export function renderPendingFeed(history, publicItems, roomChanges, viewer = '', squareState) {
+export function renderPendingFeed(history, publicItems, viewer = '', squareState) {
     const lines = [];
     for (const act of publicItems) {
         const rendered = renderAmbientEvent(act, viewer, {
@@ -273,19 +258,13 @@ export function renderPendingFeed(history, publicItems, roomChanges, viewer = ''
         if (rendered !== '')
             lines.push(rendered);
     }
-    const publicIndexes = new Set(publicItems.map((item) => item.index));
-    for (const act of roomChanges) {
-        if (publicIndexes.has(act.index))
-            continue;
-        lines.push(`· ${renderRoomChangeText(act)}`);
-    }
     return lines.join('\n\n');
 }
 export function renderActivityBlocked(opts) {
     const readNowCommand = `${participantCommandPrefix(opts.squarePath, opts.name)} catch --now`;
     return withPathOutput(opts.squarePath, [
         `${style('blocked', '✕')} your activity doesn't land — the square moved behind your back`,
-        ...renderUnreadSummary({ activitySummaries: opts.activitySummaries, roomChanges: opts.unreadRoomChanges, viewer: opts.name }),
+        ...renderUnreadSummary({ activitySummaries: opts.activitySummaries, viewer: opts.name }),
         ...draftSavedLines(opts.draftPath),
         `${readNowCommand}`,
         '  · take it in, then retry:',
@@ -306,18 +285,27 @@ export function renderActivityUncertain(opts) {
         `${commandPrefix(opts.squarePath)} history${opts.landedId === undefined ? ' --limit 10' : ` --at ${opts.landedId}`} --no-truncate`,
     ], opts);
 }
+/** A blank or whitespace hold reason is absent, never an empty sensory line. */
+function holdReasonLines(reason) {
+    const text = reason?.trim() ?? '';
+    return text === '' ? [] : [style('dim', `  · ${text}`)];
+}
+function heldMainLine(holder, styled) {
+    const glyph = styled ? style('blocked', '✕') : '✕';
+    const who = holder === undefined ? 'a hand is raised' : `${participantIdentity(holder)} has a hand raised`;
+    return `${glyph} ${who} — voices drop, yours too`;
+}
 export function renderExpressWaiting(opts) {
     if (opts.reason === 'throttled') {
         return [
-            '✕ the square is packed',
-            `  · your activity is waiting · next opening in ${formatDuration(opts.delayMs)}`,
+            '✕ the square is packed — shoulder to shoulder',
+            `  · a lull opens in ${formatDuration(opts.delayMs)}`,
             '  · --no-wait saves a draft and returns now',
         ].join('\n');
     }
-    const holder = opts.holder === undefined ? 'a hand is raised' : `${participantIdentity(opts.holder)} raised a hand`;
     return [
-        `✕ your activity doesn't land — ${holder}`,
-        ...(opts.holdReason === undefined ? [] : [`  · ${opts.holdReason}`]),
+        heldMainLine(opts.holder, false),
+        ...holdReasonLines(opts.holdReason),
         `  · your activity is waiting — after ${formatDuration(HELD_WAIT_BUDGET_MS)} it saves a draft and stops`,
         '  · --no-wait saves a draft and returns now',
     ].join('\n');
@@ -326,31 +314,19 @@ export function renderExpressNoWait(opts) {
     const retryCommand = opts.retryCommand;
     const lines = opts.reason === 'throttled'
         ? [
-            `${style('blocked', '✕')} the square is packed`,
-            `  · next opening in ${formatDuration(opts.delayMs)}`,
+            `${style('blocked', '✕')} the square is packed — shoulder to shoulder`,
+            `  · a lull opens in ${formatDuration(opts.delayMs)}`,
             ...draftSavedLines(opts.draftPath),
             `${withDraftInput(retryCommand, opts.draftPath)}`,
         ]
         : [
-            `${style('blocked', '✕')} your activity doesn't land — a hand is raised`,
-            style('dim', `  · ${opts.holdReason ?? 'the square holds its breath'}`),
+            heldMainLine(opts.holder, true),
+            ...holdReasonLines(opts.holdReason),
             ...draftSavedLines(opts.draftPath),
             `${withDraftInput(retryCommand, opts.draftPath)}`,
         ];
     return withPathOutput(opts.squarePath, lines.join('\n'), { participantCount: opts.participantCount, held: opts.held });
 }
-export function renderPublicTail(squareState, events, lastN, now, viewer = '') {
-    const publicItems = publicActs(events);
-    const selected = lastN == null ? publicItems : publicItems.slice(-lastN);
-    const preview = lastN == null ? undefined : BODY_PREVIEW_LENGTH;
-    return selected
-        .map((event) => renderAmbientEvent(event, viewer, { now, preview, actNumber: event.kind === 'say' ? sayNumberFor(events, event) : undefined, squareState }))
-        .filter(Boolean)
-        .join('\n\n');
-}
-function lastPresenceAnchor(squareState, name, landed) {
-    return presenceAnchor(squareState, name, landed);
-}
 export function renderPresenceAnchor(names) {
     const visibleNames = names.slice(0, MAX_IDENTITY_SET_SIZE);
     const participants = visibleNames.map((name) => participantIdentity(name)).join(', ');
@@ -358,45 +334,7 @@ export function renderPresenceAnchor(names) {
     const suffix = remaining === 0 ? '' : ` and ${remaining} more`;
     return style('dim', names.length === 1 ? `→ ${participants} was here` : `→ ${participants}${suffix} were here`);
 }
-export function renderActivitiesView(squareState, visible, lastN, noTruncate, 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 = noTruncate ? undefined : BODY_PREVIEW_LENGTH;
-    const markers = new Map();
-    const landed = replayLandedAudiences(squareState.acts);
-    for (const participant of rosterNames(squareState)) {
-        const anchor = lastPresenceAnchor(squareState, participant, landed);
-        if (anchor >= 0)
-            markers.set(anchor, [...(markers.get(anchor) ?? []), participant]);
-    }
-    const chunks = [];
-    for (const act of shown) {
-        const opts = {
-            preview: previewLen,
-            actNumber: act.kind === 'say' ? sayNumberFor(squareState.acts, act) : undefined,
-        };
-        const rendered = mode === 'archive'
-            ? renderEventCli(act, opts)
-            : renderAmbientEvent(act, viewer, { ...opts, squareState });
-        if (rendered !== '')
-            chunks.push(rendered);
-        const participants = markers.get(act.index);
-        if (participants !== undefined)
-            chunks.push(renderPresenceAnchor(participants));
-    }
-    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 && (mode === 'archive' || perceiveActivity(squareState, act, viewer) === 'full'));
-        if (truncated)
-            chunks.push(`${commandPrefix(squarePath)} history --no-truncate`);
-    }
-    return chunks.join('\n\n');
-}
 const GREP_PREVIEW_CHARS = 160;
-function highlightGrepMatch(text) {
-    return style('match', text);
-}
 export function renderGrepActivitiesView(visible, totalMatches, noTruncate, squarePath, pattern, fixed = false, perception) {
     const publicVisible = visible.filter((act) => act.kind === 'say' || act.kind === 'done');
     if (totalMatches === 0)
@@ -418,14 +356,14 @@ export function renderGrepActivitiesView(visible, totalMatches, noTruncate, squa
         }
         const snippet = grepSnippet(rawBody, pattern, GREP_PREVIEW_CHARS, fixed);
         if (snippet === undefined) {
-            const preview = previewBody(rawBody, GREP_PREVIEW_CHARS);
+            const preview = previewBodyFacts(rawBody, GREP_PREVIEW_CHARS).text;
             chunks.push(`${header}${preview === '' ? '' : `\n  ${preview}`}`);
             continue;
         }
         const clippedBefore = snippet.beforeOmitted > 0;
         const clippedAfter = snippet.afterOmitted > 0;
         truncated ||= clippedBefore || clippedAfter;
-        const text = `${clippedBefore ? '… ' : ''}${snippet.before}${highlightGrepMatch(snippet.match)}${snippet.after}${clippedAfter ? ' …' : ''}`;
+        const text = `${clippedBefore ? '… ' : ''}${snippet.before}${style('match', snippet.match)}${snippet.after}${clippedAfter ? ' …' : ''}`;
         const omitted = clippedBefore || clippedAfter
             ? `\n${style('dim', `  · ${snippet.beforeOmitted} chars before · ${snippet.afterOmitted} chars after`)}`
             : '';
@@ -439,18 +377,16 @@ export function renderGrepActivitiesView(visible, totalMatches, noTruncate, squa
     }
     return chunks.join('\n\n');
 }
-function renderActivityLimitBody(opts) {
-    const countText = opts.count !== undefined && opts.hardCap !== undefined ? ` (${opts.count}/${opts.hardCap})` : '';
+export function renderActivityLimit(opts) {
+    // The cap wording lives inside the count: the speaker is simply spent.
+    const spoken = opts.count !== undefined && opts.hardCap !== undefined ? ` — ${opts.count}/${opts.hardCap} spoken` : '';
     const doneCommand = `${participantCommandPrefix(opts.squarePath, opts.name)} done`;
-    return [
-        `${style('blocked', '✕')} your activity doesn't land — the cap is reached${countText}`,
+    return withPathOutput(opts.squarePath, [
+        `${style('blocked', '✕')} nothing left in you${spoken}`,
         ...draftSavedLines(opts.draftPath),
         '  · your draft stays unsent; done only steps out',
         doneCommand,
-    ].join('\n');
-}
-export function renderActivityLimit(opts) {
-    return withPathOutput(opts.squarePath, renderActivityLimitBody(opts), { participantCount: opts.participantCount, held: opts.held });
+    ].join('\n'), { participantCount: opts.participantCount, held: opts.held });
 }
 export function renderWatchAlreadyActive(opts) {
     return [
@@ -480,53 +416,39 @@ export function renderWatchStatus(opts) {
         case 'stale':
         case 'empty-now': {
             const prefix = participantCommandPrefix(opts.squarePath, opts.name);
-            const quiet = opts.status === 'stale' && opts.idleMs !== undefined
-                ? style('dim', `○ ${formatDuration(opts.idleMs)} of quiet — nothing new for you`)
-                : style('dim', '○ only footsteps in the square — nothing new for you');
+            // Quiet graduates with the idle length; an empty catch has no idle budget to report.
+            const idleMs = opts.idleMs;
+            const quiet = idleMs !== undefined && idleMs >= 60 * 60 * 1000
+                ? style('dim', `○ dust lies thick — ${formatDuration(idleMs)} of quiet`)
+                : idleMs !== undefined && idleMs >= 60 * 1000
+                    ? style('dim', `○ dust settles on the flagstones — ${formatDuration(idleMs)} of quiet`)
+                    : style('dim', '○ only footsteps in the square — nothing new for you');
+            // The quiet report never repeats the catch just run.
+            const hints = [`${prefix} catch --idle 30m`];
             return [
                 quiet,
-                ...(opts.showCatchHint === false
-                    ? []
-                    : [`${prefix} catch --idle 30m`, `  glance: ${prefix} catch --now`]),
+                ...(opts.showCatchHint === false ? [] : hints),
                 ...presenceLines,
             ].join('\n');
         }
         case 'quorum':
             return [`${style('release', '✓')} everyone else has left — the square is yours alone`, `${participantCommandPrefix(opts.squarePath, opts.name)} done`].join('\n');
-        case 'capped':
-            return [`${style('blocked', '✕')} nothing left in you — the cap is reached`, `${participantCommandPrefix(opts.squarePath, opts.name)} done`].join('\n');
+        case 'capped': {
+            const spoken = opts.hardCap === undefined || opts.hardCap === null
+                ? ''
+                : ` — ${opts.ownActivityCount ?? 0}/${opts.hardCap} spoken`;
+            return [`${style('blocked', '✕')} nothing left in you${spoken}`, `${participantCommandPrefix(opts.squarePath, opts.name)} done`].join('\n');
+        }
     }
 }
-function renderRoomChanges(changes) {
-    if (changes.length === 0)
-        return '';
-    return [`${style('changed', '▲')} while your back was turned`, ...changes.map((act) => `  · ${renderRoomChangeText(act)}`)].join('\n');
-}
 export function renderDoctorClean() {
     return '✓ no problems found';
 }
 export function renderDoctorUnfixable(reason) {
     return ['✕ unreadable artifact', `  · ${truncateExternalDiagnostic(reason)}`].join('\n');
 }
-export function renderWatchOutput(history, publicItems, roomChanges, opts) {
+export function renderWatchOutput(history, publicItems, opts) {
     const sections = [];
-    if (opts.stalePartial) {
-        const prefix = participantCommandPrefix(opts.squarePath, opts.viewer);
-        const quiet = opts.idleMs === undefined
-            ? '○ only footsteps in the square — nothing new for you'
-            : `○ ${formatDuration(opts.idleMs)} of quiet — nothing else for you`;
-        sections.push([
-            quiet,
-            ...(opts.showCatchHint === false
-                ? []
-                : [`${prefix} catch --idle 30m`, `  glance: ${prefix} catch --now`]),
-        ].join('\n'));
-    }
-    const publicIndexes = new Set(publicItems.map((item) => item.index));
-    const presenceChanges = roomChanges.filter(({ index }) => !publicIndexes.has(index));
-    const room = renderRoomChanges(presenceChanges);
-    if (room !== '')
-        sections.push(room);
     if (publicItems.length > 0) {
         const rendered = publicItems
             .map((act) => renderAmbientEvent(act, opts.viewer, {

package/dist/registry.d.ts

@@ -1,51 +1,12 @@
-/** Machine-local participant discovery cache. */
-import { type StoredAct } from './model.js';
-import type { HostLedgerPort, PresenceRecord } from './host-ledger.js';
-export type SessionChannel = 'claude-code' | 'codex' | 'opencode' | 'pi' | 'paseo' | 'unknown';
-export interface RegistryBinding {
-    sessionId: string;
-    name: string;
-    squarePath: string;
-    channel: SessionChannel;
-    child: boolean;
-    route?: PresenceRecord['route'];
-    updatedAt: number;
-    epoch: number;
-}
-export interface RegistryWriteOptions {
-    channel?: SessionChannel;
-    child?: boolean;
-    route?: PresenceRecord['route'];
-    at?: number;
-    env?: NodeJS.ProcessEnv;
-}
-type PresenceWithEpoch = PresenceRecord & {
-    readonly epoch?: number;
-};
-export declare function registryPath(env?: NodeJS.ProcessEnv): string;
-export declare function canonicalSquarePath(squarePath: string): Promise<string>;
-export declare function presenceEpoch(record: PresenceWithEpoch | undefined): number;
-/** Runs `fn` inside the ownership claim critical section, under the same lock as claims and finalize. */
-export declare function withOwnershipClaimLock<T>(env: NodeJS.ProcessEnv, fn: () => Promise<T>, signal?: AbortSignal): Promise<T>;
-export declare function recordJoin(sessionId: string, name: string, squarePath: string, options?: RegistryWriteOptions): Promise<void>;
-export declare function recordDone(sessionId: string, name: string, squarePath: string, options?: RegistryWriteOptions): Promise<void>;
-export declare function readActiveBindings(now?: number, env?: NodeJS.ProcessEnv): Promise<RegistryBinding[]>;
-export declare function lookupSessionBindings(sessionId: string, now?: number, env?: NodeJS.ProcessEnv): Promise<RegistryBinding[]>;
-export declare function lookupSession(sessionId: string, now?: number, env?: NodeJS.ProcessEnv): Promise<Array<{
-    name: string;
-    squarePath: string;
-}>>;
-export declare function lookupParticipant(squarePath: string, name: string, now?: number, env?: NodeJS.ProcessEnv): Promise<RegistryBinding[]>;
-export declare function localParticipantOwner(squarePath: string, name: string, env?: NodeJS.ProcessEnv, now?: number): Promise<string | undefined>;
-export declare function localParticipantName(squarePath: string, env?: NodeJS.ProcessEnv): Promise<string | undefined>;
+/** Participant ownership and local session identity on the host ledger. */
+import { type FileHostLedgerPort } from './host-ledger-file-adapter.js';
+import type { HostLedgerPort, PresenceChannel, PresenceRecord } from './host-ledger.js';
+export declare function presenceEpoch(record: PresenceRecord | undefined): number;
+export declare function localParticipantName(squarePath: string, hostLedger: HostLedgerPort, env?: NodeJS.ProcessEnv): Promise<string | undefined>;
 export declare function squareAssignedParticipantName(env?: NodeJS.ProcessEnv): string | undefined;
-export type CurrentParticipantBinding = Readonly<{
-    created: boolean;
-    sessionId: string;
-}>;
 export type OwnershipClaim = {
     readonly status: 'acquired' | 'owned';
-    readonly record: PresenceWithEpoch;
+    readonly record: PresenceRecord;
     readonly sessionId: string;
     readonly epoch: number;
 } | undefined;
@@ -62,43 +23,31 @@ export type TakeoverRunResult<T> = {
     readonly status: 'busy';
     readonly epoch: number;
 };
-export declare function readParticipantOwner(squarePath: string, name: string, env?: NodeJS.ProcessEnv): Promise<RegistryBinding | undefined>;
-export declare function sessionOwnsParticipant(squarePath: string, name: string, sessionId: string, env?: NodeJS.ProcessEnv, expectedEpoch?: number): Promise<boolean>;
-export declare function releaseSessionParticipantClaim(squarePath: string, name: string, env: NodeJS.ProcessEnv, claim: OwnershipClaim): Promise<void>;
-export declare function claimSessionParticipant(squarePath: string, name: string, env?: NodeJS.ProcessEnv, signal?: AbortSignal): Promise<OwnershipClaim>;
+export declare function readParticipantOwner(squarePath: string, name: string, hostLedger: HostLedgerPort): Promise<PresenceRecord | undefined>;
+export declare function sessionOwnsParticipant(squarePath: string, name: string, sessionId: string, hostLedger: HostLedgerPort, expectedEpoch?: number): Promise<boolean>;
+export declare function releaseSessionParticipantClaim(hostLedger: HostLedgerPort, claim: OwnershipClaim): Promise<void>;
+export declare function claimSessionParticipant(squarePath: string, name: string, hostLedger: HostLedgerPort, env?: NodeJS.ProcessEnv, signal?: AbortSignal): Promise<OwnershipClaim>;
 /**
  * Fenced takeover: the ownership claim and the lifecycle run as one critical section under the
- * presence-claim lock, so no second takeover can interleave between claim and commit. The claim
+ * claim lock, so no second takeover can interleave between claim and commit. The claim
  * persists nothing until the lifecycle commits: standing owner rows stay authoritative through
  * the lifecycle (a self-takeover can therefore never clobber its own standing row). On success
  * the standing rows are replaced by the new owner's row at the claim epoch; on refusal, rows
  * carrying the claim token (session + channel + claim epoch) are withdrawn and the captured
  * standing rows are restored exactly.
  */
-export declare function claimSessionTakeover<T>(squarePath: string, name: string, env: NodeJS.ProcessEnv | undefined, opts: {
+export declare function claimSessionTakeover<T>(squarePath: string, name: string, hostLedger: HostLedgerPort, env: NodeJS.ProcessEnv | undefined, opts: {
     readonly expectedEpoch?: number;
     readonly expectedSession?: string;
 } | undefined, lifecycle: (claim: TakeoverClaimToken) => Promise<T>, signal?: AbortSignal): Promise<TakeoverRunResult<T>>;
-export declare function releaseSessionParticipant(squarePath: string, name: string, env?: NodeJS.ProcessEnv): Promise<void>;
-export declare function bindCurrentParticipant(squarePath: string, name: string, env?: NodeJS.ProcessEnv): Promise<CurrentParticipantBinding>;
-export declare function unbindCurrentParticipant(squarePath: string, name: string, env?: NodeJS.ProcessEnv): Promise<boolean>;
-export interface RegistryPruneResult {
-    removed: number;
-    kept: number;
-}
-export declare function pruneRegistry(readActs: (squarePath: string) => StoredAct[] | undefined | Promise<StoredAct[] | undefined>, now?: number): Promise<RegistryPruneResult>;
+export declare function releaseSessionParticipant(squarePath: string, name: string, hostLedger: HostLedgerPort, env?: NodeJS.ProcessEnv): Promise<void>;
 export interface LocalSessionIdentity {
     sessionId: string;
-    channel: SessionChannel;
+    channel: PresenceChannel;
     child: boolean;
     paseoAgentId?: string;
 }
 export declare function localSessionIdentities(env?: NodeJS.ProcessEnv): LocalSessionIdentity[];
 export declare function hasAutomaticDeliveryIdentity(env?: NodeJS.ProcessEnv): boolean;
-export declare function recordLocalJoin(name: string, squarePath: string, env?: NodeJS.ProcessEnv): Promise<void>;
-export declare function recordLocalDone(name: string, squarePath: string, env?: NodeJS.ProcessEnv): Promise<void>;
-export declare function recordSessionJoin(sessionId: string, name: string, squarePath: string, channel: SessionChannel, env?: NodeJS.ProcessEnv): Promise<string>;
-export declare function recordSessionDone(sessionId: string, name: string, squarePath: string, channel: SessionChannel, env?: NodeJS.ProcessEnv): Promise<boolean>;
 /** Bind the host ledger to the caller's captured environment. */
-export declare function hostLedgerForEnv(env?: NodeJS.ProcessEnv): HostLedgerPort;
-export {};
+export declare function hostLedgerForEnv(env?: NodeJS.ProcessEnv): FileHostLedgerPort;