@astrosheep/square 0.4.7 → 0.4.8

package/dist/harness-claude.js

@@ -71,8 +71,8 @@ export async function doctorClaudePlugin(homeDir, run = runClaude) {
     return [
         fs.existsSync(bundle) ? `✓ Square Claude plugin bundle ${root}` : `○ Square Claude plugin bundle missing ${root}`,
         installed ? `✓ ${CLAUDE_PLUGIN_ID} installed` : `○ ${CLAUDE_PLUGIN_ID} unavailable`,
-        `Claude delivery uses synchronous prompt/tool hooks and one finite 24-hour asyncRewake Stop observer; actual coverage ends at native boundaries.`,
-        `Idle Escape cannot disarm a watcher, and already emitted notifications cannot be recalled; busy Escape disarms at the next prompt boundary.`,
-        `Native stderr output is recorded unknown until its exact token/hash frame appears at a later prompt boundary; model comprehension is not observed.`,
+        `Claude delivery uses a mod: busy turns append context and log it; idle main sessions submit an attributed plugin prompt.`,
+        `Stop suppresses the current delivery batch; clear, resume and module reload retire the captured helper and attachment.`,
+        `Exact native acceptance records presentation, not model comprehension. Paseo does not yet expose Claude ui_log events.`,
     ];
 }

package/dist/help.js

