@astrosheep/square 0.3.62 → 0.3.64

package/dist/cli/observation-commands.js

@@ -1,10 +1,10 @@
-import { runClaudeHookAsync } from '../claude-hook.js';
+import { runClaudeMod } from '../claude-mod.js';
 import { runCodexHookAsync } from '../codex-hook.js';
 import { sessionInbox } from '../inbox.js';
 import { sweepPendingNotifications } from '../notifications.js';
 import { cmdListSquares } from '../list.js';
 import { nameKey, parseActivityId, sameName } from '../model.js';
-import { commandPrefix, participantIdentity, renderGrepActivitiesView, renderEventCli, renderAmbientEvent, renderPresenceAnchor, truncateChars, withPathOutput, quoteShell, } from '../presentation.js';
+import { commandPrefix, participantIdentity, renderGrepActivitiesView, renderEventCli, renderAmbientEventFacts, renderPresenceAnchor, truncateChars, withPathOutput, quoteShell, } from '../presentation.js';
 import { actId, nowMs } from '../runtime.js';
 import { style } from '../tty-style.js';
 import { cmdStream, cmdStreamNdjson } from '../stream.js';
@@ -31,9 +31,6 @@ function inboxDisplay(value) {
     const truncated = truncateChars(value, INBOX_DISPLAY_CHARS - 1);
     return truncated.remaining === 0 ? truncated.text : `${truncated.text}…`;
 }
