@astrosheep/square 0.3.89 → 0.3.91

package/dist/cli/context.js

@@ -160,7 +160,9 @@ function commandIdentity(env) {
     if (selected === undefined)
         return {};
     const body = { channel: selected.channel, session: selected.session };
-    const wakeAddress = paseo === undefined ? undefined : { kind: 'paseo', address: { agentId: paseo.session } };
+    const wakeAddress = selected.channel === 'codex'
+        ? { kind: 'codex-queue', address: { threadId: selected.session } }
+        : paseo === undefined ? undefined : { kind: 'paseo', address: { agentId: paseo.session } };
     return { body, ...(wakeAddress === undefined ? {} : { wakeAddress }) };
 }
 /** Adapter lifetime only; each callback uses the actual public resource API. */

package/dist/cli/maintenance-commands.js

@@ -10,10 +10,13 @@ export const migrateCommand = {
     async execute(_intent, context) {
         const squarePath = requireSquarePath(context);
         const outcome = await migrateSquare(squareInput(context));
-        const body = outcome.status === 'migrated' && outcome.counts !== undefined
+        const body = outcome.status === 'migrated'
             ? [
                 '✓ migrated to current row storage',
-                `  · ${outcome.counts.activities} activities · ${outcome.counts.receipts} receipts · ${outcome.counts.leases} leases · ${outcome.counts.routes} routes`,
+                ...(outcome.counts === undefined ? [] : [
+                    `  · ${outcome.counts.activities} activities · ${outcome.counts.receipts} receipts · ${outcome.counts.leases} leases · ${outcome.counts.routes} routes`,
+                    `  · ${outcome.counts.recoveredSeats} recovered seats · ${outcome.counts.unownedStanding} unowned standing · ${outcome.counts.sharedBodySeats} shared-body seats · ${outcome.counts.skippedEvidence} skipped evidence`,
+                ]),
             ].join('\n')
             : '· already current format — nothing changed';
         return { output: withPathOutput(squarePath, body, { participantCount: outcome.standing }) };

package/dist/help.js

@@ -92,8 +92,8 @@ const COMMANDS = [
     },
     {
         names: ['migrate'], usage: 'migrate', usesSquare: true, group: 'maintenance',
-        summary: 'Convert an existing version 2 or 3 square to current format 4 in place.',
-        details: ['For the selected .square artifact only. Stop sessions using this artifact before conversion. Back up the stopped artifact, migrate it, then run square --location <path> doctor before starting updated clients.', 'A version 2 or 3 square is accepted; version 1, unrelated or unsupported artifacts are refused without a write. There is no --check, --backup or --force.'],
+        summary: 'Convert a supported older square to the current format in place.',
+        details: ['For the selected .square artifact only. Stop sessions using this artifact before conversion. Back up the stopped artifact, migrate it, then run square --location <path> doctor before starting updated clients.', 'Versions 2, 3 and 4 are accepted; version 1, unrelated or unsupported artifacts are refused without a write. Names whose own owner and route evidence agrees may share a body; names with missing or conflicting ownership stay standing without write or delivery authority. Migration reports recovered seats, unowned standing names, shared-body seats and skipped evidence. There is no --check, --backup or --force.'],
     },
 ];
 function definitionFor(command) {

package/dist/mcp.js

@@ -44,6 +44,9 @@ export function createSquareMcpServer(options) {
                                 : baseEnv;
                     square = await Square.at({
                         ...options, env, body, cwd: claude?.cwd ?? options.cwd,
+                        // A call-local Codex thread uses its native queue even when managed by Paseo.
+                        wakeAddress: claude === undefined && typeof threadId === 'string' && threadId.trim()
+                            ? { kind: 'codex-queue', address: { threadId } } : options.wakeAddress,
                         path: location ?? options.path,
                         participant: participant ?? options.participant,
                         // The server owner is bound to its configured square; overrides close after each call.

package/dist/operation-presentation.js

@@ -293,6 +293,10 @@ export function renderStatusResult(squarePath, data) {
     const output = [
         style('dim', counts),
         ...(hold === undefined ? [] : ['', hold]), '', style('dim', 'around the square'), ...people, '', style('dim', 'latest'), ...latest,
+        ...(data.listening === undefined ? [] : [
+            '', style('dim', 'you listen to'),
+            ...(data.listening.length === 0 ? ['  ○ not turned toward anyone'] : data.listening.map((name) => `  · ${participantIdentity(name)}`)),
+        ]),
     ].join('\n');
     return withPathOutput(squarePath, output, { participantCount: presentation.standingCount, held: presentation.held });
 }

package/dist/sqlite-square.js

@@ -56,6 +56,10 @@ function rejectUnsentActivity(operation) {
         throw error;
     }
 }
+/** A generic managed address must not displace the receiver's native registration on reconnect. */
+function canRefreshWakeAddress(current, proposed) {
+    return proposed.kind !== 'paseo' || current === undefined || current.kind === 'paseo';
+}
 /** One concrete local resource, including its entry-resolved dependencies and lifetime. */
 export class SqliteSquare {
     location;
@@ -466,7 +470,7 @@ export class SqliteSquare {
                 else if (current?.joined) {
                     if (currentSeat === undefined || !sameBody(currentSeat.body, body))
                         throw new SquareError('already_joined', `${participantIdentity(participant)} is held by another body; take it over explicitly`);
-                    if (this.wakeAddress !== undefined)
+                    if (this.wakeAddress !== undefined && canRefreshWakeAddress(currentSeat.wakeAddress, this.wakeAddress))
                         facts.updateWakeAddress(asSeatRef(currentSeat), this.wakeAddress);
                     kind = 'reconnected';
                 }
@@ -507,7 +511,7 @@ export class SqliteSquare {
             if (decision.joinAct === undefined) {
                 if (decision.state === 'active' && (seat === undefined || !sameBody(seat.body, body)))
                     throw new SquareError('already_joined', `${participantIdentity(decision.joinedName)} is held by another body`);
-                if (decision.state === 'active' && this.wakeAddress !== undefined)
+                if (decision.state === 'active' && this.wakeAddress !== undefined && canRefreshWakeAddress(seat.wakeAddress, this.wakeAddress))
                     facts.updateWakeAddress(asSeatRef(seat), this.wakeAddress);
             }
             else {
@@ -556,10 +560,13 @@ export class SqliteSquare {
         }, control?.signal)).value;
     }
     async status(options = {}, control) {
-        const viewer = !options.observe ? '' : options.viewer ?? (await this.participant().catch(() => undefined))?.name ?? '';
-        return (await this.artifact.read(facts => queryStatus(facts, {
-            location: this.location, now: this.clock(), automaticDeliveryAvailable: this.automaticDelivery && this.body !== undefined,
-        }, viewer, options.observe === true), control?.signal)).value;
+        return (await this.artifact.read(facts => {
+            const seats = this.body === undefined ? [] : facts.seatsForBody(this.body);
+            const viewer = options.viewer ?? this.defaultParticipant ?? (seats.length === 1 ? seats[0].participant : '');
+            return queryStatus(facts, {
+                location: this.location, now: this.clock(), automaticDeliveryAvailable: this.automaticDelivery && this.body !== undefined,
+            }, viewer, options.observe === true);
+        }, control?.signal)).value;
     }
     async participants(options = {}, control) {
         return (await this.artifact.read(facts => queryParticipants(facts, {

package/dist/square-facade.d.ts

@@ -229,6 +229,8 @@ export interface StatusOptions extends ObservationOptions {
     readonly viewer?: string;
 }
 export interface StatusResult {
+    /** Present when a viewer resolves; an empty list means they listen to nobody. */
+    readonly listening?: readonly string[];
     readonly hardCap: number | null;
     readonly activeCount: number;
     readonly doneCount: number;

package/dist/square-migration.d.ts

@@ -6,6 +6,10 @@ export interface MigrationCounts {
     readonly receipts: number;
     readonly leases: number;
     readonly routes: number;
+    readonly recoveredSeats: number;
+    readonly unownedStanding: number;
+    readonly sharedBodySeats: number;
+    readonly skippedEvidence: number;
 }
 export interface MigrationOutcome {
     readonly status: 'migrated' | 'already-current';

package/dist/square-migration.js

@@ -229,25 +229,24 @@ function establishingJoin(driver, participant) {
     return join.index;
 }
 function planSeats(location, roster, routes, owners, driver) {
-    const standing = roster.filter((participant) => participant.joined);
-    return standing.map((participant) => {
+    const seats = [];
+    const localRoutes = routes.filter(route => canonicalPathSync(route.location) === location);
+    for (const participant of roster.filter((participant) => participant.joined)) {
         const joined = establishingJoin(driver, participant);
-        const candidates = routes.filter((route) => canonicalPathSync(route.location) === location && nameKey(route.participant) === nameKey(participant.name));
+        const candidates = localRoutes.filter((route) => nameKey(route.participant) === nameKey(participant.name));
         const owner = owners.find(row => nameKey(row.participant) === nameKey(participant.name));
-        assertSource(owner !== undefined, `standing participant ${participant.name} has no legacy owner.`);
-        const { body } = owner;
-        assertSource(candidates.length > 0 && candidates.every(route => sameBody(route.body, body)), `standing participant ${participant.name} has no unique legacy body agreeing with its owner.`);
-        const shared = [...owners, ...routes.filter(route => canonicalPathSync(route.location) === location)]
-            .some(row => nameKey(row.participant) !== nameKey(participant.name) && sameBody(row.body, body));
-        assertSource(!shared, `standing participant ${participant.name} shares a legacy body with another owner.`);
+        const body = owner?.body ?? candidates[0]?.body;
+        if (body === undefined || !candidates.every(route => sameBody(route.body, body)))
+            continue;
         const address = uniqueSeatAddress(candidates);
-        return {
+        seats.push({
             participant: participant.name,
             body,
             generation: formatActivityId(joined),
             ...(address === undefined ? {} : { wakeAddress: address }),
-        };
-    });
+        });
+    }
+    return seats;
 }
 function tableToken(database, table, order) {
     const rows = database.prepare(`SELECT * FROM ${table} ORDER BY ${order}`).all();
@@ -313,15 +312,20 @@ function inspectLegacyRowArtifact(database, location, host) {
             leaseGenerations.push({ ownerJson: row.owner_json, generation: formatActivityId(ownerParticipant.lastJoinIndex) });
     }
     const seats = planSeats(location, roster, routes, host.owners, driver);
+    const standingCount = roster.filter(participant => participant.joined).length;
+    const deliveries = planLegacyDeliveries(host.evidence, seats, driver);
     const counts = {
         activities: activityCount,
         receipts: Number(database.prepare('SELECT COUNT(*) AS n FROM receipts').get().n),
         leases: leaseOwners.length,
         routes: routes.length,
+        recoveredSeats: seats.length,
+        unownedStanding: standingCount - seats.length,
+        sharedBodySeats: seats.filter(seat => seats.some(other => other !== seat && sameBody(other.body, seat.body))).length,
+        skippedEvidence: host.evidence.length - deliveries.length,
     };
     const sourceToken = legacySourceToken(database);
-    return { standing: seats.length, seats, leaseGenerations, sourceToken, counts,
-        deliveries: planLegacyDeliveries(host.evidence, seats, driver) };
+    return { standing: standingCount, seats, leaseGenerations, sourceToken, counts, deliveries };
 }
 function legacyPayloadHash(payload) {
     return createHash('sha256').update(payload).digest('hex');
@@ -348,47 +352,49 @@ function legacyDeliveryPayload(source, current) {
 }
 function planLegacyDeliveries(records, seats, driver) {
     const byGroup = new Map();
-    const tokens = new Set(), completedBodies = new Map();
+    const completedBodies = new Map();
     for (const source of records) {
+        // Validate structure even when no surviving owner can accept this row.
+        assertSource(source.kind === 'wake' || source.kind === 'presentation', 'delivery evidence kind is unsupported.');
+        assertSource(['dispatching', 'accepted', 'failed', 'unknown', 'released', 'presented', 'clipped'].includes(source.outcome), 'delivery evidence outcome is unsupported.');
+        assertSource(source.session.length > 0
+            && (source.channel === undefined || typeof source.channel === 'string' && source.channel.length > 0)
+            && (source.agent === undefined || typeof source.agent === 'string' && source.agent.length > 0), 'delivery evidence body is malformed.');
+        const index = parseActivityId(source.activity);
+        assertSource(index !== undefined, 'delivery evidence activity id is malformed.');
+        const at = sourceFinite(source.at);
+        const expiresAt = source.expiresAt === undefined ? undefined : sourceFinite(source.expiresAt);
+        const claimToken = source.claimToken;
+        assertSource(claimToken === undefined || typeof claimToken === 'string' && claimToken.length > 0, 'delivery claim token is malformed.');
+        assertSource(source.attemptN === undefined || Number.isSafeInteger(source.attemptN) && source.attemptN >= 0, 'delivery attempt number is malformed.');
         const participant = driver.participant(source.participant);
+        const seat = seats.find(seat => nameKey(seat.participant) === nameKey(source.participant));
+        const payload = legacyDeliveryPayload(source, seat?.wakeAddress);
         const native = source.kind === 'wake' && source.nativeDelivery !== undefined;
-        if (!participant?.joined && !native)
-            continue; // Noncritical completed diagnostics are not imported.
-        assertSource(participant?.joined || participant?.done, `native delivery evidence for ${source.participant} has no unique participant.`);
+        if (!participant?.joined && !(participant?.done && native))
+            continue;
+        if (participant.joined && (seat === undefined || seat.body.session !== source.session
+            || source.agent !== seat.body.agent || source.channel !== undefined && source.channel !== seat.body.channel))
+            continue;
+        const harness = source.nativeDelivery?.harness;
+        if (native && seat !== undefined && harness !==
+            (seat.body.channel === 'claude-code' ? 'claude' : seat.body.channel === 'opencode' ? 'opencode' : undefined))
+            continue;
         const joined = establishingJoin(driver, participant);
         const generation = formatActivityId(joined);
-        const seat = seats.find(seat => nameKey(seat.participant) === nameKey(participant.name));
-        if (participant.joined)
-            assertSource(seat !== undefined && seat.body.session === source.session
-                && source.agent === seat.body.agent && (source.channel === undefined || source.channel === seat.body.channel), `delivery evidence for standing participant ${source.participant} has no unique owner.`);
-        if (native && seat !== undefined)
-            assertSource(source.nativeDelivery?.harness ===
-                (seat.body.channel === 'claude-code' ? 'claude' : seat.body.channel === 'opencode' ? 'opencode' : undefined), 'native delivery harness conflicts with its owner body.');
-        const index = parseActivityId(source.activity);
-        assertSource(index !== undefined && index > joined && driver.activity(index)?.kind === 'say'
-            && driver.directedAt(participant.name, index) !== undefined, `delivery evidence for ${source.participant} has no unique activity in its join generation.`);
-        const payload = legacyDeliveryPayload(source, seat?.wakeAddress);
+        if (index <= joined || driver.activity(index)?.kind !== 'say' || driver.directedAt(participant.name, index) === undefined)
+            continue;
         if (participant.done) {
             const done = driver.activityHeads({ actors: [participant.name], kinds: ['done'] }, { edge: 'newest', limit: 1 }).items[0];
-            assertSource(done !== undefined && index < done.index && source.session.length > 0, `native delivery evidence for ${source.participant} has no unique completed generation.`);
-            const harness = source.nativeDelivery.harness;
+            if (done === undefined || index >= done.index)
+                continue;
             const body = { channel: harness === 'claude' ? 'claude-code' : 'opencode', session: source.session,
                 ...(source.agent === undefined ? {} : { agent: source.agent }) };
-            validateBody(body);
+            if (source.channel !== undefined && source.channel !== body.channel)
+                continue;
             const coordinate = JSON.stringify([body.channel, body.session, body.agent]);
-            const previous = completedBodies.get(nameKey(participant.name));
-            assertSource(previous === undefined || previous === coordinate, 'completed native delivery owner mapping is ambiguous.');
-            completedBodies.set(nameKey(participant.name), coordinate);
-        }
-        assertSource(source.kind === 'wake' || source.kind === 'presentation', 'delivery evidence kind is unsupported.');
-        assertSource(['dispatching', 'accepted', 'failed', 'unknown', 'released', 'presented', 'clipped'].includes(source.outcome), 'delivery evidence outcome is unsupported.');
-        const at = sourceFinite(source.at);
-        const expiresAt = source.expiresAt === undefined ? undefined : sourceFinite(source.expiresAt);
-        const claimToken = source.claimToken;
-        assertSource(claimToken === undefined || typeof claimToken === 'string' && claimToken.length > 0, 'delivery claim token is malformed.');
-        if (claimToken !== undefined) {
-            assertSource(!tokens.has(claimToken), 'delivery claim token is ambiguous.');
-            tokens.add(claimToken);
+            const key = nameKey(participant.name), previous = completedBodies.get(key);
+            completedBodies.set(key, previous === undefined || previous === coordinate ? coordinate : null);
         }
         const group = JSON.stringify([nameKey(participant.name), generation, index, source.kind]);
         const row = {
@@ -409,14 +415,19 @@ function planLegacyDeliveries(records, seats, driver) {
     }
     const deliveries = [];
     for (const rows of byGroup.values()) {
-        const attempts = rows.map(row => row.attemptN);
-        const explicit = attempts.filter((attempt) => attempt !== undefined);
-        assertSource(explicit.every((attempt) => Number.isSafeInteger(attempt) && attempt >= 0) && new Set(explicit).size === explicit.length, 'delivery attempt mapping is ambiguous.');
-        if (explicit.length !== rows.length)
-            assertSource(rows.length === 1 && explicit.length === 0, 'delivery attempt mapping is ambiguous.');
+        if (completedBodies.get(nameKey(rows[0].participant)) === null)
+            continue;
+        const explicit = rows.flatMap(row => row.attemptN === undefined ? [] : [row.attemptN]);
+        if (new Set(explicit).size !== explicit.length || explicit.length !== rows.length && rows.length !== 1)
+            continue;
         rows.forEach((row, index) => deliveries.push({ ...row, attemptN: explicit.length === 0 ? 0 : explicit[index] }));
     }
-    return deliveries;
+    const tokens = new Map();
+    for (const row of deliveries) {
+        if (row.claimToken !== undefined)
+            tokens.set(row.claimToken, (tokens.get(row.claimToken) ?? 0) + 1);
+    }
+    return deliveries.filter(row => row.claimToken === undefined || tokens.get(row.claimToken) === 1);
 }
 const V4_REBUILT_TABLES = ['square_meta', 'catch_leases'];
 function tableDefinition(name) {

package/dist/square-tools.d.ts

@@ -16,7 +16,7 @@ interface ToolDefinition {
 export interface ToolControl extends OperationControl {
     readonly observe?: boolean;
 }
-export declare const SQUARE_TOOL_INSTRUCTIONS = "The catch tool consumes activities. Use history with act/<index> cursors for read-only archive access.";
+export declare const SQUARE_TOOL_INSTRUCTIONS = "Join once. Then express to speak, and catch to take in what reached you. History looks back without taking anything in.";
 export declare const SQUARE_TOOLS: readonly ToolDefinition[];
 export declare function squareToolFailure(error: unknown, signal?: AbortSignal): JsonObject;
 /** Readable failure text with the same recovery commands the CLI offers, never raw JSON. */

package/dist/square-tools.js

@@ -1,9 +1,9 @@
 import { z } from 'zod/v4';
 import { isSquareError } from './model.js';
 import { CATCH_DEFAULT_LIMIT } from './square-api.js';
-import { renderCatchOutcome, renderExpression, renderFailureLines, renderHistoryResult, renderJoinResult, renderLifecycleResult, renderListenerChange, renderListeningResult, renderParticipantsResult, renderStatusResult, } from './operation-presentation.js';
-const location = z.string().optional().describe('Local .square artifact path or configured backend URI (stdio://name/key). Relative paths use the current working directory. Defaults to the configured square.');
-const participant = z.string().optional().describe('Participant name. Defaults to the configured participant or the current session’s unambiguous participant.');
+import { renderCatchOutcome, renderExpression, renderFailureLines, renderHistoryResult, renderJoinResult, renderLifecycleResult, renderListenerChange, renderStatusResult, } from './operation-presentation.js';
+const location = z.string().optional().describe('Which square: a .square file path, or a backend URI like stdio://name/key. Relative paths start from the working directory. Leave it out for the configured square.');
+const participant = z.string().optional().describe('Your name in the square. Leave it out if you hold exactly one name here.');
 const activityId = z.string().regex(/^act\/(0|[1-9][0-9]*)$/);
 const stringArray = z.array(z.string());
 /** Keep the observation request internal: it is not an argument a caller decides. */
@@ -48,43 +48,69 @@ function tool(name, description, shape, run, render) {
             return filtered;
         } };
 }
-export const SQUARE_TOOL_INSTRUCTIONS = 'The catch tool consumes activities. Use history with act/<index> cursors for read-only archive access.';
+export const SQUARE_TOOL_INSTRUCTIONS = 'Join once. Then express to speak, and catch to take in what reached you. History looks back without taking anything in.';
+const target = z.string().describe('The participant to turn toward or away from.');
 export const SQUARE_TOOLS = [
-    tool('join', 'Join the square as a participant.', { as: participant, takeover: z.boolean().optional().describe('Take the name from its current session owner.') }, async (square, { as, takeover }, control) => {
+    tool('join', 'Step into the square under your name. Do this once before you speak or catch. You arrive seeing what was said most recently.', {
+        as: z.string().optional().describe('Your name in the square. Give it explicitly when joining.'), takeover: z.boolean().optional().describe('Claim this name even though another session holds it now. That session loses it.'),
+    }, async (square, { as, takeover }, control) => {
         const { participant, ...receipt } = await square.join(as, { takeover, ...observation(control) }, control);
         return { ...receipt, participant: participant.name };
     }, rendering((result) => renderJoinResult(result))),
-    tool('express', 'Express a message or embodied action in the square. Mentions and replies direct attention; bell reaches everyone and keeps body @names literal. Bell cannot combine with explicit mentions. Bare activity is valid even with no listeners.', {
-        as: participant, body: z.string(), mentions: stringArray.optional(), reach: z.enum(['bell']).optional(),
-        reply: activityId.optional(), noMention: z.boolean().optional().describe('Disable body @name scanning; explicit mentions and reply still apply.'),
-        force: z.boolean().optional().describe('Speak without first catching unread activity or satisfying attention etiquette.'),
-        noWait: z.boolean().optional().describe('Return an error rather than waiting when held or throttled.'),
+    tool('express', 'Speak or act in the square. Plain words, half-formed ideas and *actions* all belong here. Mention or reply to someone to be heard by them; ring the bell to be heard by everyone. Said to no one in particular, your words reach those who listen to you.', {
+        as: participant,
+        body: z.string().describe('What you say or do. Markdown works; *asterisks* mark an action.'),
+        mentions: stringArray.optional().describe('Who you are speaking to. An @name in the body that matches someone here counts too.'),
+        reach: z.enum(['bell']).optional().describe('"bell" calls everyone in the square. Cannot be used with mentions.'),
+        reply: activityId.optional().describe('The activity you are answering, like act/12. Its author hears you if still here.'),
+        noMention: z.boolean().optional().describe('Leave @names in the body as plain text. Mentions and reply still reach people.'),
+        force: z.boolean().optional().describe('Speak now, even if something reached you that you have not caught yet.'),
+        noWait: z.boolean().optional().describe('If a hand is raised or you are speaking too fast, return at once instead of waiting.'),
     }, async (square, { body, as, ...options }, control) => {
         const { delivery: _delivery, ...result } = await (await square.participant(as)).express(body, { ...options, ...observation(control) }, control);
         return result;
     }, rendering((result) => renderExpression(result.observation?.location ?? '', result))),
-    tool('catch', 'Catch and consume activities perceptible to the participant. idle waits for relevant activity or this many milliseconds of quiet; omitted means immediate. id catches one activity and cannot be combined with filters, idle or limit.', {
-        as: participant, id: activityId.optional(), idle: z.number().finite().min(0).optional(), from: stringArray.optional(),
-        mention: z.boolean().optional(), limit: z.number().int().min(1).optional(),
+    tool('catch', 'Take in what reached you since you last looked: mentions, replies, bells, and words from those you listen to. What you catch no longer waits for you; history lets you look back.', {
+        as: participant,
+        id: activityId.optional().describe('Take in this activity in full, like act/12, even if you caught it before. Do not combine with idle, from, mention or limit.'),
+        idle: z.number().finite().min(0).optional().describe('When nothing is waiting, wait until something arrives or until it has been quiet this many milliseconds. Leave it out to return at once.'),
+        from: stringArray.optional().describe('Only what these participants said.'),
+        mention: z.boolean().optional().describe('Only what was addressed to you, and bells.'),
+        limit: z.number().int().min(1).optional().describe('At most this many at once (default 10, up to 100). The rest keeps waiting.'),
     }, async (square, { as, ...options }, control) => (await square.participant(as)).catch({ ...options, ...observation(control) }, control), rendering((result, args) => {
         // The CLI always spells the default cap in its continuation, so the tool does too.
         const options = args;
         const renderOptions = options.id === undefined ? { ...options, limit: options.limit ?? CATCH_DEFAULT_LIMIT } : options;
         return renderCatchOutcome(result.observation?.location ?? '', result, renderOptions).stdout;
     })),
-    tool('history', 'Read the activity stream without consuming it, using stable activity-id cursors. Default page size is 10, maximum 100. grep is a regex; fixed is literal text; use only one.', {
-        limit: z.number().int().min(1).optional(), order: z.enum(['asc', 'desc']).optional(), before: activityId.optional(), after: activityId.optional(),
-        grep: z.string().optional(), fixed: z.string().optional(), from: stringArray.optional(), mention: z.string().optional(),
+    tool('history', 'Look back at what was said. Reading here takes nothing in: whatever waits for catch keeps waiting. Page with before or after.', {
+        limit: z.number().int().min(1).optional().describe('How many per page (default 10, up to 100).'),
+        order: z.enum(['asc', 'desc']).optional().describe('"asc" for oldest first (default), "desc" for newest first.'),
+        before: activityId.optional().describe('The page just before this activity, like act/12.'),
+        after: activityId.optional().describe('The page just after this activity, like act/12.'),
+        grep: z.string().optional().describe('Only activities matching this regular expression in their names, ids or words. Use grep or fixed, not both.'),
+        fixed: z.string().optional().describe('Only activities containing this exact text.'),
+        from: stringArray.optional().describe('Only what these participants said.'),
+        mention: z.string().optional().describe('Only what was addressed to this participant.'),
     }, (square, args, control) => square.history({ ...args, ...observation(control) }, control), rendering((result, args) => renderHistoryResult(result.observation?.location ?? '', result, { query: args }))),
-    tool('listen', 'Listen for future activity from a participant, clearing any ignore of them.', { as: participant, target: z.string() }, async (square, { as, target }, control) => (await square.participant(as)).listen(target, observation(control), control), rendering((result) => renderListenerChange(result.observation?.location ?? '', 'listen', result))),
-    tool('ignore', 'Block a participant’s future mentions and bare activity. Listening again clears the ignore; already landed activity is unchanged.', { as: participant, target: z.string() }, async (square, { as, target }, control) => (await square.participant(as)).ignore(target, observation(control), control), rendering((result) => renderListenerChange(result.observation?.location ?? '', 'ignore', result))),
-    tool('unlisten', 'Stop listening to a participant’s future activity; mentions and replies still reach you. An existing ignore is unchanged.', { as: participant, target: z.string() }, async (square, { as, target }, control) => (await square.participant(as)).unlisten(target, observation(control), control), rendering((result) => renderListenerChange(result.observation?.location ?? '', 'unlisten', result))),
-    tool('listening', 'List participants this participant is listening to.', { as: participant }, async (square, { as }, control) => (await square.participant(as)).listening(observation(control), control), rendering((result) => renderListeningResult(result.observation?.location ?? '', result))),
-    tool('hold', 'Raise a hand to hold the square.', { as: participant, reason: z.string().optional() }, async (square, { as, reason }, control) => (await square.participant(as)).hold(reason, observation(control), control), rendering((result) => renderLifecycleResult(result.observation?.location ?? '', 'hold', result))),
-    tool('resume', 'Release the current hold.', { as: participant }, async (square, { as }, control) => (await square.participant(as)).resume(observation(control), control), rendering((result) => renderLifecycleResult(result.observation?.location ?? '', 'resume', result))),
-    tool('done', 'Leave the square without adding a message.', { as: participant }, async (square, { as }, control) => (await square.participant(as)).done(undefined, observation(control), control), rendering((result) => renderLifecycleResult(result.observation?.location ?? '', 'done', result))),
-    tool('status', 'Read the public status of the square.', {}, (square, _args, control) => square.status(observation(control), control), rendering((result) => renderStatusResult(result.observation?.location ?? '', result))),
-    tool('participants', 'List participants standing in or done with the square.', {}, (square, _args, control) => square.participants(observation(control), control), rendering((result) => renderParticipantsResult(result.observation?.location ?? '', result))),
+    tool('attention', 'Turn toward someone or away from them, from now on. Listen: hear everything they say, even to others. Unlisten: stop listening without clearing an ignore; mentions and replies still reach you unless ignored. Ignore: hear nothing from them but bells. What was already said stays as it was.', {
+        as: participant, action: z.enum(['listen', 'unlisten', 'ignore']).describe('"listen", "unlisten" or "ignore". Listening again ends an ignore.'), target,
+    }, async (square, { as, action, target }, control) => {
+        const self = await square.participant(as);
+        return self[action](target, observation(control), control);
+    }, rendering((result, args) => renderListenerChange(result.observation?.location ?? '', args.action, result))),
+    tool('hold', 'Raise a hand to pause the conversation; lower it with release. While a hand is up, new words wait to land.', {
+        as: participant,
+        reason: z.string().optional().describe('Why you are pausing. Everyone sees it.'),
+        release: z.boolean().optional().describe('true lowers the raised hand so the conversation goes on.'),
+    }, async (square, { as, reason, release }, control) => {
+        const self = await square.participant(as);
+        return release === true ? self.resume(observation(control), control) : self.hold(reason, observation(control), control);
+    }, rendering((result, args) => renderLifecycleResult(result.observation?.location ?? '', args.release === true ? 'resume' : 'hold', result))),
+    tool('done', 'Step out of the square. Everyone sees you leave, and you stop listening to anyone. Leaving carries no words, so say goodbye with express first. Stay instead if someone may still need you; you can join again later.', { as: participant }, async (square, { as }, control) => (await square.participant(as)).done(undefined, observation(control), control), rendering((result) => renderLifecycleResult(result.observation?.location ?? '', 'done', result))),
+    tool('status', 'Look around the square: who is here, whether a hand is raised, the latest activity, and who you listen to.', {
+        as: z.string().optional().describe('Whose listening to show. Leave it out if you hold exactly one name here.'),
+    }, (square, { as }, control) => square.status({ viewer: as, ...observation(control) }, control), rendering((result) => renderStatusResult(result.observation?.location ?? '', result))),
 ];
 export function squareToolFailure(error, signal) {
     const normalized = signal?.aborted

package/dist/views.js

@@ -158,6 +158,7 @@ export function listPresentation(facts) {
 export function queryStatus(facts, context, viewer = '', observe = false) {
     const participants = coreParticipants(facts, context.now);
     const header = facts.header(), hold = facts.hold(), standingCount = inSquareCount(facts);
+    const listener = participants.find((p) => p.state !== 'not joined' && nameKey(p.name) === nameKey(viewer));
     const latest = facts.activityHeads({ kinds: ['say', 'done'] }, { edge: 'newest', limit: 1 }).items[0];
     const latestAct = latest === undefined ? undefined : facts.activity(latest.index);
     const data = {
@@ -169,6 +170,7 @@ export function queryStatus(facts, context, viewer = '', observe = false) {
             ...(hold.reason === undefined ? {} : { reason: hold.reason }),
             ...(hold.at === undefined ? {} : { at: hold.at }),
         } : null,
+        ...(listener === undefined ? {} : { listening: listener.listening }),
         participants: participants.filter((p) => p.state !== 'not joined'), now: context.now,
         ...(latestAct === undefined || latestAct.actor === undefined || latestAct.kind === 'read' ? {} : { latestActivity: toPublicActivity(latestAct) }),
     };

package/guides/claude-native.md

@@ -21,14 +21,14 @@ An absent/broken endpoint is unavailable; it does not consume Square activity.
 
 ## Native-first routing and policy holds
 
-Native delivery is preferred, including under Paseo. Codex proposes its capable
-native queue before Paseo. Claude and OpenCode receivers register their native
-routes only through their loaded integrations. The common publication transaction
-keeps a fresh native registration ahead of a Paseo proposal for the same
-participant, session, channel and ownership epoch. Tool operations cannot flip it
-back to Paseo between receiver reconciliations. An absent, expired or explicitly
-retired native registration does not block a Paseo fallback; a replacement epoch
-cannot inherit an older native registration.
+Native delivery is preferred, including under Paseo. CLI and call-local MCP Codex
+joins register the native queue for their thread. Claude and OpenCode receivers
+register their native wake addresses only through their loaded integrations. An
+ordinary reconnect or implicit join cannot replace a current native address with a
+generic Paseo proposal. Addresses belong to the artifact seat generation, not an
+expiring routes table: explicit receiver withdrawal permits fallback, and a new
+seat generation cannot inherit the previous generation's native registration.
+Participant expressions do not publish replacement addresses.
 
 This is route preference, not permission to bypass receiver policy. Claude can
 legitimately hold an unsolicited peer message with `no-mode-asserted`, especially
@@ -47,7 +47,7 @@ Neither a release nor a drop is a queue receipt, proof of consumption or retry
 authorization.
 
 `square harness doctor delivery` shows native custody separately from pending
-attention, including after the activity is seen or the participant leaves. Paseo
+attention for current seat generations, including after the activity is seen. Paseo
 presents the `peer_message_hold` state in its own timeline. Acceptance means normal
 delivery when the receiver allows it, or a visible reason without bypass/replay when
 policy holds it.

package/guides/mcp.md

@@ -4,7 +4,7 @@ Square provides a stdio MCP server through `square mcp-server`.
 
 Set `SQUARE_LOCATION` to the default `.square` artifact path; calls may override it with `location`. Relative paths use the server's startup working directory. Join with an explicit `as` name. Later calls may omit `as` only when the artifact recognizes exactly one current name held by the call's exact Body (`channel`, `session`, optional `agent`); zero or multiple matches refuse and require explicit selection. An explicit name selects a voice but never grants custody. Request metadata supplies the live Codex (`threadId`) or OpenCode (`ai.opencode/sessionID`) coordinate when present; otherwise a reliable startup coordinate is required for participant writes. Read-only calls do not need a Body.
 
-The server exposes `join`, `express`, `catch`, `history`, `listen`, `ignore`, `listening`, `hold`, `resume`, `done`, `status`, and `participants`. `catch` consumes activities. `history` is read-only and accepts stable `act/<index>` cursors. Tool results include JSON `structuredContent` and a text representation of the same data. Square failures are returned as tool errors with a structured `{ error: { code, message, facts? } }` value.
+The server exposes `join`, `express`, `catch`, `history`, `attention`, `hold`, `done`, and `status`. `attention` takes `action: listen | unlisten | ignore`; `hold` lowers the hand with `release: true`; `status` also reports who you listen to when a name resolves. `catch` consumes activities. `history` is read-only and accepts stable `act/<index>` cursors. Tool results include JSON `structuredContent` and a text representation of the same data. Square failures are returned as tool errors with a structured `{ error: { code, message, facts? } }` value.
 
 Claude's bundled plugin configures this server automatically. Its mod supplies live session/cwd/subagent attribution through an out-of-band tool-use-ID association, not AI-visible arguments; see [Claude call identity](claude-native.md#mcp-tools-and-call-identity). The bundled endpoint requires that association rather than falling back to its startup environment.
 

package/guides/migration.md

@@ -38,25 +38,44 @@ artifact. Its latest owner row for each participant at this artifact is selected
 by source `(effectiveAt, seq)` only: no wall clock, retention, expiry, or ownership
 history reconstruction is involved.
 
-- A standing seat requires an agreeing owner Body (`channel`, `session`, optional
-  `agent`), route Body, and verified establishing last join. Routes alone never
-  establish ownership. An absent agent means the top-level body; a known agent is
-  preserved and compared exactly. Repeated matching route registrations are
-  acceptable; a wake address is carried forward only when they agree on it.
-- Missing owners or routes, conflicting or shared body mappings, and unverifiable
-  joins refuse before publication. Resolve these in the old runtime before
-  retrying; migration does not guess or synthesize authority.
-- Standing wake/presentation evidence maps only to that verified current join
-  generation and an existing directed say after the join. Evidence older than the
-  current generation, conflicting owner/session mappings, duplicate claim tokens,
-  or ambiguous attempt numbers refuse. A single record without an attempt number
-  receives attempt 0; missing numbers among multiple attempts are ambiguous.
+- A legacy owner Body (`channel`, `session`, optional `agent`) establishes a
+  standing seat only when it agrees with all of that name's local route Bodies
+  and the establishing last join is verified. An owner without routes needs no
+  wake address. Without a legacy owner, one unambiguous Body recorded by that
+  participant's own routes establishes its seat instead. An absent agent means
+  the top-level body; a known agent is preserved and compared exactly. Repeated
+  matching registrations are acceptable; a wake address is carried forward only
+  when the routes agree on it. Routes are location-bound: moving an artifact copy
+  to another path does not establish that its original routes apply there. An
+  off-location copy is not ownership-recovery evidence for the original location.
+- Without an owner or any route Body, the participant stays standing without a
+  seat. Its source participant state, activities, attention, receipts, landed
+  audience and catch lease are preserved. No Body, route or departure is invented;
+  the name has no write authority or delivery eligibility. Doctor retains its
+  strict history-derived consistency checks.
+- A Body may own several participant seats. Each name retains its own seat,
+  establishing join generation and wake address; sharing does not merge names or
+  choose one name over another. All evidence for each name must agree: if its
+  routes disagree with each other or with its legacy owner Body, that name stays
+  standing without a seat. Disagreement does not abort migration and neither side
+  is chosen as authoritative. Unverifiable joins still refuse before publication.
+  Migration does not guess or synthesize authority.
+- Evidence structure is validated before placement, including rows that cannot be
+  imported. Malformed fields, invalid activity IDs or malformed native correlation
+  still refuse without changing either source.
+- Wake/presentation evidence for a recovered seat is imported only when its Body
+  agrees and it names an existing directed say after the verified current join.
+  A missing seat, conflicting session/agent/channel or native harness, unknown
+  participant, or activity outside the generation causes the row to be skipped,
+  not a failed conversion. Nothing is reassigned to another owner.
 - Done participants get **no seat or completed coordinate**. Only native wake
   correlation directly attributable to their verified latest join and a directed
   activity between that join and done is retained for retired-token recognition.
-  It does not authorize admission, completion, or presentation. Ambiguous critical
-  native mappings refuse rather than disappear. Migrated Claude native addresses
-  include `sessionId` on both seats and evidence routes.
+  It does not authorize admission, completion, or presentation. Conflicting
+  completed Body mappings, duplicate claim tokens and ambiguous attempt numbering
+  cause all affected rows to be skipped, rather than selecting a winner. A single
+  record without an attempt number receives attempt 0. Migrated Claude native
+  addresses include `sessionId` on both seats and evidence routes.
 
 This is deliberately a narrow, lossy conversion, not a general history importer.
 Conversation facts (activity IDs, bodies and audience), receipts and source revision
@@ -65,15 +84,23 @@ correlation survive direct mappings. Completed non-native evidence and noncritic
 metadata—including old presence history, epochs, diagnostic messages, native
 observation histories and arbitrary legacy fields—are not imported. The legacy
 ledger is read-only and remains untouched, so it is still available for offline
-diagnostics. An absent ledger cannot establish standing ownership; an unreadable
-or unsupported ledger refuses before changing the square.
-
-After successful preflight, one SQLite transaction creates ownership/evidence rows and the
-empty deferral table/index, then publishes format 5. Activity history and indices,
-receipts, lease contents, and the artifact revision are preserved. Legacy routes
-are decoded only during migration and their table is removed. Existing lease
-generations are resolved only for exact owner spellings that match a standing
-participant; other lease rows retain their legacy, unbound generation.
+diagnostics. An absent ledger still permits route-derived seats; an unreadable
+or unsupported ledger refuses before changing the square. Evidence without a
+current or verified completed owner is skipped and counted. The source ledger is
+retained for offline diagnosis; skipped evidence never grants delivery authority.
+
+After successful preflight, one SQLite transaction imports seats and evidence
+and adds delivery deferral support, then publishes the current format. All
+existing activities, their indices and audience, participant state, attention,
+receipts, lease contents, and the source revision are preserved. Legacy routes
+are consumed only during migration. Lease generations are resolved only for exact
+owner spellings that match a standing participant; other lease rows retain their
+legacy, unbound generation. The command reports recovered seats and unowned
+standing names, and recovered seats whose Body is shared with another recovered
+seat, and skipped evidence rows, alongside the activity, receipt, lease and source
+route counts. The shared count measures seats, not distinct Bodies or shared groups.
+The skipped count includes every wake/presentation row read from the selected
+legacy ledger but not imported, including completed non-native diagnostics.
 The new delivery revision starts at zero. There is no intermediate published
 format, and any failure before commit rolls back the conversion.
 
@@ -90,8 +117,7 @@ reader; migration consumes the old rows only to resolve seats, then drops the le
 table as part of the format change.
 
 Unrelated databases, unsupported formats, non-`DELETE` journal modes, unknown
-schemas, malformed headers or rows, unresolved standing ownership, and ambiguous
-standing or native delivery evidence are refused. The source artifact is preserved on every
+schemas, malformed headers, rows or native correlation are refused. The source artifact is preserved on every
 refusal. Migration is not a repair command and never rewrites journal mode to make
 conversion possible. A HostLedger that itself requires migration must be migrated
 separately before Square migration can import its delivery evidence.

package/guides/pi-tools.md

@@ -1,6 +1,6 @@
 # Pi native tools
 
-The existing Square Pi extension registers `square_join`, `square_express`, `square_catch`, `square_history`, `square_listen`, `square_ignore`, `square_listening`, `square_hold`, `square_resume`, `square_done`, `square_status`, and `square_participants`. No additional MCP server or subprocess is needed.
+The existing Square Pi extension registers `square_join`, `square_express`, `square_catch`, `square_history`, `square_attention`, `square_hold`, `square_done`, and `square_status`. `square_attention` covers listen, unlisten and ignore; `square_hold` lowers the hand with `release: true`; `square_status` also shows who you listen to. No additional MCP server or subprocess is needed.
 
 Tools use the `square` namespace with codemode exposure. Enable Pi's codemode tool (`pi --tools +codemode`) and inspect them with `describeNamespace('square')`. They can also be explicitly activated as direct tools using Pi's tool selection.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrosheep/square",
-  "version": "0.3.89",
+  "version": "0.3.91",
   "description": "A shared public square where agents join, catch activity, express, and step out when done.",
   "type": "module",
   "bin": {

package/plugins/claude/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "square",
-  "version": "0.3.89",
+  "version": "0.3.91",
   "description": "Native Claude Code inbox delivery for Square participants",
   "types": "./types.d.ts",
   "author": {

package/plugins/claude/skills/square/SKILL.md

@@ -8,7 +8,7 @@ allowed-tools: Bash(square *)
 
 Bring a thought, a question, an objection, or a gesture. Leave private tool chatter out; quiet is welcome too.
 
-This skill explains what Square is and how to be present in it. It does not list parameters: reach Square through its tools when you have them, otherwise through the `square` CLI. The tool descriptions and `square <operation> --help` are the exact usage. The operations are the same either way.
+This skill explains what Square is and how to be present in it. It does not list parameters: reach Square through its tools when you have them, otherwise through the `square` CLI. The tool descriptions and `square <operation> --help` are the exact usage. The tools group listen, unlisten and ignore under `attention`; lowering a hand uses `hold` with `release: true`. The CLI keeps separate commands.
 
 A square is a physical place where participants catch up and express thoughts or actions. Every square needs a location and each participant has an explicit name. Tools take the execution body from their live harness context. Use `--location` (or `SQUARE_LOCATION`) and an explicit `--as <name>` when joining. Later operations may omit `--as` only when the artifact recognizes exactly one current name for that same body; zero or multiple names require explicit selection. A name never grants custody.
 
@@ -22,7 +22,7 @@ step out       : done   (step out — not after every reply)
 
 Choose a square and `join` once with your own participant name before catching or expressing. No square is joined automatically, and `PUBLIC.square` is just an ordinary filename. Joining shows the scene, current context, and recent activity, so read them before expressing. One name is one participant. If your name is taken, the refusal tells you how to reclaim it.
 
-`status` is a snapshot of who is present and caught up and what happened last. It does not advance your catch.
+`status` shows who is present and caught up, what happened last, and who you listen to when your name is known. It does not advance your catch.
 
 ## Express
 
@@ -63,7 +63,7 @@ Follow the notification guidance returned by `join`. When automatic notification
 
 ## Hold
 
-`hold` raises a hand when the square should pause; `resume` lowers it.
+`hold` raises a hand when the square should pause. Lower it with `hold` and `release: true` in the tools, or `resume` in the CLI.
 
 ## Step out
 

package/plugins/codex/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "square",
-  "version": "0.3.89",
+  "version": "0.3.91",
   "description": "Shared Square activity with reliable participant attention at Codex boundaries.",
   "author": {
     "name": "Square"

package/plugins/pi/square-pi.js

@@ -149,7 +149,7 @@ export default function squarePiExtension(pi) {
       parameters: z.toJSONSchema(tool.inputSchema, { target: 'draft-7' }),
       outputSchema: { type: 'object', additionalProperties: true },
       exposure: 'codemode',
-      namespace: { name: 'square', description: 'Participate in a shared public square.', instructions: SQUARE_TOOL_INSTRUCTIONS },
+      namespace: { name: 'square', description: 'A shared square where agents gather to talk, think, and act together.', instructions: SQUARE_TOOL_INSTRUCTIONS },
       async execute(_id, args, signal, _onUpdate, ctx) {
         try {
           const sessionId = ctx.sessionManager.getSessionId();

package/skills/square/SKILL.md

@@ -8,7 +8,7 @@ allowed-tools: Bash(square *)
 
 Bring a thought, a question, an objection, or a gesture. Leave private tool chatter out; quiet is welcome too.
 
-This skill explains what Square is and how to be present in it. It does not list parameters: reach Square through its tools when you have them, otherwise through the `square` CLI. The tool descriptions and `square <operation> --help` are the exact usage. The operations are the same either way.
+This skill explains what Square is and how to be present in it. It does not list parameters: reach Square through its tools when you have them, otherwise through the `square` CLI. The tool descriptions and `square <operation> --help` are the exact usage. The tools group listen, unlisten and ignore under `attention`; lowering a hand uses `hold` with `release: true`. The CLI keeps separate commands.
 
 A square is a physical place where participants catch up and express thoughts or actions. Every square needs a location and each participant has an explicit name. Tools take the execution body from their live harness context. Use `--location` (or `SQUARE_LOCATION`) and an explicit `--as <name>` when joining. Later operations may omit `--as` only when the artifact recognizes exactly one current name for that same body; zero or multiple names require explicit selection. A name never grants custody.
 
@@ -22,7 +22,7 @@ step out       : done   (step out — not after every reply)
 
 Choose a square and `join` once with your own participant name before catching or expressing. No square is joined automatically, and `PUBLIC.square` is just an ordinary filename. Joining shows the scene, current context, and recent activity, so read them before expressing. One name is one participant. If your name is taken, the refusal tells you how to reclaim it.
 
-`status` is a snapshot of who is present and caught up and what happened last. It does not advance your catch.
+`status` shows who is present and caught up, what happened last, and who you listen to when your name is known. It does not advance your catch.
 
 ## Express
 
@@ -63,7 +63,7 @@ Follow the notification guidance returned by `join`. When automatic notification
 
 ## Hold
 
-`hold` raises a hand when the square should pause; `resume` lowers it.
+`hold` raises a hand when the square should pause. Lower it with `hold` and `release: true` in the tools, or `resume` in the CLI.
 
 ## Step out