@@ -40,11 +40,10 @@ const COMMANDS = [
     { names: ['listen'], usage: '--as <name> listen <participant>', usesSquare: true, group: 'participant', summary: 'Turn an ear toward one participant\'s future activity.' },
     { names: ['unlisten'], usage: '--as <name> unlisten <participant>', usesSquare: true, group: 'participant', summary: 'Stop listening without blocking that participant\'s mentions or replies.' },
     { names: ['ignore'], usage: '--as <name> ignore <participant>', usesSquare: true, group: 'participant', summary: 'Stop hearing one participant\'s future activity, except bells.' },
-    { names: ['listening'], usage: '--as <name> listening', usesSquare: true, group: 'participant', summary: 'Show who you are turned toward.', details: ['Listening applies to future activity. What you could hear when an activity landed does not change afterward.'] },
     {
-        names: ['perceive'], usage: '--as <name> perceive [--id <activity-id>] [--now | --idle <duration>] [--from <names>] [--mention] [--limit <count>] [--takeover]', usesSquare: true, group: 'participant',
+        names: ['perceive'], usage: '--as <name> perceive [--id <activity-id>] [--idle <duration>] [--from <names>] [--mention] [--limit <count>] [--takeover]', usesSquare: true, group: 'participant',
         summary: 'Perceive directed conversation since you last looked.',
-        details: ['Modes:', '  --id <activity-id> Perceive exactly one activity addressed to you, with its full body; implies --now.', '                    Marks only this activity seen; repeats return it again. No filters, limit, idle or takeover.', '                    history stays read-only; perceive --id consumes the selected activity.', '  --now             Take in activity immediately; bare perceive already does this.', '  --idle <duration> Wait for something relevant, or for quiet to last this long.', '', 'Attention:', '  Mentions arrive when you are addressed; bells arrive for everyone; bare says require listen.', '  listen and ignore are future-only and fixed when each say lands.', '', 'Filters:', '  --from <names>    Match only comma-separated participants.', '  --mention         Match direct attention for your current participant (and bells).', '  --limit <count>   Return one page (default 10, maximum 100).', '', 'Recovery:', '  --takeover        Take over from another active perceive for this participant.'],
+        details: ['Modes:', '  --id <activity-id> Open one activity addressed to you in full; repeats work. Use it alone.', '  --idle <duration> Wait for something relevant, or for quiet to last this long.', '', 'Attention:', '  Mentions arrive when you are addressed; bells arrive for everyone; bare says require listen.', '  listen and ignore are future-only and fixed when each say lands.', '', 'Filters:', '  --from <names>    Match only comma-separated participants.', '  --mention         Match direct attention for your current participant (and bells).', '  --limit <count>   Return one page (default 10, maximum 100).', '', 'Recovery:', '  --takeover        Take over from another active perceive for this participant.'],
     },
     { names: ['done'], usage: '--as <name> done', usesSquare: true, group: 'participant', summary: 'Step out of the square.', details: ['done takes no message. Use express before leaving to send one.'] },
     {
@@ -60,12 +59,11 @@ const COMMANDS = [
     { names: ['codex-hook'], usage: '{command}', summary: 'Present pending attention at one native agent boundary.', hiddenFromIndex: true },
     { names: ['codex-watch'], usage: '{command}', summary: 'Observe pending attention from a native async Stop hook.', hiddenFromIndex: true },
     { names: ['codex-interrupt'], usage: '{command}', summary: 'Cancel pending attention at a native Interrupt boundary.', hiddenFromIndex: true },
-    { names: ['claude-hook'], usage: '{command}', summary: 'Receive a native Claude hook event.', hiddenFromIndex: true },
-    { names: ['claude-watch'], usage: '{command}', summary: 'Observe pending attention from a native async Stop hook.', hiddenFromIndex: true },
+    { names: ['claude-mod'], usage: '{command}', summary: 'Run the Claude mod delivery helper.', hiddenFromIndex: true },
     {
         names: ['history'], usage: 'history [filters] [output]', usesSquare: true, group: 'participant',
         summary: 'Read or search the archive without changing what you have perceived.',
-        details: ['Optional --as is accepted but does not change the archive or claim a name.', '', 'Filters:', '  --from <names>                  Match activities from participants.', '  --since <time>                  Match activities after a time.', '  --grep <regex> | --fixed <s>    Search activity ids, participants, and original bodies.', '  --mention <name>                Match direct attention for a participant.', '  --at <ids>                      Center on comma-separated activity ids; may repeat.', '  -B, -A, -C <N>                 Set non-negative context around every --at coordinate.', '  --before <id>                   Read the page immediately before an activity.', '  --after <id>                    Read the page immediately after an activity.', '', 'Results:', '  --limit <N>                     Page size (default 10, maximum 100).', '  --order <asc|desc>              Set display order (default oldest first).', '', 'Output:', '  --no-truncate  --json  --format <fields>', '  One result shows its full body; multiple results use previews.', '  --no-truncate shows every original body.'],
+        details: ['Filters:', '  --from <names>                  Match activities from participants.', '  --since <time>                  Match activities after a time.', '  --search <text> [--regex]      Search ids, participants, and original bodies; literal by default.', '  --mention <name>                Match direct attention for a participant.', '  --at <ids>                      Center on comma-separated activity ids; may repeat.', '  -C <N>                         Set symmetric context around every --at coordinate.', '  --before <id>                   Read the page immediately before an activity.', '  --after <id>                    Read the page immediately after an activity.', '', 'Results:', '  --limit <N>                     Page size (default 10, maximum 100).', '  --order <asc|desc>              Set display order (default oldest first).', '', 'Output:', '  --full  --json  --format <fields>', '  One result shows its full body; multiple results use previews.', '  --full shows every original body.'],
     },
     { names: ['status'], usage: '[--as <name>] status', usesSquare: true, group: 'participant', summary: 'Show who is present and what happened most recently.' },
     {
@@ -96,7 +94,7 @@ function isHelpFlag(value) {
 }
 export function renderGlobalHelp() {
     const groups = [
-        { key: 'participant', title: 'In the square:', order: ['join', 'express', 'listen', 'unlisten', 'ignore', 'listening', 'perceive', 'history', 'status', 'done'] },
+        { key: 'participant', title: 'In the square:', order: ['join', 'express', 'listen', 'unlisten', 'ignore', 'perceive', 'history', 'status', 'done'] },
         { key: 'host', title: 'Prepare and manage:', order: ['build', 'list'] },
         { key: 'maintenance', title: 'Setup:', order: ['install', 'uninstall', 'doctor'] },
     ];
@@ -112,7 +110,7 @@ export function renderGlobalHelp() {
         'Usage: square [--location <square>] [--as <name>] [--owner <id>] <command> [args...]',
         'Location: square-accessing commands require --location <square>. Use square list to find nearby squares and your joined names; use --as to select a participant.',
         'Identity: --owner overrides SQUARE_OWNER, then a complete harness identity, then user:<OS user>@<host>. Incomplete or ambiguous harness identities refuse. Owners without wake use perceive --idle.',
-        'Output: --json on join, express, perceive, history, listen, ignore, unlisten, listening, done, status and inbox prints the SDK result without observation; a participant handle becomes {name}.',
+        'Output: --json on join, express, perceive, history, listen, ignore, unlisten, done, status and inbox prints the SDK result without observation; a participant handle becomes {name}.',
         'History emits one JSON document; stream --ndjson emits one SDK record per line.',
         '',
         ...commandLines,

package/dist/mcp.js

@@ -20,7 +20,7 @@ export function createSquareMcpServer(options) {
                 return invoke(tool, args, { signal: extra.signal }, async () => {
                     const threadId = extra._meta?.threadId;
                     const opencodeSessionId = extra._meta?.['ai.opencode/sessionID'];
-                    // Claude's bundled plugin requires a per-call native hook association; startup identity is not a fallback.
+                    // Claude's bundled mod requires a per-call native association; startup identity is not a fallback.
                     const claude = baseEnv.SQUARE_CLAUDE_MCP_CONTEXT === '1'
                         ? await readClaudeMcpCall(extra._meta?.['claudecode/toolUseId'], baseEnv)
                         : undefined;

package/dist/neutral.d.ts

@@ -2,6 +2,16 @@
 export type Owner = string;
 export type SquareErrorCode = 'invalid_name' | 'invalid_args' | 'unknown_participant' | 'not_joined' | 'already_joined' | 'already_done' | 'capped' | 'throttled' | 'bell_quota' | 'behind' | 'io' | 'unavailable';
 export type InternalSquareErrorCode = SquareErrorCode | 'not_found' | 'cap_reached' | 'conflict' | 'pending_peer';
+/** One speaker's unperceived activity, previewed by its latest body. */
+export interface UnreadActivitySummary {
+    readonly name: string;
+    readonly count: number;
+    readonly latestActivityAgeMs: number;
+    readonly preview: {
+        readonly body?: string;
+        readonly structured: boolean;
+    };
+}
 export interface SquareErrorFacts {
     /** Express admission rejected before any activity was committed. */
     activityUnsent?: true;
@@ -13,8 +23,12 @@ export interface SquareErrorFacts {
     targets?: readonly string[];
     /** Whether the artifact holds that activity at all; an unknown id needs an ordinary page. */
     activityExists?: boolean;
-    pending?: number;
+    /** Who spoke while an express was away; the refusal rests on exactly these. */
+    activitySummaries?: readonly UnreadActivitySummary[];
     retryAfterMs?: number;
+    /** A capped speaker's spoken count against the square's cap. */
+    spoken?: number;
+    hardCap?: number;
 }
 export interface PerceiveWaitStart {
     readonly idleMs: number;

package/dist/notifications.js

@@ -1,7 +1,7 @@
 import { createDefaultDeliveryTransports } from './wake-transports.js';
 export { createDefaultDeliveryTransports } from './wake-transports.js';
 const DEFAULT_DELIVERY_WAIT_MS = 5000;
-const NATIVE_RECEIVER_ROUTES = new Set(['codex-queue', 'claude-async-hook', 'claude-native', 'pi-native']);
+const NATIVE_RECEIVER_ROUTES = new Set(['codex-queue', 'claude-mod', 'pi-native']);
 /** Best-effort dispatch for currently eligible cards, including cards restored by release. */
 export async function dispatchEligibleCards(ledger, owner, options = {}) {
     const signal = options.signal ?? AbortSignal.timeout(DEFAULT_DELIVERY_WAIT_MS);

package/dist/operation-presentation.d.ts

@@ -1,4 +1,4 @@
-import type { PerceiveOptions, PerceiveResult, ExpressResult, HistoryQuery, HistoryResult, JoinResult, LifecycleResult, ListenerChangeResult, ListeningResult, OperationFailureDetail, StatusResult, DiscoveryResult } from './square-facade.js';
+import type { PerceiveOptions, PerceiveResult, ExpressResult, HistoryQuery, HistoryResult, JoinResult, LifecycleResult, ListenerChangeResult, OperationFailureDetail, SquareErrorFacts, StatusResult, DiscoveryResult } from './square-facade.js';
 import { type PresentationSurface } from './presentation.js';
 export declare function renderSquareList(data: DiscoveryResult, projection: {
     now: number;
@@ -22,14 +22,13 @@ export declare function renderPerceiveOutcome(squarePath: string, data: Perceive
 export declare function historyContinuationCommand(squarePath: string, args: readonly string[]): string;
 export declare function renderHistoryResult(squarePath: string, data: HistoryResult, options?: {
     query?: HistoryQuery;
-    noTruncate?: boolean;
+    full?: boolean;
     continuationArgs?: readonly string[];
     surface?: PresentationSurface;
 }): string | undefined;
 export declare function renderStatusResult(squarePath: string, data: StatusResult, options?: {
     surface?: PresentationSurface;
 }): string | undefined;
-export declare function renderListeningResult(squarePath: string, data: ListeningResult): string | undefined;
 export type ListenerVerb = 'listen' | 'ignore' | 'unlisten';
 export declare function renderListenerChange(squarePath: string, verb: ListenerVerb, data: ListenerChangeResult): string | undefined;
 export declare function renderLifecycleResult(squarePath: string, data: LifecycleResult): string | undefined;
@@ -37,18 +36,21 @@ export declare function renderLifecycleResult(squarePath: string, data: Lifecycl
 export interface FailureReport {
     readonly code: string;
     readonly message: string;
-    readonly facts?: {
-        readonly reason?: 'never_joined' | 'not_standing' | 'bell_mention_conflict' | 'not_addressed' | 'invalid_reply' | 'invalid_done_body' | 'needs_seat';
-        readonly activityId?: string;
-        readonly activityExists?: boolean;
-    };
+    readonly facts?: SquareErrorFacts;
     readonly operation?: OperationFailureDetail;
 }
+interface FailureOptions {
+    readonly squarePath?: string;
+    readonly name?: string;
+    readonly owner?: string;
+    readonly surface?: PresentationSurface;
+    readonly reply?: string;
+    /** CLI only: the saved draft and the full command that resends it. */
+    readonly draftPath?: string;
+    readonly retry?: string;
+}
+/** Express gates are physics, not mistakes: one scene for every surface, then that surface's next action. */
+export declare function isExpressGate(code: string): boolean;
 /** Refusal lines with surface-specific recovery actions. */
-export declare function renderFailureLines(failure: FailureReport, options?: {
-    squarePath?: string;
-    name?: string;
-    owner?: string;
-    surface?: PresentationSurface;
-    reply?: string;
-}): string[];
+export declare function renderFailureLines(failure: FailureReport, options?: FailureOptions): string[];
+export {};

package/dist/operation-presentation.js

@@ -1,8 +1,8 @@
 // Human-facing scenes for settled operations, with surface-specific next actions.
 import { sameName } from './model.js';
 import { formatActivityId } from './square-core.js';
-import { displayPath, formatToolAction, commandPrefix, joinRecoveryCommand, participantCommandPrefix, participantIdentity, quoteShell, renderAmbientEvent, renderAmbientEventFacts, renderEventCli, renderGrepActivitiesView, renderPresenceAnchor, renderWatchAlreadyActive, renderWatchReplaced, renderWatchStatus, takeoverRecoveryLines, withPathOutput, truncateChars, } from './presentation.js';
-import { formatRelativeTime, formatTimestamp } from './time.js';
+import { displayPath, formatToolAction, commandPrefix, joinRecoveryCommand, participantCommandPrefix, participantIdentity, quoteShell, renderAmbientEvent, renderAmbientEventFacts, renderEventCli, renderGrepActivitiesView, renderPresenceAnchor, renderWatchAlreadyActive, renderWatchReplaced, renderWatchStatus, renderUnreadSummary, takeoverRecoveryLines, withPathOutput, truncateChars, } from './presentation.js';
+import { formatDuration, formatRelativeTime, formatTimestamp } from './time.js';
 import { style } from './tty-style.js';
 function listDisplay(value) {
     const truncated = truncateChars(value, 159);
@@ -53,7 +53,7 @@ export function renderJoinResult(data, owner, surface = 'cli') {
         now: after.now, preview: 200, perception: event.perception,
     })).filter(Boolean).join('\n\n');
     const fallback = after.deliveryAvailable ? ['', '· when someone calls you, you’ll hear them here'] : [
-        '', surface === 'tool' ? formatToolAction('perceive', { location: displayPath(after.location), as: name, idle: 1800000 }) : `${participantCommandPrefix(after.location, name, owner)} perceive --idle 30m`,
+        '', surface === 'tool' ? formatToolAction('perceive', { location: displayPath(after.location), as: name, idle: '30m' }) : `${participantCommandPrefix(after.location, name, owner)} perceive --idle 30m`,
         '  · stay within earshot — keep this perceive open for new activity',
     ];
     const entryLine = data.kind === 'joined' ? '● you stepped into the square'
@@ -101,14 +101,14 @@ export function renderExpression(squarePath, data, owner, surface = 'cli') {
     return withPathOutput(projection.location ?? squarePath, confirmation + (data.hint ? `\n${style('dim', `· ${data.hint}`)}` : '') + replyNotice + unmatchedNotice + pending, { participantCount: projection.standingCount });
 }
 function continuationCommand(squarePath, name, options, owner) {
-    const args = ['--now'];
+    const args = [];
     if (options.from?.length)
         args.push('--from', options.from.join(','));
     if (options.mention)
         args.push('--mention');
     if (options.limit !== undefined)
         args.push('--limit', String(options.limit));
-    return `${participantCommandPrefix(squarePath, name, owner)} perceive ${args.join(' ')}`;
+    return [participantCommandPrefix(squarePath, name, owner), 'perceive', ...args].join(' ');
 }
 /** Render settled perceive facts; no selection, terminal decisions, receipts or wait machinery. */
 export function renderPerceiveOutcome(squarePath, data, options = {}, owner, surface = 'cli') {
@@ -141,16 +141,16 @@ export function renderPerceiveOutcome(squarePath, data, options = {}, owner, sur
         ...(stop === 'idle' && options.idle !== undefined ? { idleMs: options.idle } : {}),
     });
     const fallback = stop === undefined && !projection.deliveryAvailable && data.remaining === 0
-        ? `${surface === 'tool' ? formatToolAction('perceive', { location: displayPath(location), as: name, idle: 1800000 }) : `${participantCommandPrefix(location, name, owner)} perceive --idle 30m`}\n  stay available for new activity` : '';
+        ? `${surface === 'tool' ? formatToolAction('perceive', { location: displayPath(location), as: name, idle: '30m' }) : `${participantCommandPrefix(location, name, owner)} perceive --idle 30m`}\n  stay available for new activity` : '';
     const hint = data.hint === undefined ? '' : style('dim', `· ${data.hint}`);
     return {
         stdout: withPathOutput(location, [terminal, rendered, hint, remaining, fallback].filter(Boolean).join('\n\n'), header),
         exitCode: stop === 'capped' ? 1 : 0,
     };
 }
-function renderHistoryProjection(projection, visible, noTruncate, squarePath, surface) {
+function renderHistoryProjection(projection, visible, full, squarePath, surface) {
     const shown = visible;
-    const preview = noTruncate || shown.length <= 1 ? undefined : 200;
+    const preview = full || shown.length <= 1 ? undefined : 200;
     const chunks = [];
     // Presence anchors collect into one closing line instead of interrupting the page.
     const anchored = [];
@@ -167,7 +167,7 @@ function renderHistoryProjection(projection, visible, noTruncate, squarePath, su
         return '○ no activity matches this history query';
     if (preview !== undefined && shown.some((activity) => activity.kind === 'say' && (activity.body?.length ?? 0) > preview)) {
         const ids = shown.map((activity) => formatActivityId(activity.index));
-        chunks.push(surface === 'tool' ? formatToolAction('history', { location: displayPath(squarePath), at: ids, noTruncate: true }) : `${commandPrefix(squarePath)} history --at ${ids.join(',')} --no-truncate`);
+        chunks.push(surface === 'tool' ? formatToolAction('history', { location: displayPath(squarePath), at: ids, full: true }) : `${commandPrefix(squarePath)} history --at ${ids.join(',')} --full`);
     }
     if (anchored.length > 0)
         chunks.push(renderPresenceAnchor(anchored));
@@ -185,14 +185,15 @@ function historyQueryArgs(query) {
         args.push('--since', formatTimestamp(query.since));
     if (query.at?.length)
         args.push('--at', query.at.join(','));
-    if (query.contextBefore !== undefined)
-        args.push('-B', String(query.contextBefore));
-    if (query.contextAfter !== undefined)
-        args.push('-A', String(query.contextAfter));
+    if (query.context !== undefined)
+        args.push('-C', String(query.context));
     if (query.mention !== undefined)
         args.push('--mention', query.mention);
-    if (query.search !== undefined)
-        args.push(query.search.mode === 'regex' ? '--grep' : '--fixed', query.search.text);
+    if (query.search !== undefined) {
+        args.push('--search', query.search.text);
+        if (query.search.mode === 'regex')
+            args.push('--regex');
+    }
     if (query.order !== undefined)
         args.push('--order', query.order);
     return args;
@@ -202,14 +203,14 @@ export function renderHistoryResult(squarePath, data, options = {}) {
     if (projection === undefined)
         return undefined;
     const query = options.query ?? {};
-    const noTruncate = options.noTruncate === true;
+    const full = options.full === true;
     const search = query.search;
     const output = search === undefined
-        ? renderHistoryProjection(projection, projection.visibleActivities, noTruncate, squarePath, options.surface ?? 'cli')
-        : renderGrepActivitiesView(projection.visibleActivities, projection.totalMatches, noTruncate, squarePath, search.text, search.mode === 'literal', () => 'full', options.surface);
+        ? renderHistoryProjection(projection, projection.visibleActivities, full, squarePath, options.surface ?? 'cli')
+        : renderGrepActivitiesView(projection.visibleActivities, projection.totalMatches, full, squarePath, search.text, search.mode === 'literal', () => 'full', options.surface);
     const next = projection.continuation;
-    const base = options.continuationArgs ?? historyQueryArgs(query);
-    const continuation = next === undefined ? '' : `\n\n${options.surface === 'tool' ? formatToolAction('history', { location: displayPath(squarePath), ...(query.from?.length ? { from: query.from } : {}), ...(query.since !== undefined ? { since: formatTimestamp(query.since) } : {}), ...(query.at?.length ? { at: query.at } : {}), ...(query.contextBefore !== undefined && query.contextBefore === query.contextAfter ? { context: query.contextBefore } : { ...(query.contextBefore !== undefined ? { contextBefore: query.contextBefore } : {}), ...(query.contextAfter !== undefined ? { contextAfter: query.contextAfter } : {}) }), ...(query.mention !== undefined ? { mention: query.mention } : {}), ...(query.search !== undefined ? (query.search.mode === 'regex' ? { grep: query.search.text } : { fixed: query.search.text }) : {}), ...(query.order !== undefined ? { order: query.order } : {}), ...(noTruncate ? { noTruncate: true } : {}), [next.direction]: next.cursor, limit: next.limit }) : historyContinuationCommand(squarePath, [...base, `--${next.direction}`, next.cursor, '--limit', String(next.limit)])}`;
+    const base = options.continuationArgs ?? [...historyQueryArgs(query), ...(full ? ['--full'] : [])];
+    const continuation = next === undefined ? '' : `\n\n${options.surface === 'tool' ? formatToolAction('history', { location: displayPath(squarePath), ...(query.from?.length ? { from: query.from } : {}), ...(query.since !== undefined ? { since: formatTimestamp(query.since) } : {}), ...(query.at?.length ? { at: query.at } : {}), ...(query.context !== undefined ? { context: query.context } : {}), ...(query.mention !== undefined ? { mention: query.mention } : {}), ...(query.search !== undefined ? { search: query.search.text, ...(query.search.mode === 'regex' ? { regex: true } : {}) } : {}), ...(query.order !== undefined ? { order: query.order } : {}), ...(full ? { full: true } : {}), [next.direction]: next.cursor, limit: next.limit }) : historyContinuationCommand(squarePath, [...base, `--${next.direction}`, next.cursor, '--limit', String(next.limit)])}`;
     return withPathOutput(squarePath, output + continuation, { participantCount: projection.standingCount });
 }
 export function renderStatusResult(squarePath, data, options = {}) {
@@ -276,7 +277,7 @@ export function renderStatusResult(squarePath, data, options = {}) {
     if (presentation.joinCount > 3)
         latest.push(style('dim', `  → … ${presentation.joinCount - 3} more stepped in`));
     if (visible.bodyClipped && data.latestActivity !== undefined) {
-        latest.push(options.surface === 'tool' ? formatToolAction('history', { location: displayPath(squarePath), at: [data.latestActivity.id], context: 2, noTruncate: true }) : `${commandPrefix(squarePath)} history --at ${data.latestActivity.id} -C 2 --no-truncate`);
+        latest.push(options.surface === 'tool' ? formatToolAction('history', { location: displayPath(squarePath), at: [data.latestActivity.id], context: 2, full: true }) : `${commandPrefix(squarePath)} history --at ${data.latestActivity.id} -C 2 --full`);
     }
     const counts = [
         `${orderedHere.length} here`,
@@ -296,15 +297,6 @@ export function renderStatusResult(squarePath, data, options = {}) {
     ].join('\n');
     return withPathOutput(squarePath, output, { participantCount: presentation.standingCount });
 }
-export function renderListeningResult(squarePath, data) {
-    const projection = data.observation;
-    if (projection?.participant === undefined)
-        return undefined;
-    const body = data.listening.length === 0
-        ? `○ ${participantIdentity(projection.participant)} is not turned toward anyone`
-        : ['listening', ...data.listening.map((target) => `  · ${participantIdentity(target)}`)].join('\n');
-    return withPathOutput(squarePath, body, { participantCount: projection.standingCount });
-}
 export function renderListenerChange(squarePath, verb, data) {
     const projection = data.observation;
     if (projection?.participant === undefined)
@@ -330,15 +322,49 @@ export function renderLifecycleResult(squarePath, data) {
         participantCount: projection.standingCount,
     });
 }
+/** Express gates are physics, not mistakes: one scene for every surface, then that surface's next action. */
+export function isExpressGate(code) {
+    return code === 'behind' || code === 'capped' || code === 'throttled' || code === 'bell_quota';
+}
+function expressGateLines(failure, options) {
+    if (!isExpressGate(failure.code))
+        return undefined;
+    const { squarePath, name, owner } = options;
+    const facts = failure.facts;
+    const tool = options.surface === 'tool';
+    const scene = failure.code === 'behind'
+        ? ['✕ your words stay unsent — someone spoke while you were away', ...renderUnreadSummary(facts?.activitySummaries ?? [])]
+        : failure.code === 'capped'
+            ? [`✕ you’ve reached your speaking cap${facts?.spoken !== undefined && facts.hardCap !== undefined ? ` — ${facts.spoken}/${facts.hardCap} spoken` : ''}`]
+            : failure.code === 'throttled'
+                ? ['✕ the square is packed — shoulder to shoulder', `  · a lull opens in ${formatDuration(facts?.retryAfterMs ?? 1)}`]
+                : ['✕ the bell stays quiet for now', `  · you can ring it again in ${formatDuration(facts?.retryAfterMs ?? 1)}`];
+    const lines = [...scene, ...(options.draftPath === undefined ? [] : [style('dim', `· draft kept: ${options.draftPath}`)])];
+    if (squarePath === undefined || name === undefined)
+        return lines;
+    const action = (verb) => tool
+        ? formatToolAction(verb, { location: displayPath(squarePath), as: name })
+        : `${participantCommandPrefix(squarePath, name, owner)} ${verb}`;
+    if (failure.code === 'behind')
+        lines.push(...(tool ? ['Take it in, then express again:', action('perceive')] : [action('perceive'), '  · take it in, then retry:']));
+    if (failure.code === 'capped')
+        lines.push('  · your words stay unsent; done only steps out', action('done'));
+    if (failure.code === 'bell_quota' && !tool)
+        lines.push('  · retry when the bell is ready:');
+    if (failure.code !== 'capped' && options.retry !== undefined)
+        lines.push(options.retry);
+    return lines;
+}
 /** Refusal lines with surface-specific recovery actions. */
 export function renderFailureLines(failure, options = {}) {
     const { squarePath, name, owner } = options;
     const facts = failure.facts;
     const reason = facts?.reason;
+    const gate = expressGateLines(failure, options);
+    if (gate !== undefined)
+        return gate;
     const marked = reason === 'never_joined' || reason === 'not_standing';
     const lines = marked ? failure.message.split('\n').map((line) => `✕ ${line}`) : [failure.message];
-    if (failure.code === 'behind' && options.surface === 'tool')
-        lines[0] = `✕ your words stay unsent — ${failure.message}`;
     if (reason === 'bell_mention_conflict' || reason === 'invalid_reply') {
         lines[0] = reason === 'bell_mention_conflict' ? '✕ a bell cannot be combined with a mention'
             : `Invalid ${options.surface === 'tool' ? 'reply' : '--reply'}: ${facts?.activityExists === false ? `${facts.activityId ?? options.reply ?? 'that activity'} is not in this square's history` : 'expected an activity id like act/12'}`;

package/dist/packages/agent-delivery/src/index.d.ts

@@ -1,6 +1,6 @@
 import { DeliveryError } from './errors.js';
-import type { OpenCodeConnectOptions, ClaudeConnectOptions, PiConnectOptions, PaseoConnectOptions, CodexConnectOptions, CodexAppServerConnectOptions, CodexCliConnectOptions } from './types.js';
-export type { OpenCodeConnectOptions, ClaudeConnectOptions, PiConnectOptions, PaseoConnectOptions, CodexConnectOptions, CodexAppServerConnectOptions, CodexCliConnectOptions } from './types.js';
+import type { OpenCodeConnectOptions, PiConnectOptions, PaseoConnectOptions, CodexConnectOptions, CodexAppServerConnectOptions, CodexCliConnectOptions } from './types.js';
+export type { OpenCodeConnectOptions, PiConnectOptions, PaseoConnectOptions, CodexConnectOptions, CodexAppServerConnectOptions, CodexCliConnectOptions } from './types.js';
 export interface SendOptions {
     readonly timeoutMs?: number;
     readonly signal?: AbortSignal;
@@ -10,7 +10,7 @@ export interface KeyedSendOptions extends SendOptions {
 }
 export interface Receipt {
     readonly id: string;
-    readonly proof: 'written' | 'admitted' | 'observed';
+    readonly proof: 'admitted' | 'observed';
 }
 export interface Steerable<O = SendOptions> {
     steer(text: string, options?: O): Promise<Receipt>;
@@ -22,10 +22,6 @@ export type OpenCodeAgent = Steerable<KeyedSendOptions> & Queueable<KeyedSendOpt
     readonly harness: 'opencode';
     readonly sessionId: string;
 };
-export type ClaudeAgent = Steerable & {
-    readonly harness: 'claude';
-    readonly sessionId: string;
-};
 export type PiAgent = Steerable & Queueable & {
     readonly harness: 'pi';
     readonly sessionId: string;
@@ -47,9 +43,8 @@ export type CodexCliAgent = Queueable & {
     readonly sessionId: string;
 };
 export type CodexAgent = CodexAppServerAgent | CodexCliAgent;
-export type Agent = OpenCodeAgent | ClaudeAgent | PiAgent | PaseoAgent | CodexAgent;
+export type Agent = OpenCodeAgent | PiAgent | PaseoAgent | CodexAgent;
 export declare function connect(options: OpenCodeConnectOptions): Promise<OpenCodeAgent>;
-export declare function connect(options: ClaudeConnectOptions): Promise<ClaudeAgent>;
 export declare function connect(options: PiConnectOptions): Promise<PiAgent>;
 export declare function connect(options: PaseoConnectOptions): Promise<PaseoAgent>;
 export declare function connect(options: CodexCliConnectOptions): Promise<CodexCliAgent>;

package/dist/packages/agent-delivery/src/index.js

@@ -58,15 +58,6 @@ const harnesses = {
             return { coordinate: target.sessionId, send: (text, value) => sendText(target, text, value) };
         },
     },
-    claude: {
-        harness: 'claude', proof: 'written', accepted: 'written', coordinate: 'sessionId', keyed: false, queue: false,
-        id: (result) => result.messageId,
-        open: async (options) => {
-            const { connectExisting, sendText } = await import('./claude.js');
-            const target = await connectExisting(options);
-            return { coordinate: target.sessionId, send: (text, value) => sendText(target, text, value) };
-        },
-    },
     pi: {
         harness: 'pi', proof: 'observed', accepted: 'observed', coordinate: 'sessionId', keyed: false, queue: true,
         id: (result) => result.inputId,

package/dist/packages/agent-delivery/src/local-endpoint.d.ts

@@ -1,20 +1,12 @@
 import net from 'node:net';
 export interface LocalEndpoint {
-    readonly kind: 'unix' | 'pipe';
-    /** What the socket connects to. */
     readonly path: string;
-    /** What the native receiver fingerprints; also the auth key file digest input. */
-    readonly canonical: string;
 }
-/**
- * A local endpoint is either a Windows named pipe or an absolute Unix socket
- * path. There is no `stat().isSocket()` check: connecting is the existence check.
- */
+/** An absolute Unix socket path; connecting is the existence check. */
 export declare function parseLocalEndpoint(raw: unknown): LocalEndpoint;
 export declare class LocalEndpointError extends Error {
     readonly code: 'unavailable' | 'aborted' | 'timeout' | 'transport';
-    readonly maybeDelivered: boolean;
-    constructor(code: LocalEndpointError['code'], maybeDelivered?: boolean);
+    constructor(code: LocalEndpointError['code']);
 }
 export interface LocalConnectScope {
     readonly signal?: AbortSignal;
@@ -22,5 +14,3 @@ export interface LocalConnectScope {
 }
 /** Connect with bounded waiting. A connect failure is `unavailable`: nothing was written. */
 export declare function connectLocal(endpoint: LocalEndpoint, scope?: LocalConnectScope): Promise<net.Socket>;
-/** LF-delimited JSON frames. Any failure here is past the uncertainty boundary. */
-export declare function writeFrames(socket: net.Socket, frames: object[]): Promise<void>;

package/dist/packages/agent-delivery/src/local-endpoint.js

@@ -1,35 +1,20 @@
 import net from 'node:net';
 import { resolve } from 'node:path';
-/** Claude's own pipe spelling: `\\.\pipe\<lowercased name>`. */
-const PIPE = /^[\\/]{2}[.?][\\/]pipe[\\/](?:(LOCAL)[\\/])?([^\\/]+)$/i;
-/**
- * A local endpoint is either a Windows named pipe or an absolute Unix socket
- * path. There is no `stat().isSocket()` check: connecting is the existence check.
- */
+/** An absolute Unix socket path; connecting is the existence check. */
 export function parseLocalEndpoint(raw) {
-    if (typeof raw !== 'string' || raw.includes('\0'))
-        throw new Error('Invalid local endpoint.');
-    const pipe = PIPE.exec(raw);
-    if (pipe) {
-        const canonical = `\\\\.\\pipe\\${pipe[2].toLowerCase()}`;
-        return { kind: 'pipe', path: canonical, canonical };
-    }
-    if (!(process.platform === 'win32' ? /^[A-Za-z]:[\\/]/.test(raw) : raw.startsWith('/')))
+    if (typeof raw !== 'string' || raw.includes('\0') || !raw.startsWith('/'))
         throw new Error('Invalid local endpoint.');
     const limit = process.platform === 'darwin' ? 103 : process.platform === 'linux' ? 107 : undefined;
     if (limit !== undefined && Buffer.byteLength(raw) > limit)
         throw new Error('Invalid local endpoint.');
-    const canonical = resolve(raw);
-    return { kind: 'unix', path: canonical, canonical };
+    return { path: resolve(raw) };
 }
 export class LocalEndpointError extends Error {
     code;
-    maybeDelivered;
-    constructor(code, maybeDelivered = false) {
+    constructor(code) {
         super(code);
         this.name = 'LocalEndpointError';
         this.code = code;
-        this.maybeDelivered = maybeDelivered;
     }
 }
 function errnoCode(error) {
@@ -83,32 +68,3 @@ export function connectLocal(endpoint, scope = {}) {
         }
     });
 }
-/** LF-delimited JSON frames. Any failure here is past the uncertainty boundary. */
-export function writeFrames(socket, frames) {
-    const payload = frames.map((frame) => JSON.stringify(frame)).join('\n') + '\n';
-    return new Promise((resolveWrite, reject) => {
-        let settled = false;
-        // Error/close handlers stay attached past settling, so a later I/O failure is
-        // swallowed here instead of surfacing as an unhandled socket event.
-        const finish = (error) => {
-            if (settled)
-                return;
-            settled = true;
-            if (error) {
-                reject(error);
-                return;
-            }
-            resolveWrite();
-        };
-        const failed = (error) => finish(new LocalEndpointError(errnoCode(error), true));
-        socket.once('error', failed);
-        socket.once('close', () => finish(new LocalEndpointError('transport', true)));
-        socket.end(payload, 'utf8', (error) => {
-            if (error) {
-                failed(error);
-                return;
-            }
-            finish();
-        });
-    });
-}

package/dist/packages/agent-delivery/src/pi-client.js

@@ -55,8 +55,6 @@ export async function connectPi(options) {
     }
     if (process.platform !== 'darwin')
         throw new ConnectionError('unsupported_platform');
-    if (endpoint.kind !== 'unix')
-        throw new ConnectionError('invalid_arguments');
     const answer = await request(endpoint, { protocol: VERSION, harness: 'pi', op: 'hello', sessionId: options.sessionId }, options.timeoutMs, options.signal);
     if (answer.code !== undefined)
         throw new ConnectionError(answer.code === 'transport' ? 'service_unavailable' : answer.code);

package/dist/packages/agent-delivery/src/types.d.ts

@@ -5,11 +5,6 @@ export interface OpenCodeTarget {
     readonly sessionId: string;
     readonly [targetBrand]: true;
 }
-export interface ClaudeTarget {
-    readonly harness: 'claude';
-    readonly sessionId: string;
-    readonly [targetBrand]: true;
-}
 export interface PiTarget {
     readonly harness: 'pi';
     readonly sessionId: string;
@@ -25,7 +20,7 @@ export interface CodexTarget {
     readonly sessionId: string;
     readonly [targetBrand]: true;
 }
-export type Target = OpenCodeTarget | ClaudeTarget | PiTarget | PaseoTarget | CodexTarget;
+export type Target = OpenCodeTarget | PiTarget | PaseoTarget | CodexTarget;
 export type Delivery = 'steer' | 'queue';
 export interface OpenCodeSendTextOptions {
     readonly delivery?: Delivery;
@@ -33,12 +28,6 @@ export interface OpenCodeSendTextOptions {
     readonly timeoutMs?: number;
     readonly signal?: AbortSignal;
 }
-export interface ClaudeSendTextOptions {
-    readonly delivery?: 'steer';
-    readonly inputId?: never;
-    readonly timeoutMs?: number;
-    readonly signal?: AbortSignal;
-}
 export interface PiSendTextOptions {
     readonly delivery?: Delivery;
     readonly inputId?: never;
@@ -58,7 +47,7 @@ export interface CodexSendTextOptions {
     readonly timeoutMs?: number;
     readonly signal?: AbortSignal;
 }
-export type SendTextOptions = OpenCodeSendTextOptions | ClaudeSendTextOptions | PiSendTextOptions | PaseoSendTextOptions | CodexSendTextOptions;
+export type SendTextOptions = OpenCodeSendTextOptions | PiSendTextOptions | PaseoSendTextOptions | CodexSendTextOptions;
 export interface OpenCodeConnectOptions {
     readonly harness: 'opencode';
     readonly sessionId: string;
@@ -74,15 +63,6 @@ export interface OpenCodeConnectOptions {
     readonly timeoutMs?: number;
     readonly signal?: AbortSignal;
 }
-export interface ClaudeConnectOptions {
-    readonly harness: 'claude';
-    readonly sessionId: string;
-    readonly endpoint: string;
-    readonly token?: string;
-    readonly claudeHome?: string;
-    readonly timeoutMs?: number;
-    readonly signal?: AbortSignal;
-}
 export interface PiConnectOptions {
     readonly harness: 'pi';
     readonly sessionId: string;
@@ -147,20 +127,6 @@ export type OpenCodeDeliveryResult = (OpenCodeAttempt & {
     readonly state: 'unavailable';
     readonly code: 'aborted' | 'timeout';
 });
-interface ClaudeAttempt {
-    readonly harness: 'claude';
-    readonly sessionId: string;
-}
-export type ClaudeDeliveryResult = (ClaudeAttempt & {
-    readonly state: 'written';
-    readonly messageId: string;
-}) | (ClaudeAttempt & {
-    readonly state: 'unknown';
-    readonly code: 'timeout' | 'aborted' | 'transport';
-}) | (ClaudeAttempt & {
-    readonly state: 'unavailable';
-    readonly code: 'aborted' | 'timeout' | 'endpoint_unavailable' | 'authentication_failed';
-});
 interface PiAttempt {
     readonly harness: 'pi';
     readonly sessionId: string;
@@ -214,5 +180,5 @@ export type CodexDeliveryResult = (CodexAttempt & {
     readonly state: 'rejected';
     readonly code: 'not_found' | 'refused' | 'unsupported_version';
 });
-export type DeliveryResult = OpenCodeDeliveryResult | ClaudeDeliveryResult | PiDeliveryResult | PaseoDeliveryResult | CodexDeliveryResult;
+export type DeliveryResult = OpenCodeDeliveryResult | PiDeliveryResult | PaseoDeliveryResult | CodexDeliveryResult;
 export {};

package/dist/plugins/paseo/shared/card-format.d.ts

@@ -0,0 +1,6 @@
+import type { CardPresentation } from "./card-presentation.ts";
+export declare function reachLabel(reach?: CardPresentation["reach"]): string | undefined;
+/** Calendar days, rather than elapsed hours, keep yesterday correct across DST. */
+export declare function timeLabel(at: number, now?: number, compact?: boolean): string;
+/** Only adjacent references from the same origin can form a range. */
+export declare function cardReferences(items: readonly CardPresentation[], originLabel?: (origin: string) => string): string;