@astrosheep/square 0.3.11 → 0.3.12

package/dist/list.js

@@ -1,37 +1,11 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { parseSquare } from './artifact.js';
+import { probeSquare } from './artifact.js';
 import { inSquareCount, publicActs } from './runtime.js';
 import { formatRelativeTime } from './time.js';
 const DEFAULT_LIST_DEPTH = 4;
 const LIST_SKIP_DIRS = new Set(['.git', 'node_modules', 'dist']);
-function frontmatterOf(text) {
-    const match = text.match(/^---\n([\s\S]*?)\n---(?:\n|$)/);
-    return match ? match[1] : null;
-}
-function candidateFrontmatter(filePath) {
-    let fd;
-    try {
-        fd = fs.openSync(filePath, 'r');
-        const buffer = Buffer.allocUnsafe(4096);
-        const bytesRead = fs.readSync(fd, buffer, 0, buffer.length, 0);
-        const prefix = buffer.toString('utf8', 0, bytesRead);
-        if (!prefix.startsWith('---\n'))
-            return null;
-        const frontmatter = frontmatterOf(prefix);
-        return frontmatter ?? frontmatterOf(fs.readFileSync(filePath, 'utf8'));
-    }
-    catch {
-        return null;
-    }
-    finally {
-        if (fd !== undefined)
-            fs.closeSync(fd);
-    }
-}
 function readSquareListItem(filePath, root) {
-    let text;
-    let doc;
     let stat;
     try {
         stat = fs.statSync(filePath);
@@ -39,27 +13,9 @@ function readSquareListItem(filePath, root) {
     catch {
         return null;
     }
-    const frontmatter = candidateFrontmatter(filePath);
-    if (!frontmatter)
-        return null;
-    if (!/^hard_cap:\s*(-1|\d+)\s*$/m.test(frontmatter))
+    const doc = probeSquare(filePath);
+    if (doc === undefined)
         return null;
-    if (!/^format_version:\s*3\s*$/m.test(frontmatter))
-        return null;
-    try {
-        text = fs.readFileSync(filePath, 'utf8');
-    }
-    catch {
-        return null;
-    }
-    if (!text.includes('<!-- square:warmup -->') || !text.includes('<!-- square:activities -->'))
-        return null;
-    try {
-        doc = parseSquare(text);
-    }
-    catch {
-        return null;
-    }
     const relative = path.relative(root, filePath) || path.basename(filePath);
     return {
         path: relative,

package/dist/model.js

@@ -11,12 +11,6 @@ export class SquareError extends Error {
         this.name = 'SquareError';
     }
 }
-export const WARMUP_HEADING = '## Warmup';
-export const WARMUP_MARKER = '<!-- square:warmup -->';
-export const ACTIVITIES_HEADING = '## Activities';
-export const ACTIVITIES_MARKER = '<!-- square:activities -->';
-export const ACT_MARKER_PREFIX = '<!-- square:act';
-export const CURRENT_FORMAT_VERSION = 3;
 export function formatHardCap(hardCap) {
     return hardCap === null ? '-1' : String(hardCap);
 }

package/dist/notifications.js

@@ -4,11 +4,12 @@ import { homedir } from 'node:os';
 import { setTimeout as sleep } from 'node:timers/promises';
 import { fileURLToPath } from 'node:url';
 import { loadSquare } from './artifact.js';
-import { deriveDeliveryModel, isDeliveryDelivered, isPendingNotification, leaseOwnsNotification, planActNotifications, } from './delivery.js';
+import { deriveDeliveryModel, isDeliveryDelivered, leaseOwnsNotification, planActNotifications, } from './delivery.js';
 import { sessionInbox } from './inbox.js';
 import { hasPresentedAttention } from './presented.js';
 import { nameKey, SquareError } from './model.js';
 import { SLEEP_MS, matchesMentionTarget, resolveRosterName, rosterNames } from './runtime.js';
+import { formatActivityId, parseActivityId } from './square-core.js';
 import { PaseoAdapter } from './paseo-delivery.js';
 import { quoteShell } from './presentation.js';
 import { lookupParticipant } from './registry.js';
@@ -42,7 +43,7 @@ function renderWakePayload(request) {
         : request.squarePath;
     return [
         '<system-reminder source="square">',
-        `${request.route === 'bell' ? 'Bell' : request.route === 'beside' ? 'Beside' : 'Mention'} from @${request.actor} in \`${display}\``,
+        `${request.route === 'bell' ? 'Bell' : 'Mention'} from @${request.actor} in \`${display}\``,
         'The native adapter will present it at the next boundary. If no native wake is available, pull from the square yourself.',
         `\`${catchCommand(request.squarePath, request.recipient)}\``,
         '</system-reminder>',
@@ -57,7 +58,6 @@ async function waitForCatch(route, request, body) {
         actor: request.actor,
         body,
         route: request.route,
-        recipient: request.recipient,
     }))
         return false;
     const deadline = Date.now() + 180_000;
@@ -75,14 +75,22 @@ async function waitForCatch(route, request, body) {
     }
     return false;
 }
+function notificationIndex(ref) {
+    if (typeof ref === 'number')
+        return ref;
+    const index = parseActivityId(ref);
+    if (index === undefined)
+        throw new Error(`Invalid act ref: ${ref}`);
+    return index;
+}
 export function hasDeliveredNotification(squarePath, name, ref) {
     const doc = loadSquare(squarePath);
-    return isDeliveryDelivered(doc, known(doc, name), typeof ref === 'number' ? ref : Number(ref.slice(4)));
+    return isDeliveryDelivered(doc, known(doc, name), notificationIndex(ref));
 }
 export function hasAttentionNotification(squarePath, name, ref, env = process.env) {
     const doc = loadSquare(squarePath);
     const recipient = known(doc, name);
-    const index = typeof ref === 'number' ? ref : Number(ref.slice(4));
+    const index = notificationIndex(ref);
     return isDeliveryDelivered(doc, recipient, index) || hasPresentedAttention(squarePath, recipient, index, env);
 }
 export async function waitForDeliveredNotification(squarePath, name, ref, opts = {}) {
@@ -95,7 +103,7 @@ export async function waitForDeliveredNotification(squarePath, name, ref, opts =
     return false;
 }
 function notifyLeaseKey(recipient, actIndex) {
-    return JSON.stringify([`act_${actIndex}`, nameKey(recipient)]);
+    return JSON.stringify([formatActivityId(actIndex), nameKey(recipient)]);
 }
 async function claimNotifyLease(squarePath, recipient, actIndex) {
     const at = Date.now();
@@ -214,7 +222,7 @@ export async function processActNotificationsOnce(squarePath, actIndex, opts = {
     const item = doc.acts.find((candidate) => candidate.index === actIndex);
     if (item === undefined)
         return;
-    const notifications = planActNotifications(doc, item).filter(isPendingNotification);
+    const notifications = planActNotifications(doc, item);
     await Promise.all(notifications.map((notification) => processNotification(squarePath, notification, opts)));
 }
 function launchWorker(workerPath, args) {
@@ -227,7 +235,7 @@ export async function dispatchActNotifications(squarePath, item, opts = {}) {
     if (env.SQUARE_DISABLE_PASEO_WAKE === '1')
         return;
     const doc = loadSquare(squarePath);
-    if (!planActNotifications(doc, item).some(isPendingNotification))
+    if (planActNotifications(doc, item).length === 0)
         return;
     (opts.launchWorker ?? launchWorker)(fileURLToPath(new URL('./cmd/notify-once.js', import.meta.url)), ['--location', squarePath, '--act-index', String(item.index)]);
 }

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 = {}) {
@@ -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,
         }))

package/dist/runtime.js

@@ -1,4 +1,4 @@
-import { fold } from './square-core.js';
+import { audienceIncludes, audienceOf, fold, formatActivityId } from './square-core.js';
 import { SquareError, findParticipantName, nameKey, sameName, } from './model.js';
 function parseIntegerEnvValue(name, raw, fallback) {
     if (raw === undefined)
@@ -51,27 +51,12 @@ export function nowMs() {
     }
     return value;
 }
-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;
-}
-/** Pure directed-activity filter. Broadcast bodies (no @) match any named viewer. */
+/** Pure directed-activity filter. Bell matches every viewer; mentions match by audience. */
 export function matchesMentionTarget(act, mention) {
-    if (act.reach === 'bell')
-        return true;
-    if (act.reach !== undefined) {
-        return mention === true || sameName(act.reach.beside, mention);
-    }
-    const mentions = extractMentions(act.body);
+    const audience = audienceOf(act);
     if (mention === true)
-        return mentions.length > 0;
-    if (mentions.length === 0)
-        return true;
-    return mentions.some((name) => sameName(name, mention));
+        return audience.kind === 'bell' || audience.names.length > 0;
+    return audienceIncludes(audience, mention);
 }
 export function foldedState(doc) {
     return fold(doc.acts);
@@ -131,7 +116,7 @@ export function actStableIndex(act) {
 }
 export function actId(actOrIndex) {
     const index = typeof actOrIndex === 'number' ? actOrIndex : actStableIndex(actOrIndex);
-    return `act_${index}`;
+    return formatActivityId(index);
 }
 export function getReadState(doc, name) {
     return doc.runtime.cursors[name] ?? Object.entries(doc.runtime.cursors).find(([participant]) => sameName(participant, name))?.[1];

package/dist/square-application.js

@@ -1,21 +1,16 @@
 import fs from 'node:fs';
-import path from 'node:path';
-import { emptyRuntimeState, loadRuntimeSidecar, loadSquare, mergeRuntimeState, renderArtifactAct, renderSquare, renderSquareDoc, saveRuntimeSidecar } from './artifact.js';
+import { createSquareDoc, loadArchive, loadSquare, writeArchiveFile, writeSquareFile } from './artifact.js';
 import { coreCompact, coreDone, coreHold, coreResume, decideAct, decideJoin, resolveKnownName } from './decisions.js';
-import { planRepair } from './doctor.js';
 import { withFileLock } from './file-lock.js';
 import { stageReplacement } from './harness-stage.js';
 import { SquareError } from './model.js';
 import { advanceCursor, freshWatchLease, LOCK_RETRY_MS, LOCK_STALE_MS, removeWatchLease, touchPresenceCursor, watchLease, writeWatchLease } from './runtime.js';
-/** The only persistence primitive: one per-square lock, one Markdown write, one sidecar write. */
+/** The only mutation boundary: one per-square lock around one complete snapshot commit. */
 export async function withSquareLock(squarePath, fn) {
     return withFileLock(`${squarePath}.lock`, { retryMs: LOCK_RETRY_MS, staleMs: LOCK_STALE_MS }, fn);
 }
 export function writeSquareDoc(squarePath, doc) {
-    const temporary = path.join(path.dirname(squarePath), `.${path.basename(squarePath)}.${process.pid}.${Date.now()}.tmp`);
-    fs.writeFileSync(temporary, renderSquareDoc(doc));
-    fs.renameSync(temporary, squarePath);
-    saveRuntimeSidecar(squarePath, doc.runtime);
+    writeSquareFile(squarePath, doc);
 }
 export function appendAct(squarePath, doc, act) {
     const stored = applyActs(doc, [act])[0];
@@ -35,13 +30,11 @@ function applyActs(doc, acts, mutateRuntime) {
     mutateRuntime?.(doc);
     return stored;
 }
-/**
- * Publish a dependent persistence file before the Square document. A retained
- * backup lets a failed document commit restore the prior file exactly.
- */
-function prepareAppend(filePath, block, existing = fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf8') : '') {
+/** Publish a dependent archive before the main snapshot, retaining rollback evidence. */
+function prepareArchive(filePath, acts) {
+    const existing = fs.existsSync(filePath) ? loadArchive(filePath) : [];
     return stageReplacement(filePath, (stage) => {
-        fs.writeFileSync(stage, `${existing}${existing === '' ? '' : '\n'}${block}\n`);
+        writeArchiveFile(stage, [...existing, ...acts]);
     });
 }
 function plan(doc, intent) {
@@ -156,27 +149,9 @@ function plan(doc, intent) {
                 replaceDoc: result.doc,
                 preparePersistence: archive.length === 0
                     ? undefined
-                    : () => {
-                        const existing = fs.existsSync(intent.archivePath) ? fs.readFileSync(intent.archivePath, 'utf8') : '';
-                        const block = archive
-                            .map((act, index) => renderArtifactAct(act, { first: existing === '' && index === 0 }))
-                            .join('\n');
-                        return prepareAppend(intent.archivePath, block, existing);
-                    },
+                    : () => prepareArchive(intent.archivePath, archive),
             };
         }
-        case 'repair':
-            return {
-                result: undefined,
-                acts: [],
-                replaceDoc: intent.doc,
-                preparePersistence: intent.quarantine === undefined || intent.quarantine.blocks.length === 0
-                    ? undefined
-                    : () => {
-                        const block = intent.quarantine.blocks.join('\n\n');
-                        return prepareAppend(intent.quarantine.path, block);
-                    },
-            };
     }
 }
 function commitPlan(squarePath, doc, planned) {
@@ -213,50 +188,6 @@ export async function createSquare(squarePath, options, snippet) {
         if (fs.existsSync(squarePath) && !options.force) {
             throw new SquareError('conflict', `Refusing to overwrite existing square: ${squarePath}\nPass -f to overwrite.`);
         }
-        const temporary = path.join(path.dirname(squarePath), `.${path.basename(squarePath)}.${process.pid}.${Date.now()}.tmp`);
-        fs.mkdirSync(path.dirname(squarePath), { recursive: true });
-        fs.writeFileSync(temporary, renderSquare(options, snippet));
-        fs.renameSync(temporary, squarePath);
-        saveRuntimeSidecar(squarePath, emptyRuntimeState(0));
-    });
-}
-/** Keep artifact repair planning and dependent quarantine persistence inside the application boundary. */
-export async function repairSquare(squarePath) {
-    const result = await withSquareLock(squarePath, () => {
-        let text;
-        try {
-            text = fs.readFileSync(squarePath, 'utf8');
-        }
-        catch (error) {
-            if (error.code === 'ENOENT')
-                throw new SquareError('not_found', `square file not found: ${squarePath}`);
-            throw error;
-        }
-        const repair = planRepair(text);
-        if (repair.diagnosis.unfixable || repair.repaired === undefined)
-            return { repair };
-        // Repair changes Markdown only. Keep the sidecar's runtime metadata and
-        // merge history boundaries so a doctor run cannot erase delivery state or
-        // reuse a stable activity index.
-        const sidecarRuntime = loadRuntimeSidecar(squarePath, repair.repaired.doc.runtime);
-        const indexesPreserved = repair.diagnosis.acts.every(({ act }, index) => repair.repaired.doc.acts[index]?.index === act.index);
-        if (indexesPreserved) {
-            repair.repaired.doc.runtime = mergeRuntimeState(repair.repaired.doc.runtime, sidecarRuntime);
-        }
-        else {
-            repair.repaired.doc.runtime = emptyRuntimeState(Math.max(repair.repaired.doc.runtime.nextActIndex, sidecarRuntime.nextActIndex));
-            repair.repaired.actions.push({ message: 'reset runtime delivery metadata because act indexes changed' });
-        }
-        const quarantinePath = squarePath.replace(/\.md$/, '') + '.quarantine.md';
-        const intent = {
-            type: 'repair',
-            doc: repair.repaired.doc,
-            ...(repair.repaired.quarantinedBlocks.length === 0
-                ? {}
-                : { quarantine: { path: quarantinePath, blocks: repair.repaired.quarantinedBlocks } }),
-        };
-        commitPlan(squarePath, repair.repaired.doc, plan(repair.repaired.doc, intent));
-        return { repair };
+        writeSquareFile(squarePath, createSquareDoc(options, snippet));
     });
-    return result.repair;
 }

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/wake-attempts.js

@@ -4,6 +4,7 @@ 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;
@@ -12,7 +13,7 @@ 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), `act_${attention.actIndex}`, nameKey(attention.recipient)]);
+    return JSON.stringify([canonicalSquarePath(attention.squarePath), formatActivityId(attention.actIndex), nameKey(attention.recipient)]);
 }
 function parseRow(raw, now) {
     let value;
@@ -27,7 +28,7 @@ function parseRow(raw, now) {
     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' || !/^act_\d+$/.test(row.attention.act_id) ||
+        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 ||
@@ -62,11 +63,14 @@ function writeRows(filePath, rows) {
     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: Number(row.attention.act_id.slice(4)),
+            actIndex,
             recipient: row.attention.recipient,
         },
         routeKind: row.route_kind,
@@ -121,7 +125,7 @@ function toRow(attempt, env) {
         ts: safe.at,
         attention: {
             square_path: canonicalSquarePath(safe.attention.squarePath),
-            act_id: `act_${safe.attention.actIndex}`,
+            act_id: formatActivityId(safe.attention.actIndex),
             recipient: safe.attention.recipient,
         },
         route_kind: safe.routeKind,