-function inboxLimitCommand(sessionId, json) {
-    return `square inbox --for-session ${quoteShell(sessionId)} --limit ${INBOX_MAX_LIMIT}${json ? ' --json' : ''}`;
-}
 export const listCommand = {
     parse: (argv) => argv,
     async execute(argv, context) {
@@ -305,37 +302,9 @@ function parseHistory(argv, context) {
         continuationArgs: historyContinuationArgs(argv),
     };
 }
-function applicationHistoryQuery(options) {
-    return {
-        ...(options.participants === undefined || options.participants.length === 0 ? {} : { from: options.participants }),
-        ...(options.mention === undefined ? {} : { mention: options.mention }),
-        ...(options.afterIndex === undefined ? {} : { after: actId(options.afterIndex) }),
-        ...(options.beforeIndex === undefined ? {} : { before: actId(options.beforeIndex) }),
-        ...(options.grep === undefined ? {} : { grep: options.grep }), ...(options.fixed === undefined ? {} : { fixed: options.fixed }),
-        order: 'asc',
-    };
-}
-function activityAsStored(activity) {
-    const index = parseActivityId(activity.id);
-    if (index === undefined)
-        throw new Error('Application returned a non-canonical activity id');
-    switch (activity.kind) {
-        case 'say': return { index, kind: 'say', actor: activity.actor, at: activity.at, body: activity.body ?? '', mentions: activity.mentions, ...(activity.reach === undefined ? {} : { reach: activity.reach }), ...(activity.reply === undefined ? {} : { reply: parseActivityId(activity.reply) ?? undefined }) };
-        case 'done': return { index, kind: 'done', actor: activity.actor, at: activity.at, body: activity.body ?? '' };
-        case 'hold': return { index, kind: 'hold', actor: activity.actor, at: activity.at, ...(activity.body === undefined ? {} : { body: activity.body }) };
-        case 'resume': return { index, kind: 'resume', actor: activity.actor, at: activity.at };
-        case 'join': return { index, kind: 'join', actor: activity.actor, at: activity.at };
-        case 'listen': return { index, kind: 'listen', actor: activity.actor, target: activity.target ?? '', at: activity.at };
-        case 'ignore': return { index, kind: 'ignore', actor: activity.actor, target: activity.target ?? '', at: activity.at };
-    }
-}
-function historyContinuationCommand(options, squarePath, direction, index) {
-    const args = [...(options.continuationArgs ?? []), direction, actId(index), '--limit', String(options.lastN ?? HISTORY_DEFAULT_LIMIT)];
-    return `${commandPrefix(squarePath)} history ${args.map((arg) => arg.startsWith('-') || /^act\/\d+$/.test(arg) || /^\d+$/.test(arg) ? arg : quoteShell(arg)).join(' ')}`;
-}
-function boundedHistoryCommand(options, squarePath) {
-    const args = [...(options.continuationArgs ?? []), '--limit', String(HISTORY_MAX_LIMIT)];
-    return `${commandPrefix(squarePath)} history ${args.map((arg) => arg.startsWith('-') || /^act\/\d+$/.test(arg) || /^\d+$/.test(arg) ? arg : quoteShell(arg)).join(' ')}`;
+function historyContinuationCommand(options, squarePath, args) {
+    const full = [...(options.continuationArgs ?? []), ...args];
+    return `${commandPrefix(squarePath)} history ${full.map((arg) => arg.startsWith('-') || /^act\/\d+$/.test(arg) || /^\d+$/.test(arg) ? arg : quoteShell(arg)).join(' ')}`;
 }
 /** The archive-visible activity model: content plus the lifecycle moves that keep its story honest — a raised hand pairs with its lowering, and a departure pairs with the return. */
 function isArchiveActivity(item) {
@@ -377,6 +346,8 @@ function renderHistoryProjection(projection, visible, noTruncate, squarePath) {
     const shown = visible.filter(isArchiveActivity);
     const preview = noTruncate || shown.length <= 1 ? undefined : 200;
     const chunks = [];
+    // Presence anchors collect into one closing line instead of interrupting the page.
+    const anchored = [];
     for (const activity of shown) {
         const options = {
             preview,
@@ -385,15 +356,18 @@ function renderHistoryProjection(projection, visible, noTruncate, squarePath) {
         const rendered = renderEventCli(activity, options);
         if (rendered !== '')
             chunks.push(rendered);
-        const participants = projection.presenceAnchors[activity.index];
-        if (participants !== undefined)
-            chunks.push(renderPresenceAnchor(participants));
+        for (const participant of projection.presenceAnchors[activity.index] ?? []) {
+            if (!anchored.some((existing) => sameName(existing, participant)))
+                anchored.push(participant);
+        }
     }
     if (chunks.length === 0)
         return 'latest\n  ○ no public activity in this view';
     if (preview !== undefined && shown.some((activity) => activity.kind === 'say' && activity.body.length > preview)) {
         chunks.push(`${commandPrefix(squarePath)} history --no-truncate`);
     }
+    if (anchored.length > 0)
+        chunks.push(renderPresenceAnchor(anchored));
     return chunks.join('\n\n');
 }
 export const historyCommand = {
@@ -403,15 +377,14 @@ export const historyCommand = {
         const square = await openSquare(squarePath, { clock: nowMs, env: context.env, hostLedger: hostLedgerForEnv(context.env) });
         try {
             // Keep the projection chronological; pagination chooses a stable edge,
-            // then --order only changes how the selected page is displayed.
+            // then --order only changes how the selected page is displayed. The
+            // plain archive hides `read` bookkeeping, while --at/-C/--since windows
+            // render the raw activity stream around their coordinates.
             const projection = await historyPresentation(square, { ...options, order: 'asc' });
-            const useApplicationHistory = options.atIndexes === undefined && options.beforeContext === undefined && options.afterContext === undefined && options.after === undefined;
-            const applicationHistory = useApplicationHistory
-                ? await createSquareApplication({ cwd: context.cwd, env: { ...context.env, SQUARE_PARTICIPANT_NAME: undefined }, squarePath, clock: nowMs }).history(applicationHistoryQuery(options))
-                : undefined;
-            let events = applicationHistory === undefined ? [...projection.activities] : applicationHistory.map(activityAsStored);
+            const hideReadActs = options.atIndexes === undefined && options.beforeContext === undefined && options.afterContext === undefined && options.after === undefined;
+            let events = hideReadActs ? projection.activities.filter((activity) => activity.kind !== 'read') : [...projection.activities];
             if (options.lastN === null && events.length > HISTORY_MAX_LIMIT) {
-                fail(`✕ history is capped at ${HISTORY_MAX_LIMIT} activities\n${boundedHistoryCommand(options, squarePath)}`);
+                fail(`✕ history is capped at ${HISTORY_MAX_LIMIT} activities\n${historyContinuationCommand(options, squarePath, ['--limit', String(HISTORY_MAX_LIMIT)])}`);
             }
             const searching = options.grep !== undefined || options.fixed !== undefined;
             const totalMatches = searching ? events.length : 0;
@@ -440,7 +413,7 @@ export const historyCommand = {
                 : allPublic.some((item) => item.index < (pageMin ?? Infinity)));
             const cursorDirection = options.afterIndex !== undefined ? '--after' : '--before';
             const cursorIndex = cursorDirection === '--after' ? Math.max(...publicEvents.map((item) => item.index)) : Math.min(...publicEvents.map((item) => item.index));
-            const continuation = hasMore ? `\n\n${historyContinuationCommand(options, squarePath, cursorDirection, cursorIndex)}` : '';
+            const continuation = hasMore ? `\n\n${historyContinuationCommand(options, squarePath, [cursorDirection, actId(cursorIndex), '--limit', String(options.lastN ?? HISTORY_DEFAULT_LIMIT)])}` : '';
             return withPathOutput(squarePath, output + continuation, { participantCount: projection.participantCount });
         }
         finally {
@@ -522,10 +495,10 @@ export const statusCommand = {
                         ? '◎'
                         : participant.activityCount > 0 ? '●' : '○';
                     const summary = participant.presence === 'watching'
-                        ? 'catching'
+                        ? 'is nearby · catching'
                         : participant.activityCount > 0
-                            ? formatRelativeTime(participant.lastActiveAt ?? result.now, result.now)
-                            : `quiet · ${participant.lastActiveAt === undefined ? 'just now' : formatRelativeTime(participant.lastActiveAt, result.now)}`;
+                            ? `is nearby · ${formatRelativeTime(participant.lastActiveAt ?? result.now, result.now)}`
+                            : `is nearby · quiet · ${participant.lastActiveAt === undefined ? 'just now' : formatRelativeTime(participant.lastActiveAt, result.now)}`;
                     const showAttention = context.name === undefined || sameName(participant.name, context.name);
                     const attention = !showAttention
                         ? ''
@@ -534,7 +507,7 @@ export const statusCommand = {
                             : participant.unreadActivityCount > 0
                                 ? `${participant.unreadActivityCount} change${participant.unreadActivityCount === 1 ? '' : 's'} waiting`
                                 : 'caught up';
-                    return `  ${glyph} ${participantIdentity(participant.name)}${style('dim', ` · ${summary}${attention === '' ? '' : ` · ${attention}`}`)}`;
+                    return `  ${glyph} ${participantIdentity(participant.name)}${style('dim', ` ${summary}${attention === '' ? '' : ` · ${attention}`}`)}`;
                 }));
                 const unshown = Math.max(0, orderedHere.length - STATUS_PARTICIPANT_PREVIEW_LIMIT) + lingering;
                 if (orderedHere.length > STATUS_PARTICIPANT_PREVIEW_LIMIT) {
@@ -554,18 +527,18 @@ export const statusCommand = {
                 ? `· ${result.holdActor === undefined ? 'someone' : participantIdentity(result.holdActor)} raised a hand${result.holdReason ? ` — ${result.holdReason}` : ''}${style('dim', ` · ${holdTime}`)}`
                 : undefined;
             const visible = result.latestAct === undefined
-                ? ''
-                : renderAmbientEvent(result.latestAct, context.name ?? '', {
+                ? { text: '', bodyClipped: false }
+                : renderAmbientEventFacts(result.latestAct, context.name ?? '', {
                     now: result.now,
                     preview: 200,
                     actNumber: presentation.latestActNumber,
                     squareState: presentation.state,
                 });
-            const latest = visible === ''
+            const latest = visible.text === ''
                 ? [result.latestAct === undefined
                         ? '  ○ no public activity yet'
                         : '  · the latest words were meant for other ears']
-                : [`  ${visible.replace(/\n/g, '\n  ')}`];
+                : [`  ${visible.text.replace(/\n/g, '\n  ')}`];
             // Presence events after the latest public act: otherwise the roster can say someone is
             // here while the latest line shows them leaving, with nothing to reconcile the two.
             const latestIndex = result.latestAct?.index ?? -1;
@@ -576,7 +549,7 @@ export const statusCommand = {
             }
             if (stepsIn.length > 3)
                 latest.push(style('dim', `  → … ${stepsIn.length - 3} more stepped in`));
-            if (visible.includes('more chars') && result.latestAct !== undefined) {
+            if (visible.bodyClipped && result.latestAct !== undefined) {
                 latest.push(`${commandPrefix(squarePath)} history --at ${actId(result.latestAct)} -C 2 --no-truncate`);
             }
             const counts = [
@@ -624,7 +597,7 @@ export const inboxCommand = {
         }
         if (!sessionId)
             fail('inbox requires --for-session <session-id>.');
-        const retry = inboxLimitCommand(sessionId, json);
+        const retry = `square inbox --for-session ${quoteShell(sessionId)} --limit ${INBOX_MAX_LIMIT}${json ? ' --json' : ''}`;
         if (duplicateLimit)
             fail(`✕ inbox accepts one --limit\n${retry}`);
         const limit = hasLimit
@@ -673,5 +646,5 @@ function hookCommand(runHook) {
         present: (result) => process.stdout.write(result),
     };
 }
-export const claudeHookCommand = hookCommand(runClaudeHookAsync);
+export const claudeModCommand = hookCommand(runClaudeMod);
 export const codexHookCommand = hookCommand(runCodexHookAsync);

package/dist/cli/program.js

@@ -1,46 +1,48 @@
 import { helpRequest } from '../help.js';
 import { isSquareError } from '../model.js';
-import { formatRefusal, joinRecoveryCommand, participantsRecoveryCommand, takeoverRecoveryLines } from '../presentation.js';
+import { commandPrefix, formatRefusal, joinRecoveryCommand, participantsRecoveryCommand, takeoverRecoveryLines } from '../presentation.js';
 import { inSquareCount, nowMs } from '../runtime.js';
 import { openSquare } from '../square-file-adapter.js';
 import { closeOpenSquare } from '../open-square.js';
 import { defaultContext, parseGlobalArgs } from './context.js';
 import { executeRegisteredCommand, findCommand } from './registry.js';
-async function participantCountFor(squarePath) {
-    try {
-        const square = await openSquare(squarePath, { clock: nowMs });
-        try {
-            return inSquareCount((await square.artifact.read()).state);
-        }
-        finally {
-            await closeOpenSquare(square);
-        }
-    }
-    catch {
-        return undefined;
-    }
-}
 async function handleSquareError(error, squarePath, name) {
     if (isSquareError(error)) {
         const existing = [error.message];
         if (squarePath !== undefined && name !== undefined && error.code === 'already_joined') {
             existing.push(...takeoverRecoveryLines(squarePath, name));
         }
-        else if (squarePath !== undefined && /^✕ .* has never stepped into/.test(error.message)) {
+        else if (squarePath !== undefined && error.facts?.reason === 'never_joined') {
             // The caller's name has never joined this square; only a join admits it.
             if (name !== undefined)
                 existing.push(joinRecoveryCommand(squarePath, name));
             else
                 existing.push(participantsRecoveryCommand(squarePath));
         }
-        else if (squarePath !== undefined && /^✕ .* is not standing in this square/.test(error.message)) {
+        else if (squarePath !== undefined && error.facts?.reason === 'not_standing') {
             existing.push(participantsRecoveryCommand(squarePath));
         }
+        else if (squarePath !== undefined && error.facts?.reason === 'not_addressed' && typeof error.facts.activityId === 'string') {
+            // An anchor only works for an activity the artifact actually holds.
+            existing.push(error.facts.activityExists === true
+                ? `${commandPrefix(squarePath)} history --at ${error.facts.activityId} -C 2`
+                : `${commandPrefix(squarePath)} history --limit 10`);
+        }
         if (squarePath === undefined) {
             process.stderr.write(`${existing.join('\n')}\n`);
         }
         else {
-            const participantCount = await participantCountFor(squarePath);
+            let participantCount;
+            try {
+                const square = await openSquare(squarePath, { clock: nowMs });
+                try {
+                    participantCount = inSquareCount((await square.artifact.read()).state);
+                }
+                finally {
+                    await closeOpenSquare(square);
+                }
+            }
+            catch { /* the header count is best effort */ }
             process.stderr.write(formatRefusal(squarePath, existing, participantCount === undefined ? {} : { participantCount }));
         }
         process.exit(error.code === 'not_found' ? 1 : 2);

package/dist/cli/registry.js

@@ -3,7 +3,7 @@ import { doctorCommand } from './maintenance-commands.js';
 import { harnessCommand, installCommand, uninstallCommand } from './harness-command.js';
 import { helpCommand, versionCommand } from './meta-commands.js';
 import { mcpServerCommand } from './mcp-server-command.js';
-import { catchCommand, claudeHookCommand, codexHookCommand, historyCommand, inboxCommand, listCommand, participantsCommand, statusCommand, streamCommand, } from './observation-commands.js';
+import { catchCommand, claudeModCommand, codexHookCommand, historyCommand, inboxCommand, listCommand, participantsCommand, statusCommand, streamCommand, } from './observation-commands.js';
 /** Every public command is an executable adapter, including aliases and utility commands. */
 export const commandRegistry = [
     { names: ['build'], spec: buildCommand },
@@ -11,7 +11,7 @@ export const commandRegistry = [
     { names: ['join'], spec: joinCommand },
     { names: ['stream'], spec: streamCommand },
     { names: ['inbox'], spec: inboxCommand },
-    { names: ['claude-hook'], spec: claudeHookCommand },
+    { names: ['claude-mod'], spec: claudeModCommand },
     { names: ['codex-hook'], spec: codexHookCommand },
     { names: ['catch'], spec: catchCommand },
     { names: ['express'], spec: expressCommand },

package/dist/cli/square-commands.js

@@ -1,7 +1,7 @@
 import { cmdActivity } from '../activity.js';
 import { scanMentionCandidates } from '../mention-parse.js';
 import { validateDoneBody } from '../decisions.js';
-import { formatHardCap, } from '../model.js';
+import { formatHardCap, sameName, } from '../model.js';
 import { formatRefusal, participantCommandPrefix, participantIdentity, takeoverRecoveryLines, renderRoomChangeText, renderAmbientEvent, withPathOutput, } from '../presentation.js';
 import { hostLedgerForEnv, hasAutomaticDeliveryIdentity, } from '../registry.js';
 import { actId, nowMs } from '../runtime.js';
@@ -59,7 +59,7 @@ export const buildCommand = {
         await createSquare(squarePath, intent.options, snippet);
         const cap = intent.options.hardCap === null ? 'unlimited' : formatHardCap(intent.options.hardCap);
         const throttle = intent.options.throttlePerMinute === undefined ? [] : [`  · throttle ${intent.options.throttlePerMinute}/min`];
-        return withPathOutput(squarePath, ['✓ the square is open', `  · cap ${cap}`, ...throttle, '  · nobody here yet — the first join steps in'].join('\n'), { participantCount: 0 });
+        return withPathOutput(squarePath, ['· the square stands ready', `  · cap ${cap}`, ...throttle].join('\n'), { participantCount: 0 });
     },
     present: (result) => process.stdout.write(result),
 };
@@ -130,11 +130,15 @@ export const joinCommand = {
                 : `✓ you banished the original ${participantIdentity(joinedName)} — the name is yours`;
         const isRejoin = joinKind !== 'joined';
         const reconnect = joinKind === 'reconnected';
+        // The long scene belongs to a name's first join here; a return reads its own line.
+        const joinedBefore = after.state.acts.filter((act) => act.kind === 'join' && sameName(act.actor, joinedName)).length > 1;
+        const rejoinScene = '*the flagstones are where you left them. so is your shadow.*';
+        const entryScene = joinKind !== 'joined' ? '' : joinedBefore ? rejoinScene : scene;
         const output = [
             entryLine,
             '',
             "· carved into the fountain's edge: every word here lands on a real ear — speak when someone needs it.",
-            ...(reconnect || scene === '' ? [] : ['', scene]),
+            ...(reconnect || entryScene === '' ? [] : ['', entryScene]),
             ...(isRejoin || contextText === '' ? [] : ['', style('dim', 'context'), contextText]),
             ...(isRejoin || activities === '' ? [] : ['', style('dim', 'recent activity'), activities]),
             ...fallback,
@@ -193,8 +197,8 @@ export const expressCommand = {
     async execute(intent, context) {
         const squarePath = requireSquarePath(context);
         const body = await resolveBody(intent.activity);
-        if (intent.reach === undefined && !intent.noMention && intent.mentions.length === 0 && scanMentionCandidates(body).length === 0) {
-            fail('✕ express needs --mention <name>, --no-mention, --bell, or an @name in the body\nsquare express --help');
+        if (intent.reach === undefined && !intent.noMention && intent.mentions.length === 0 && intent.reply === undefined && scanMentionCandidates(body).length === 0) {
+            fail("✕ express needs --mention <name>, --no-mention, --bell, or an @name in the body\n  · --reply <activity-id> also reaches the author it answers\nsquare express --help");
         }
         await cmdActivity(squarePath, intent.name, body, (value) => value, {
             force: intent.force,
@@ -304,7 +308,7 @@ export const doneCommand = {
         const name = result.activity.actor;
         const presentation = await openSquare(squarePath, { clock: nowMs, env: context.env, hostLedger: hostLedgerForEnv(context.env) });
         const participantCount = (await entryPresentation(presentation, name).finally(() => closeOpenSquare(presentation))).participantCount;
-        return withPathOutput(squarePath, `○ ${participantIdentity(name)} steps out of the square — done · ${result.activity.id} · just now`, { participantCount });
+        return withPathOutput(squarePath, `○ you stepped out — your footsteps fade · ${result.activity.id}`, { participantCount });
     },
     present: (result) => process.stdout.write(result),
 };

package/dist/codex-hook.js

@@ -11,17 +11,6 @@ const CODEX_HOOK_EVENTS = {
     Stop: 'Stop',
 };
 const defaultTrace = (line) => { process.stderr.write(`${line}\n`); };
-/** Per-stage timings, emitted as each stage completes so a killed hook still leaves a trace. */
-function stageTracer(trace) {
-    const startedAt = Date.now();
-    let mark = startedAt;
-    return (stage, extra = '') => {
-        const now = Date.now();
-        const durationMs = now - mark;
-        mark = now;
-        trace(`square-codex-hook: stage=${stage} durationMs=${durationMs} totalMs=${now - startedAt}${extra === '' ? '' : ` ${extra}`}`);
-    };
-}
 function hookBudgetMs(env) {
     const configured = Number(env.SQUARE_CODEX_HOOK_BUDGET_MS ?? CODEX_HOOK_BUDGET_MS);
     return Number.isFinite(configured) && configured > 0 ? configured : CODEX_HOOK_BUDGET_MS;
@@ -34,7 +23,15 @@ export async function codexHookResponse(input, lookup = sessionInbox, env = proc
     const hookEventName = CODEX_HOOK_EVENTS[input.hook_event_name];
     if (hookEventName === undefined)
         return undefined;
-    const stage = stageTracer(trace);
+    // Per-stage timings, emitted as each stage completes so a killed hook still leaves a trace.
+    const startedAt = Date.now();
+    let mark = startedAt;
+    const stage = (name, extra = '') => {
+        const now = Date.now();
+        const durationMs = now - mark;
+        mark = now;
+        trace(`square-codex-hook: stage=${name} durationMs=${durationMs} totalMs=${now - startedAt}${extra === '' ? '' : ` ${extra}`}`);
+    };
     const signal = AbortSignal.timeout(hookBudgetMs(env));
     const sweepDeadline = Date.now() + Math.min(PRIVILEGED_HOOK_BUDGET_MS, hookBudgetMs(env));
     const cwd = typeof input.cwd === 'string' ? input.cwd : process.cwd();

package/dist/codex-queue.d.ts

@@ -1,4 +1,4 @@
-import type { WakeAdapter, WakeDispatchResult } from './delivery.js';
+import type { WakeAdapter, WakeAdapterResult } from './delivery.js';
 import { type WakeRoute } from './model.js';
 export interface CodexQueueRequest {
     threadId: string;
@@ -23,6 +23,6 @@ export declare class CodexQueueAdapter implements WakeAdapter {
     private readonly opts;
     readonly kind: "codex-queue";
     constructor(opts?: CodexQueueAdapterOptions);
-    dispatch(address: Readonly<Record<string, string>>, payload: string, beforeSend: () => Promise<boolean>, timeoutMs?: number): Promise<WakeDispatchResult>;
+    dispatch(address: Readonly<Record<string, string>>, payload: string, beforeSend: () => Promise<boolean>, timeoutMs?: number): Promise<WakeAdapterResult>;
 }
 export type { WakeRoute };

package/dist/codex-queue.js

@@ -38,22 +38,24 @@ export class CodexQueueAdapter {
         const remainingMs = () => Math.max(0, deadline - Date.now());
         const threadId = address.threadId?.trim();
         if (!threadId) {
-            return { outcome: 'unavailable', signature: 'invalid_address', message: 'Codex route has no thread id.', routeStale: true };
+            return { outcome: 'failed', unavailable: true, signature: 'invalid_address', message: 'Codex route has no thread id.', routeStale: true };
         }
         const env = this.opts.env ?? process.env;
         if (!await codexQueueEligible(threadId, env)) {
             return {
-                outcome: 'unavailable',
+                outcome: 'failed',
+                unavailable: true,
                 signature: 'boundary_not_stopped',
                 message: 'The Codex thread has not reached a current Stop boundary.',
                 retainRoute: true,
             };
         }
         if (!(await beforeSend()))
-            return { outcome: 'cancelled' };
+            return { outcome: 'gate-rejected' };
         if (!await codexQueueEligible(threadId, env)) {
             return {
-                outcome: 'unavailable',
+                outcome: 'failed',
+                unavailable: true,
                 signature: 'boundary_not_stopped',
                 message: 'The Codex thread left its Stop boundary before queueing.',
                 retainRoute: true,
@@ -61,7 +63,7 @@ export class CodexQueueAdapter {
         }
         const remaining = remainingMs();
         if (remaining === 0) {
-            return { outcome: 'unavailable', signature: 'dispatch_budget_exhausted', message: 'The wake dispatch budget elapsed before queueing.', retainRoute: true };
+            return { outcome: 'failed', unavailable: true, signature: 'dispatch_budget_exhausted', message: 'The wake dispatch budget elapsed before queueing.', retainRoute: true };
         }
         try {
             (this.opts.sendQueue ?? sendCodexQueue)({ threadId, message: payload }, { env, timeoutMs: remaining });

package/dist/decisions.d.ts

@@ -1,5 +1,4 @@
 import { type ActivitiesOptions, type Act, type StoredAct, type SquareState, type Reach, type HardCap } from './model.js';
-import { directedPeerSays, peerRoomChanges } from './activity-feed.js';
 import { type Perception } from './square-core.js';
 import { type DeliveryModel } from './delivery.js';
 export interface UnreadActivitySummary {
@@ -36,14 +35,11 @@ export declare function decideImplicitJoin(squareState: SquareState, name: strin
 export type ActDecision = {
     type: 'sent';
     act: Act;
-    confirmation: string;
-    ownActCount: number;
-    pendingPublic: ReturnType<typeof directedPeerSays>;
-    pendingRoomChanges: ReturnType<typeof peerRoomChanges>;
+    /** The replied-to author was not standing, so the reply landed without reaching them. */
+    replyAuthorNotHere?: string;
 } | {
     type: 'blocked';
     activitySummaries: UnreadActivitySummary[];
-    unreadRoomChanges: ReturnType<typeof peerRoomChanges>;
 } | {
     type: 'capped';
     count: number;

package/dist/decisions.js

@@ -2,7 +2,7 @@ import { SquareError, sameName, validateName, } from './model.js';
 import { participantIdentity } from './participant-identity.js';
 import { UNREAD_BLOCK_GRACE_MS, actId, actStableIndex, foldedState, freshWatchLease, publicActs, resolveRosterName, rosterNames, THROTTLE_WINDOW_MS, } from './runtime.js';
 import { actDelta, directedPeerSays } from './activity-feed.js';
-import { formatActivityId, isIgnored, isListening, listeningTo, MAX_IDENTITY_SET_SIZE, validate } from './square-core.js';
+import { actorOf, formatActivityId, isIgnored, isListening, listeningTo, MAX_IDENTITY_SET_SIZE, validate } from './square-core.js';
 import { deriveDeliveryModel } from './delivery.js';
 import { compileSearchPattern } from './search.js';
 import { scanMentionCandidates, resolveNameAt } from './mention-parse.js';
@@ -10,13 +10,10 @@ export function resolveKnownName(squareState, name) {
     validateName(name);
     const known = resolveRosterName(squareState, name);
     if (known === undefined) {
-        throw new SquareError('invalid_args', `✕ ${participantIdentity(name)} has never stepped into this square`);
+        throw new SquareError('invalid_args', `✕ ${participantIdentity(name)} has never stepped into this square`, { reason: 'never_joined' });
     }
     return known;
 }
-function participantState(state, name) {
-    return state.participants.find((participant) => sameName(participant.name, name));
-}
 export function decideJoin(squareState, name, now) {
     validateName(name);
     const knownName = resolveRosterName(squareState, name);
@@ -38,7 +35,7 @@ export function decideImplicitJoin(squareState, name, now) {
     const knownName = resolveRosterName(squareState, name);
     const joinedName = knownName ?? name;
     if (knownName !== undefined) {
-        const current = participantState(foldedState(squareState), knownName);
+        const current = foldedState(squareState).participants.find((participant) => sameName(participant.name, knownName));
         return { joinedName, state: current?.joined === true ? 'active' : 'done' };
     }
     return {
@@ -116,7 +113,7 @@ export function decideAct(squareState, input) {
         validateName(requested);
         const resolved = joinedNames.find((candidate) => sameName(candidate, requested));
         if (resolved === undefined) {
-            throw new SquareError('invalid_args', `✕ ${participantIdentity(requested)} is not standing in this square`);
+            throw new SquareError('invalid_args', `✕ ${participantIdentity(requested)} is not standing in this square`, { reason: 'not_standing' });
         }
         if (!mentionNames.some((existing) => sameName(existing, resolved))) {
             if (mentionNames.length >= MAX_IDENTITY_SET_SIZE) {
@@ -156,11 +153,11 @@ export function decideAct(squareState, input) {
                 lines.push(`✕ ${notStanding.map((candidate) => participantIdentity(candidate.token)).join(', ')} ${notStanding.length === 1 ? 'is' : 'are'} not standing in this square`);
             }
             lines.push('  · wrap literal @text in backticks, or pass --no-mention to land bare');
-            throw new SquareError('invalid_args', lines.join('\n'));
+            throw new SquareError('invalid_args', lines.join('\n'), { reason: 'unmatched_mention' });
         }
     }
     if (reach === 'bell' && mentionNames.length > 0) {
-        throw new SquareError('invalid_args', 'A bell cannot be combined with a mention — remove --mention or the @name in the body.');
+        throw new SquareError('invalid_args', '✕ a bell cannot be combined with a mention — remove --mention or the @name in the body.', { reason: 'bell_mention_conflict' });
     }
     const reply = input.reply;
     if (reply !== undefined) {
@@ -169,7 +166,14 @@ export function decideAct(squareState, input) {
             throw new SquareError('invalid_args', `Unknown reply activity: ${label}`);
         }
     }
-    const current = participantState(state, name);
+    // A non-standing author never rejects the activity: the reply still lands and the
+    // speaker is told the notification did not reach them.
+    const repliedTo = reply === undefined ? undefined : squareState.acts.find((act) => act.index === reply);
+    const repliedToAuthor = repliedTo === undefined ? undefined : actorOf(repliedTo);
+    const replyAuthorNotHere = repliedToAuthor === undefined || sameName(repliedToAuthor, name)
+        || state.participants.some((participant) => participant.joined && sameName(participant.name, repliedToAuthor))
+        ? undefined
+        : repliedToAuthor;
     const result = validate(state, {
         kind: 'say', actor: name, at: now, body, mentions: mentionNames,
         ...(reach !== undefined ? { reach } : {}),
@@ -194,15 +198,13 @@ export function decideAct(squareState, input) {
     const delivery = deriveDeliveryModel(squareState);
     const delta = actDelta(squareState.acts, delivery.cursorFor(name));
     const unreadPublic = directedPeerSays(squareState, delta, name, delivery);
-    const unreadRoomChanges = [];
     const activitySummaries = unreadActivitySummaries(squareState, name, now);
     const latestActivityAgeMs = activitySummaries[0]?.latestActivityAgeMs;
     const hasUnread = unreadPublic.length > 0;
     const hasFreshUnreadActivity = latestActivityAgeMs !== undefined && latestActivityAgeMs <= UNREAD_BLOCK_GRACE_MS;
     if (!force && hasUnread && !hasFreshUnreadActivity) {
-        return { type: 'blocked', activitySummaries, unreadRoomChanges };
+        return { type: 'blocked', activitySummaries };
     }
-    const ownActCount = (current?.activityCount ?? 0) + 1;
     return {
         type: 'sent',
         act: {
@@ -210,10 +212,7 @@ export function decideAct(squareState, input) {
             ...(reach !== undefined ? { reach } : {}),
             ...(reply !== undefined ? { reply } : {}),
         },
-        confirmation: `● your activity lands — #${ownActCount}`,
-        ownActCount,
-        pendingPublic: unreadPublic,
-        pendingRoomChanges: unreadRoomChanges,
+        ...(replyAuthorNotHere === undefined ? {} : { replyAuthorNotHere }),
     };
 }
 export function validateDoneBody(body) {

package/dist/delivery-health.d.ts

@@ -1,6 +1,5 @@
 import { type DirectedNotificationRoute } from './delivery.js';
-import { type WakeAttempt } from './square-projections.js';
-import { type WakeReleaseDiagnostic } from './wake-attempts.js';
+import type { WakeAttempt, WakeReleaseDiagnostic } from './wake-evidence.js';
 export type DeliveryHealthKind = 'awaiting' | 'wake-accepted' | 'wake-unknown' | 'presented-not-delivered' | 'unreachable';
 export interface DeliveryHealthItem {
     squarePath: string;

package/dist/delivery-health.js

@@ -71,10 +71,6 @@ function displayField(value) {
     const truncated = truncateChars(value, DISPLAY_FIELD_LIMIT - 1);
     return truncated.remaining === 0 ? truncated.text : `${truncated.text}…`;
 }
-function formatItem(item) {
-    const evidence = item.attempt?.signature === undefined ? '' : ` · ${displayField(item.attempt.signature)}`;
-    return `  · ${formatActivityId(item.actIndex)} → ${displayField(participantIdentity(item.recipient))} from ${displayField(participantIdentity(item.actor))} · ${formatDuration(item.ageMs)}${evidence}`;
-}
 export function renderDeliveryHealth(items, releases = [], now = Date.now()) {
     const out = items.length === 0 ? ['✓ no pending delivery attention'] : [`· delivery attention · ${items.length} pending`];
     if (items.length > 0) {
@@ -85,7 +81,10 @@ export function renderDeliveryHealth(items, releases = [], now = Date.now()) {
                 continue;
             out.push(`${ACTIONABLE.has(kind) ? '✕' : '○'} ${kind}: ${group.length}`);
             const details = group.slice(0, DETAIL_LIMIT - displayed);
-            out.push(...details.map(formatItem));
+            out.push(...details.map((item) => {
+                const evidence = item.attempt?.signature === undefined ? '' : ` · ${displayField(item.attempt.signature)}`;
+                return `  · ${formatActivityId(item.actIndex)} → ${displayField(participantIdentity(item.recipient))} from ${displayField(participantIdentity(item.actor))} · ${formatDuration(item.ageMs)}${evidence}`;
+            }));
             displayed += details.length;
         }
         if (items.length > DETAIL_LIMIT)

package/dist/delivery-operations.d.ts

@@ -1,10 +1,7 @@
-import { type SquareState } from './model.js';
-import type { HostLedgerPort, PresenceRecord, PresentationEvidenceProjection, SquareArtifactPort, DeliverPendingInput, DeliveryResult, ObserveSquareInput, SquareObservation } from './ports.js';
+import type { SquareState } from './model.js';
+import type { HostLedgerPort, SquareArtifactPort, DeliverPendingInput, DeliveryResult } from './ports.js';
 import { deriveDeliveryModel } from './delivery.js';
-import { type WakeAttempt } from './square-projections.js';
-export declare function observeSquare(input: ObserveSquareInput): Promise<SquareObservation>;
 export declare function deliverPending(input: DeliverPendingInput): Promise<DeliveryResult>;
-export declare function selectPendingWakeActivities(state: SquareState, routes: readonly PresenceRecord[], attempts: readonly WakeAttempt[], now: number, graceMs: number, limit: number, delivery?: import("./delivery.js").DeliveryModel, presentations?: readonly PresentationEvidenceProjection[]): number[];
 export declare function sweepPending(input: {
     readonly artifact: SquareArtifactPort;
     readonly hostLedger: HostLedgerPort;