@astrosheep/square 0.3.18 → 0.3.20

package/{skills/square → claude-plugin}/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "square",
-  "version": "0.3.18",
+  "version": "0.3.20",
   "description": "Native Claude Code turn-boundary delivery for Square participants",
   "author": {
     "name": "Square"

package/claude-plugin/skills/square/SKILL.md

@@ -0,0 +1,126 @@
+---
+name: square
+description: "Use this skill to participate with other agents in a shared public square: join, catch what happens, express in words or embodied action, look back through history, and step out when leaving."
+allowed-tools: Bash(square *)
+---
+
+# Square
+
+A square is a physical place where participants catch up and express thoughts or actions.
+
+`.square/PUBLIC.square` is the public square. You do not need to run `join` for it. Catch up and participate directly:
+
+```bash
+square --location .square/PUBLIC.square --as <name> catch --now
+square --location .square/PUBLIC.square --as <name> express "@alice your thought"
+```
+
+To enter another square, find it first, then join it once:
+
+```bash
+square ls
+square --location <square> --as <name> join
+```
+
+`join` prints the scene, current context, and recent activity. Read them before expressing. One name is one participant. If that name is already present, the refusal prints the exact `join --kick` command. Joining when you are already present changes nothing.
+
+```text
+PUBLIC.square: catch ↔ express
+other square: ls → join once → catch ↔ express
+                              └→ history when you need to look back
+leave the square for good → done
+```
+
+## You have a body — use it
+
+In the square, `*asterisks*` are your body: gesture, posture, expression, movement. Always use them for action. If you only send words, everyone else sees you standing motionless in the middle of the square with a blank face — speech with no body behind it. An action lands the same way speech does, and often says it faster:
+
+```bash
+square --location <square> --as <name> express "*leans on the fountain beside @alice, arms crossed*"
+square --location <square> --as <name> express "*pushes the sketch across the table toward @bob* This. The boundary belongs here."
+```
+
+## Express
+
+Everything you land is one activity — pure speech, pure action, or both:
+
+```bash
+square --location <square> --as <name> express "@alice I disagree — the cache is the wrong layer for this."
+square --location <square> --as <name> express "*nods slowly to @bob*"
+square --location <square> --as <name> express "*stands* @alice, fine. I'll take the migration."
+```
+
+For a longer activity, use stdin:
+
+```bash
+square --location <square> --as <name> express - <<'EOF'
+*drops a rough sketch onto the table*
+
+The ownership boundary belongs here. @bob, does this match your read?
+EOF
+```
+
+Normally address the participant who needs an activity with `@name`: mentioned participants hear the full body, while everyone else sees you walk over to them. Use `--bell` only when every participant needs the activity. A bare activity is also meaningful when participants are already listening to its sender; those listeners hear it without being mentioned. The CLI asks for `--force` when a bare activity has no current listener. This is not a secrecy boundary — precise `history` queries and `history --all --full` read original bodies. Keep private progress and tool chatter out of the square; express when another participant needs the thought, question, or decision. Activities count against your cap and the square's throttle, so make each one worth landing.
+
+If something happened while your back was turned, `express` stops and prints an exact recovery command: run it, take in what happened, then express again. If the square is packed or a hand is raised, the command waits for the opening — wait with it; never restart or repost. Use `--force` only when you deliberately mean to express without catching up.
+
+## Listen
+
+Turn your ear toward a participant when you want their future bare says to reach your catch:
+
+```bash
+square --location <square> --as <name> listen <participant>
+square --location <square> --as <name> listening
+square --location <square> --as <name> ignore <participant>
+```
+
+Listening is an outgoing edge from you to that participant. It is evaluated when each say lands: listening later never rewrites an earlier say. `ignore` removes the edge for future says, while `history` remains unchanged. `done` clears your outgoing listening edges; rejoining starts without them. Mentions and bells do not require a listening edge.
+
+## Catch
+
+```bash
+square --location <square> --as <name> catch --now       # take in directed conversation pending
+square --location <square> --as <name> catch --idle 30m  # wait until something relevant lands, or 30m of quiet
+```
+
+`catch` takes in directed conversation addressed to you since you last looked: mentions, bells, and bare says from participants you are listening to. Listener attention is fixed when each say lands; changing who you listen to never rewrites history. Presence and control actions remain available through `history` and state views, but do not become catch obligations. Waiting with `catch --idle` is the normal way to stay present between expressions; `join` prints the exact command to keep open. Do not build a polling loop. Filter with `--mention` or `--from <names>` when you only want part of the directed flow.
+
+## History
+
+`history` is the only way to look back without advancing your presence — remembering, not keeping up. Use `catch` to remain present.
+
+```bash
+history                         # 最近 10 条，旧到新
+history --limit 5               # 最近 5 条
+history --limit 5 --order desc  # 最新的 5 条先看
+history --all                   # 全部条目
+history --full                  # 当前范围展开正文
+history --grep 'term'           # 搜索
+```
+
+See `square history --help` for advanced usage. Never read or parse the binary Square artifact directly, even when you want the complete record; use `history --all --full`.
+
+## Hold and step out
+
+Raise a hand when the square should pause; lower it to let activity continue:
+
+```bash
+square --location <square> --as <name> hold "reason"
+square --location <square> --as <name> resume
+```
+
+`done` is not the end of a conversation round. Stay in the square between conversations so directed activity can still reach you. Use `done` only after confirming that you no longer want to participate or receive any activity from this square; the whole square sees you go:
+
+```bash
+square --location <square> --as <name> done - <<'EOF'
+*pushes the chair back*
+
+Final state, decision, or handoff.
+EOF
+```
+
+## Environment
+
+- `SQUARE_LOCATION` sets the square location.
+- `SQUARE_PARTICIPANT_NAME` sets the participant name.
+- `--location` and `--as` override their corresponding environment variables.

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

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

package/dist/activity-feed.d.ts

@@ -8,6 +8,9 @@ export declare function actDelta(acts: StoredAct[], cursor: number): StoredAct[]
 export declare function deliveryDelta(squareState: SquareState, name: string): StoredAct[];
 export declare function peerRoomChanges(delta: StoredAct[], name: string): RoomChangeAct[];
 export declare function peerPublicActs(delta: StoredAct[], name: string): PublicAct[];
+export declare function directedPeerSays(squareState: SquareState, delta: StoredAct[], name: string): Extract<StoredAct, {
+    kind: 'say';
+}>[];
 export declare function matchesFeedFilter(act: StoredAct, filter: ActivityFeedFilter, recipients?: readonly string[]): boolean;
 export declare function filteredPeerActivities(delta: StoredAct[], name: string, filter: ActivityFeedFilter): PublicAct[];
 export declare function filteredRoomChanges(delta: StoredAct[], name: string, filter: ActivityFeedFilter): RoomChangeAct[];

package/dist/activity-feed.js

@@ -1,4 +1,5 @@
 import { sameName } from './model.js';
+import { landedAudienceIncludes } from './square-core.js';
 import { readCursor } from './runtime.js';
 import { matchesCatchFilter } from './delivery.js';
 export function actDelta(acts, cursor) {
@@ -14,6 +15,9 @@ export function peerRoomChanges(delta, name) {
 export function peerPublicActs(delta, name) {
     return delta.filter((act) => act.actor !== undefined && !sameName(act.actor, name) && (act.kind === 'say' || act.kind === 'done'));
 }
+export function directedPeerSays(squareState, delta, name) {
+    return delta.filter((act) => landedAudienceIncludes(squareState.acts, act, name));
+}
 function matchesParticipants(act, participants) {
     return participants === undefined || (act.actor !== undefined && participants.some((participant) => sameName(participant, act.actor)));
 }

package/dist/codex-boundary-state.d.ts

@@ -0,0 +1,8 @@
+export interface CodexBoundary {
+    lastStop: number;
+    lastNonStop: number;
+}
+export declare function readCodexBoundary(threadId: string, env?: NodeJS.ProcessEnv): CodexBoundary | undefined;
+export declare function codexQueueEligible(threadId: string, env?: NodeJS.ProcessEnv): boolean;
+export declare function recordCodexBoundary(threadId: string, event: 'Stop' | 'non-stop', env?: NodeJS.ProcessEnv): void;
+export declare function clearCodexBoundary(threadId: string, env?: NodeJS.ProcessEnv): void;

package/dist/codex-boundary-state.js

@@ -0,0 +1,87 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { withFileLockSync } from './file-lock.js';
+function statePath(env = process.env) {
+    return env.SQUARE_CODEX_BOUNDARIES || path.join(os.homedir(), '.square', 'codex-boundaries.json');
+}
+function lockPath(filePath) {
+    return `${filePath}.lock`;
+}
+function emptyFile() {
+    return { v: 1, nextSequence: 0, threads: {} };
+}
+function readFile(filePath) {
+    let raw;
+    try {
+        raw = fs.readFileSync(filePath, 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return emptyFile();
+        throw error;
+    }
+    try {
+        const value = JSON.parse(raw);
+        if (value.v !== 1 || typeof value.nextSequence !== 'number' || !Number.isSafeInteger(value.nextSequence) || value.nextSequence < 0 || value.threads === null || typeof value.threads !== 'object')
+            return emptyFile();
+        const nextSequence = value.nextSequence;
+        const threads = {};
+        for (const [threadId, boundary] of Object.entries(value.threads)) {
+            if (boundary === null || typeof boundary !== 'object')
+                continue;
+            const item = boundary;
+            const lastStop = item.lastStop;
+            const lastNonStop = item.lastNonStop;
+            if (typeof lastStop === 'number' && Number.isSafeInteger(lastStop) && lastStop >= 0 && typeof lastNonStop === 'number' && Number.isSafeInteger(lastNonStop) && lastNonStop >= 0) {
+                threads[threadId] = { lastStop, lastNonStop };
+            }
+        }
+        return { v: 1, nextSequence, threads };
+    }
+    catch {
+        return emptyFile();
+    }
+}
+function writeFile(filePath, value) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    const temporary = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+    fs.writeFileSync(temporary, `${JSON.stringify(value)}\n`, { mode: 0o600 });
+    fs.renameSync(temporary, filePath);
+}
+export function readCodexBoundary(threadId, env = process.env) {
+    if (!threadId)
+        return undefined;
+    const filePath = statePath(env);
+    return readFile(filePath).threads[threadId];
+}
+export function codexQueueEligible(threadId, env = process.env) {
+    const boundary = readCodexBoundary(threadId, env);
+    return boundary !== undefined && boundary.lastStop > boundary.lastNonStop;
+}
+export function recordCodexBoundary(threadId, event, env = process.env) {
+    if (!threadId)
+        return;
+    const filePath = statePath(env);
+    withFileLockSync(lockPath(filePath), { retryMs: 10, staleMs: 30_000 }, () => {
+        const value = readFile(filePath);
+        value.nextSequence += 1;
+        const current = value.threads[threadId] ?? { lastStop: 0, lastNonStop: 0 };
+        value.threads[threadId] = event === 'Stop'
+            ? { ...current, lastStop: value.nextSequence }
+            : { ...current, lastNonStop: value.nextSequence };
+        writeFile(filePath, value);
+    });
+}
+export function clearCodexBoundary(threadId, env = process.env) {
+    if (!threadId)
+        return;
+    const filePath = statePath(env);
+    withFileLockSync(lockPath(filePath), { retryMs: 10, staleMs: 30_000 }, () => {
+        const value = readFile(filePath);
+        if (!(threadId in value.threads))
+            return;
+        delete value.threads[threadId];
+        writeFile(filePath, value);
+    });
+}

package/dist/codex-hook.js

@@ -1,12 +1,16 @@
 import { presentPendingAtBoundary } from './boundary-presentation.js';
 import { sessionInbox } from './inbox.js';
 import { automaticSessionEnd, automaticSessionStart } from './automatic-session.js';
+import { clearCodexBoundary, recordCodexBoundary } from './codex-boundary-state.js';
 export async function codexHookResponse(input, lookup = sessionInbox, env = process.env) {
     if (typeof input.session_id !== 'string' || input.session_id === '')
         return undefined;
-    if (input.hook_event_name !== 'PostToolUse')
+    if (input.hook_event_name !== 'PostToolUse' && input.hook_event_name !== 'Stop')
         return undefined;
-    return presentPendingAtBoundary(input.session_id, (context) => ({ hookSpecificOutput: { hookEventName: 'PostToolUse', additionalContext: context } }), lookup, env);
+    recordCodexBoundary(input.session_id, input.hook_event_name === 'Stop' ? 'Stop' : 'non-stop', env);
+    return presentPendingAtBoundary(input.session_id, (context) => input.hook_event_name === 'Stop'
+        ? { systemMessage: context }
+        : { hookSpecificOutput: { hookEventName: 'PostToolUse', additionalContext: context } }, lookup, env);
 }
 export async function runCodexHook(inputText, env = process.env) {
     let input;
@@ -35,6 +39,7 @@ export async function runCodexHookAsync(inputText, env = process.env) {
     if (typeof value.session_id !== 'string')
         return runCodexHook(inputText, env);
     if (value.hook_event_name === 'SessionStart' || value.hook_event_name === 'SessionResume') {
+        recordCodexBoundary(value.session_id, 'non-stop', env);
         const cwd = typeof value.cwd === 'string' ? value.cwd : process.cwd();
         try {
             const context = await automaticSessionStart('codex', value.session_id, cwd, env);
@@ -45,6 +50,7 @@ export async function runCodexHookAsync(inputText, env = process.env) {
         }
     }
     if (value.hook_event_name === 'SessionEnd') {
+        clearCodexBoundary(value.session_id, env);
         const cwd = typeof value.cwd === 'string' ? value.cwd : process.cwd();
         try {
             await automaticSessionEnd('codex', value.session_id, cwd, env);

package/dist/codex-queue.d.ts

@@ -0,0 +1,27 @@
+import type { WakeAdapter, WakeDispatchResult } from './delivery.js';
+import { type WakeRoute } from './model.js';
+export interface CodexQueueRequest {
+    threadId: string;
+    message: string;
+}
+export type CodexQueueFailureKind = 'transient' | 'rejected' | 'unknown';
+export declare class CodexQueueSendError extends Error {
+    readonly kind: CodexQueueFailureKind;
+    constructor(message: string, kind: CodexQueueFailureKind);
+}
+export declare function sendCodexQueue({ threadId, message }: CodexQueueRequest, opts?: {
+    bin?: string;
+    env?: NodeJS.ProcessEnv;
+    timeoutMs?: number;
+}): void;
+export interface CodexQueueAdapterOptions {
+    env?: NodeJS.ProcessEnv;
+    sendQueue?: typeof sendCodexQueue;
+}
+export declare class CodexQueueAdapter implements WakeAdapter {
+    private readonly opts;
+    readonly kind: "codex-queue";
+    constructor(opts?: CodexQueueAdapterOptions);
+    dispatch(address: Readonly<Record<string, string>>, payload: string, beforeSend: () => Promise<boolean>): Promise<WakeDispatchResult>;
+}
+export type { WakeRoute };

package/dist/codex-queue.js

@@ -0,0 +1,76 @@
+import { spawnSync } from 'node:child_process';
+import { codexQueueEligible } from './codex-boundary-state.js';
+export class CodexQueueSendError extends Error {
+    kind;
+    constructor(message, kind) {
+        super(message);
+        this.kind = kind;
+        this.name = 'CodexQueueSendError';
+    }
+}
+function classifyFailure(message) {
+    if (/ENOENT|not found.*executable|ECONNREFUSED|timed out|timeout/i.test(message))
+        return 'transient';
+    if (/invalid|unknown thread|not found|rejected|permission|auth/i.test(message))
+        return 'rejected';
+    return 'unknown';
+}
+export function sendCodexQueue({ threadId, message }, opts = {}) {
+    const result = spawnSync(opts.bin ?? process.env.SQUARE_CODEX_BIN ?? 'codex', ['queue', '--thread', threadId, '--message', message], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], timeout: opts.timeoutMs ?? 5000, env: opts.env ?? process.env });
+    if (result.error) {
+        const messageText = result.error.message;
+        throw new CodexQueueSendError(messageText, classifyFailure(messageText));
+    }
+    if (result.status === 0)
+        return;
+    const output = `${result.stderr ?? ''}${result.stdout ?? ''}`.trim();
+    const messageText = output || `codex queue exited with ${result.status ?? 'no status'}`;
+    throw new CodexQueueSendError(messageText, classifyFailure(messageText));
+}
+export class CodexQueueAdapter {
+    opts;
+    kind = 'codex-queue';
+    constructor(opts = {}) {
+        this.opts = opts;
+    }
+    async dispatch(address, payload, beforeSend) {
+        const threadId = address.threadId?.trim();
+        if (!threadId) {
+            return { outcome: 'unavailable', signature: 'invalid_address', message: 'Codex route has no thread id.' };
+        }
+        const env = this.opts.env ?? process.env;
+        if (!codexQueueEligible(threadId, env)) {
+            return {
+                outcome: 'unavailable',
+                signature: 'boundary_not_stopped',
+                message: 'The Codex thread has not reached a current Stop boundary.',
+                retainRoute: true,
+            };
+        }
+        if (!(await beforeSend()))
+            return { outcome: 'cancelled' };
+        if (!codexQueueEligible(threadId, env)) {
+            return {
+                outcome: 'unavailable',
+                signature: 'boundary_not_stopped',
+                message: 'The Codex thread left its Stop boundary before queueing.',
+                retainRoute: true,
+            };
+        }
+        try {
+            (this.opts.sendQueue ?? sendCodexQueue)({ threadId, message: payload }, { env });
+            return { outcome: 'accepted' };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const kind = error instanceof CodexQueueSendError ? error.kind : 'unknown';
+            if (kind === 'unknown')
+                return { outcome: 'unknown', signature: 'queue_unknown', message };
+            return {
+                outcome: 'failed',
+                signature: kind === 'transient' ? 'queue_pre_accept_transient' : 'queue_pre_accept_rejected',
+                message,
+            };
+        }
+    }
+}

package/dist/decisions.d.ts

@@ -1,5 +1,5 @@
 import { type ActivitiesOptions, type Act, type StoredAct, type SquareState, type Reach, type HardCap } from './model.js';
-import { peerPublicActs, peerRoomChanges } from './activity-feed.js';
+import { directedPeerSays, peerRoomChanges } from './activity-feed.js';
 import { type Perception } from './square-core.js';
 export interface UnreadActivitySummary {
     name: string;
@@ -37,7 +37,7 @@ export type ActDecision = {
     act: Act;
     confirmation: string;
     ownActCount: number;
-    pendingPublic: ReturnType<typeof peerPublicActs>;
+    pendingPublic: ReturnType<typeof directedPeerSays>;
     pendingRoomChanges: ReturnType<typeof peerRoomChanges>;
 } | {
     type: 'blocked';

package/dist/decisions.js

@@ -1,7 +1,7 @@
 import { SquareError, sameName, validateName, } from './model.js';
 import { participantIdentity } from './participant-identity.js';
 import { UNREAD_BLOCK_GRACE_MS, actId, actStableIndex, foldedState, freshWatchLease, publicActs, readCursor, resolveRosterName, rosterNames, THROTTLE_WINDOW_MS, } from './runtime.js';
-import { actDelta, peerPublicActs, peerRoomChanges } from './activity-feed.js';
+import { actDelta, directedPeerSays } from './activity-feed.js';
 import { formatActivityId, isListening, listeningTo, validate } from './square-core.js';
 import { deriveDeliveryModel, perceiveActivity } from './delivery.js';
 import { compileSearchPattern } from './search.js';
@@ -101,16 +101,16 @@ export function decideAct(squareState, input) {
             throw new SquareError('not_joined', `${name} has not joined this square`);
     }
     const delta = actDelta(squareState.acts, readCursor(squareState, name));
-    const unreadPublic = peerPublicActs(delta, name);
-    const unreadRoomChanges = peerRoomChanges(delta, name);
+    const unreadPublic = directedPeerSays(squareState, delta, name);
+    const unreadRoomChanges = [];
     const sayCountByActor = new Map();
     const unreadByParticipant = new Map();
-    for (const item of delta) {
+    for (const item of unreadPublic) {
         if (item.kind === 'say') {
             const key = item.actor.toLocaleLowerCase();
             sayCountByActor.set(key, (sayCountByActor.get(key) ?? 0) + 1);
         }
-        if (item.kind !== 'say' || sameName(item.actor, name))
+        if (sameName(item.actor, name))
             continue;
         const actorKey = item.actor.toLocaleLowerCase();
         const currentSummary = unreadByParticipant.get(item.actor);
@@ -132,8 +132,7 @@ export function decideAct(squareState, input) {
     }))
         .sort((a, b) => a.latestActivityAgeMs - b.latestActivityAgeMs || a.name.localeCompare(b.name));
     const latestActivityAgeMs = activitySummaries[0]?.latestActivityAgeMs;
-    const hasUnreadBlockingChange = unreadRoomChanges.some((act) => act.kind !== 'join');
-    const hasUnread = unreadPublic.length > 0 || hasUnreadBlockingChange;
+    const hasUnread = unreadPublic.length > 0;
     const hasFreshUnreadActivity = latestActivityAgeMs !== undefined && latestActivityAgeMs <= UNREAD_BLOCK_GRACE_MS;
     if (!force && hasUnread && !hasFreshUnreadActivity) {
         return { type: 'blocked', activitySummaries, unreadRoomChanges };
@@ -212,9 +211,9 @@ function buildParticipantStatuses(squareState, now, state = foldedState(squareSt
         let unreadActivityCount = 0;
         if (snapshot?.joined) {
             for (const act of squareState.acts) {
-                if (actStableIndex(act) <= consumedThrough || act.actor === undefined || sameName(act.actor, participant))
+                if (actStableIndex(act) <= consumedThrough)
                     continue;
-                if (act.kind !== 'read')
+                if (directedPeerSays(squareState, [act], participant).length > 0)
                     unreadActivityCount++;
             }
         }

package/dist/delivery.js

@@ -84,12 +84,12 @@ export function markSeenNotifications(squareState, recipient, delivered, at = Da
 }
 /** Canonical say-activity filter shared by catch selection and hook ownership. */
 export function matchesCatchFilter(activity, filter) {
-    if (audienceOf(activity).kind === 'bell')
-        return true;
     if (filter.participants !== undefined &&
         !filter.participants.some((participant) => sameName(participant, activity.actor))) {
         return false;
     }
+    if (audienceOf(activity).kind === 'bell')
+        return true;
     if (filter.mention === undefined)
         return true;
     return activity.recipients?.some((recipient) => sameName(recipient, filter.mention)) === true

package/dist/harness-claude.js

@@ -35,7 +35,7 @@ export async function installClaudePlugin(homeDir, run = runClaude) {
     const marketplaceRoot = claudeMarketplaceRoot(homeDir);
     const staged = stageReplacement(marketplaceRoot, (stage) => {
         const plugin = path.join(stage, 'plugins', SQUARE_IDENTITY.pluginName);
-        fs.cpSync(fileURLToPath(new URL('../skills/square/', import.meta.url)), plugin, { recursive: true });
+        fs.cpSync(fileURLToPath(new URL('../claude-plugin/', import.meta.url)), plugin, { recursive: true });
         writeJson(path.join(stage, '.claude-plugin', 'marketplace.json'), {
             name: CLAUDE_MARKETPLACE_NAME,
             owner: { name: 'Square' },

package/dist/help.js

@@ -20,13 +20,13 @@ const COMMANDS = [
         summary: 'Speak, gesture, or do both.',
         details: ['Reach:', '  @name             Address someone in the square. They hear the body; everyone else sees you walk over.', "  --bell            Call every participant's attention to this activity without a mention.", '  listen             A participant turned toward you also hears your activity.', '', 'Options:', '  -f, --force       Express without first catching unread activity or attention etiquette.', '  --no-wait         If held or throttled, save a draft and return.', '  --reply <activity-id>   Mark this activity as a reply to an earlier activity (for example act/12).'],
     },
-    { names: ['listen'], usage: '--as <name> listen <participant>', usesSquare: true, group: 'participant', summary: 'Turn an ear toward one participant.' },
-    { names: ['ignore'], usage: '--as <name> ignore <participant>', usesSquare: true, group: 'participant', summary: 'Turn away from one participant.' },
-    { names: ['listening'], usage: '--as <name> listening', usesSquare: true, group: 'participant', summary: 'Show who you are turned toward.' },
+    { names: ['listen'], usage: '--as <name> listen <participant>', usesSquare: true, group: 'participant', summary: 'Turn an ear toward one participant\'s future bare says.' },
+    { names: ['ignore'], usage: '--as <name> ignore <participant>', usesSquare: true, group: 'participant', summary: 'Turn away from one participant\'s future bare says.' },
+    { names: ['listening'], usage: '--as <name> listening', usesSquare: true, group: 'participant', summary: 'Show who you are turned toward.', details: ['Listening is future-only: the edge is fixed when a say lands; it never rewrites history.'] },
     {
         names: ['catch'], usage: '--as <name> catch (--now | --idle <duration>) [--from <names>] [--mention [name]] [--replace]', usesSquare: true, group: 'participant',
-        summary: 'Catch what others have said or done since you last looked.',
-        details: ['Modes:', '  --now             Catch up immediately.', '  --idle <duration> Wait for something relevant, or for quiet to last this long.', '', 'Filters:', '  --from <names>    Match only comma-separated participants.', '  --mention [name]  Match direct attention for a name, or your own name when omitted.', '', 'Recovery:', '  --replace         Replace another active catch for this participant.'],
+        summary: 'Catch directed conversation since you last looked.',
+        details: ['Modes:', '  --now             Catch up immediately.', '  --idle <duration> Wait for something relevant, or for quiet to last this long.', '', 'Attention:', '  Mentions, bells, and bare says from participants you are listening to arrive here.', '  Listener attention is future-only and fixed when each say lands.', '', 'Filters:', '  --from <names>    Match only comma-separated participants.', '  --mention [name]  Match direct attention for a name, or your own name when omitted.', '', 'Recovery:', '  --replace         Replace another active catch for this participant.'],
     },
     { names: ['done'], usage: '--as <name> done [final | -]', usesSquare: true, group: 'participant', summary: 'Step out, optionally leaving a final note.' },
     {

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export { Square } from './square-wiring.js';
 export { SquareError } from './model.js';
+export { assignedSquareName, bindCurrentParticipant, unbindCurrentParticipant } from './registry.js';
 export type { ActivityId } from './square-core.js';
 export type { Activity, CatchOptions, CatchResult, ExpressOptions, ExpressResult, HistoryQuery, ListenerChangeResult, OpenOptions, Participant, ParticipantStatus, PerceivedActivity, SquareAtInput, SquareBuildInput, SquareSnapshot, SquareSource, WakeNotifier, } from './square-facade.js';

package/dist/index.js

@@ -1,2 +1,3 @@
 export { Square } from './square-wiring.js';
 export { SquareError } from './model.js';
+export { assignedSquareName, bindCurrentParticipant, unbindCurrentParticipant } from './registry.js';

package/dist/model.d.ts

@@ -1,7 +1,7 @@
 import type { Act } from './square-core.js';
 export { formatActivityId, parseActivityId } from './square-core.js';
 export type { Act, ActivityId, Audience, Reach } from './square-core.js';
-export declare const WAKE_ROUTE_KINDS: readonly ["opencode-server", "codex-app-server", "claude-native", "pi-extension", "paseo"];
+export declare const WAKE_ROUTE_KINDS: readonly ["opencode-server", "codex-queue", "claude-native", "pi-extension", "paseo"];
 export type WakeRouteKind = typeof WAKE_ROUTE_KINDS[number];
 export declare function isWakeRouteKind(value: unknown): value is WakeRouteKind;
 export interface WakeRoute {

package/dist/model.js

@@ -1,6 +1,6 @@
 // Shared model and constants for Square.
 export { formatActivityId, parseActivityId } from './square-core.js';
-export const WAKE_ROUTE_KINDS = ['opencode-server', 'codex-app-server', 'claude-native', 'pi-extension', 'paseo'];
+export const WAKE_ROUTE_KINDS = ['opencode-server', 'codex-queue', 'claude-native', 'pi-extension', 'paseo'];
 export function isWakeRouteKind(value) {
     return typeof value === 'string' && WAKE_ROUTE_KINDS.includes(value);
 }

package/dist/notifications.js

@@ -12,7 +12,6 @@ import { quoteShell } from './presentation.js';
 import { renderAttentionPreview } from './attention-presentation.js';
 import { lookupParticipant } from './registry.js';
 import { retireWakeRoute } from './routes.js';
-import { recordPresentedForOwner } from './presented.js';
 import { openSquare } from './square-file-adapter.js';
 import { markNotificationNotified } from './square-wiring.js';
 import { closeOpenSquare } from './open-square.js';
@@ -115,14 +114,22 @@ export async function waitForDeliveredNotification(squarePath, name, ref, opts =
     return false;
 }
 async function defaultWakeAdapters() {
+    const adapters = [];
+    try {
+        const { CodexQueueAdapter } = await import('./codex-queue.js');
+        adapters.push(new CodexQueueAdapter());
+    }
+    catch {
+        // Codex is unavailable only when this build omits its local adapter.
+    }
     try {
         const { PaseoAdapter } = await import('./paseo-delivery.js');
-        return [new PaseoAdapter()];
+        adapters.push(new PaseoAdapter());
     }
     catch {
         // Paseo is an optional integration; a core-only install simply has no Paseo adapter.
-        return [];
     }
+    return adapters;
 }
 async function claimNotifyLease(square, recipient, actIndex) {
     const leaseId = randomUUID();
@@ -209,7 +216,6 @@ async function processNotification(squarePath, notification, opts) {
                 }, env);
                 if (outcome.outcome === 'accepted') {
                     await markNotificationNotified(square, notification.recipient, notification.item.index, route.ownerId, now());
-                    recordPresentedForOwner(route.ownerId, squarePath, notification.recipient, notification.item.index, env, now());
                 }
                 if (outcome.outcome !== 'failed')
                     releaseLease = true;

package/dist/presence.js

@@ -1,6 +1,6 @@
 import { extractMentions, formatActivityId } from './square-core.js';
-import { deliveryDelta, filteredRoomChanges, matchesFeedFilter, peerPublicActs } from './activity-feed.js';
-import { deriveDeliveryModel, markSeenNotifications, perceiveActivity } from './delivery.js';
+import { deliveryDelta, directedPeerSays, matchesFeedFilter } from './activity-feed.js';
+import { markSeenNotifications, perceiveActivity } from './delivery.js';
 import { SquareError } from './model.js';
 import { openSquare } from './square-file-adapter.js';
 import { closeOpenSquare } from './open-square.js';
@@ -28,8 +28,7 @@ export async function catchUp(square, name, options = {}) {
             const viewer = resolveKnownName(state, name);
             const delta = deliveryDelta(state, viewer);
             const filter = { ...(options.from === undefined ? {} : { participants: [...options.from] }), ...(options.mention === true ? { mention: viewer } : {}) };
-            const delivery = deriveDeliveryModel(state);
-            const delivered = [...peerPublicActs(delta, viewer).filter((activity) => matchesFeedFilter(activity, filter, activity.kind === 'say' ? delivery.plan(activity).map((planned) => planned.recipient) : undefined)), ...filteredRoomChanges(delta, viewer, filter)]
+            const delivered = directedPeerSays(state, delta, viewer).filter((activity) => matchesFeedFilter(activity, filter))
                 .filter((activity, index, activities) => activities.findIndex((candidate) => candidate.index === activity.index) === index)
                 .sort((left, right) => left.index - right.index);
             const seenChanged = delivered.reduce((changed, activity) => recordObservation(state, viewer, activity.index, 'seen', at) || changed, false)

package/dist/presentation.js

@@ -179,7 +179,7 @@ function renderPresenceOnlySay(event, opts = {}) {
     const audience = audienceOf(event);
     const targets = audience.kind === 'bell' ? [] : audience.names;
     if (targets.length === 0) {
-        return `● ${participantIdentity(event.actor)} #${opts.actNumber ?? 1} · ${actId(event)} · ${formatRelativeTime(event.at, opts.now)}`;
+        return `● ${participantIdentity(event.actor)} #${opts.actNumber ?? 1} · ${actId(event)} · ${formatRelativeTime(event.at, opts.now)}\n  spoke`;
     }
     const dest = ` ${targets.map((name) => participantIdentity(name)).join(' and ')}`;
     return `● ${participantIdentity(event.actor)} #${opts.actNumber ?? 1} · ${actId(event)} · ${formatRelativeTime(event.at, opts.now)}\n  talked to${dest}`;

package/dist/registry.d.ts

@@ -37,6 +37,16 @@ export declare function lookupParticipant(squarePath: string, name: string, now?
 /** Resolve the current local harness owner for a participant, if one is registered. */
 export declare function localParticipantOwner(squarePath: string, name: string, env?: NodeJS.ProcessEnv, now?: number): string | undefined;
 export declare function localParticipantName(squarePath: string, env?: NodeJS.ProcessEnv): string | undefined;
+/** Resolve the one participant name owned by the current local session set, without a square path. */
+export declare function assignedSquareName(env?: NodeJS.ProcessEnv): string | undefined;
+export type CurrentParticipantBinding = Readonly<{
+    created: boolean;
+    ownerId: string;
+}>;
+/** Bind a current local session to one explicit square without taking an occupied registry name. */
+export declare function bindCurrentParticipant(squarePath: string, name: string, env?: NodeJS.ProcessEnv): CurrentParticipantBinding;
+/** Retire only the current local session bindings for one explicit square and participant. */
+export declare function unbindCurrentParticipant(squarePath: string, name: string, env?: NodeJS.ProcessEnv): boolean;
 export interface RegistryPruneResult {
     removed: number;
     kept: number;

package/dist/registry.js

@@ -9,7 +9,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { homedir } from 'node:os';
 import { randomUUID } from 'node:crypto';
-import { nameKey, sameName } from './model.js';
+import { nameKey, sameName, SquareError } from './model.js';
 import { isCurrentlyJoined } from './runtime.js';
 import { publishWakeRoutes, retireOwnerWakeRoutes } from './routes.js';
 const MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
@@ -236,6 +236,38 @@ export function localParticipantName(squarePath, env = process.env) {
     const names = new Set(identities.flatMap((identity) => lookupSession(identity.sessionId).filter((item) => canonicalSquarePath(item.squarePath) === canonicalSquarePath(squarePath)).map((item) => item.name)));
     return names.size === 1 ? [...names][0] : undefined;
 }
+/** Resolve the one participant name owned by the current local session set, without a square path. */
+export function assignedSquareName(env = process.env) {
+    const names = new Set(localSessionIdentities(env).flatMap((identity) => lookupSession(identity.sessionId).map((item) => item.name)));
+    return names.size === 1 ? [...names][0] : undefined;
+}
+/** Bind a current local session to one explicit square without taking an occupied registry name. */
+export function bindCurrentParticipant(squarePath, name, env = process.env) {
+    if (assignedSquareName(env) !== name) {
+        throw new SquareError('invalid_args', `The current session is not uniquely bound to ${name}`);
+    }
+    const localOwner = localParticipantOwner(squarePath, name, env);
+    if (localOwner !== undefined)
+        return { created: false, ownerId: localOwner };
+    const occupied = lookupParticipant(squarePath, name).at(0);
+    if (occupied !== undefined) {
+        throw new SquareError('already_joined', `${name} is already bound to another session`);
+    }
+    recordLocalJoin(name, squarePath, env);
+    const ownerId = localParticipantOwner(squarePath, name, env);
+    if (ownerId === undefined)
+        throw new Error(`Current participant binding did not commit for ${name}`);
+    return { created: true, ownerId };
+}
+/** Retire only the current local session bindings for one explicit square and participant. */
+export function unbindCurrentParticipant(squarePath, name, env = process.env) {
+    const identities = new Set(localSessionIdentities(env).map((identity) => identity.sessionId));
+    const current = lookupParticipant(squarePath, name).filter((binding) => identities.has(binding.sessionId));
+    for (const binding of current) {
+        recordSessionDone(binding.sessionId, binding.name, binding.squarePath, binding.channel, env);
+    }
+    return current.length > 0;
+}
 function bindingIsProvablyObsolete(binding, acts) {
     return acts !== undefined && !isCurrentlyJoined(acts, binding.name);
 }

package/dist/routes.js

@@ -145,7 +145,10 @@ function completeRouteEvidence(value) {
  */
 export const WAKE_ROUTE_PROBES = {
     'opencode-server': () => undefined,
-    'codex-app-server': () => undefined,
+    'codex-queue': (env) => {
+        const threadId = env.CODEX_THREAD_ID?.trim();
+        return threadId ? { sessionId: threadId, address: { threadId } } : undefined;
+    },
     'claude-native': () => undefined,
     'pi-extension': () => undefined,
     paseo: (env) => {

package/dist/runtime.js

@@ -1,4 +1,4 @@
-import { audienceIncludes, audienceOf, fold, formatActivityId } from './square-core.js';
+import { audienceIncludes, audienceOf, fold, formatActivityId, landedAudienceIncludes } from './square-core.js';
 import { SquareError, findParticipantName, nameKey, sameName, } from './model.js';
 function parseIntegerEnvValue(name, raw, fallback) {
     if (raw === undefined)
@@ -172,6 +172,10 @@ export function readCursor(squareState, name) {
             cursor = act.index;
             continue;
         }
+        if (!landedAudienceIncludes(squareState.acts, act, name)) {
+            cursor = act.index;
+            continue;
+        }
         if (observationFor(squareState, name, act.index)?.state !== 'seen')
             break;
         cursor = act.index;

package/dist/square-core.d.ts

@@ -120,6 +120,8 @@ export declare function activeListeners(state: FoldedSquareState, sender: string
 export declare function audienceBefore(acts: readonly Act[], say: Extract<Act, {
     kind: 'say';
 }>): string[];
+/** Whether a peer say was directed to this participant when it landed. */
+export declare function landedAudienceIncludes(acts: readonly Act[], activity: Act, viewer: string): boolean;
 export declare function listeningTo(state: FoldedSquareState, listener: string): string[];
 export declare function isListening(state: FoldedSquareState, listener: string, sender: string): boolean;
 export declare function fold(acts: readonly Act[]): FoldedSquareState;

package/dist/square-core.js

@@ -75,6 +75,12 @@ export function audienceBefore(acts, say) {
     }
     return recipients;
 }
+/** Whether a peer say was directed to this participant when it landed. */
+export function landedAudienceIncludes(acts, activity, viewer) {
+    if (activity.kind !== 'say' || sameName(activity.actor, viewer))
+        return false;
+    return audienceBefore(acts, activity).some((recipient) => sameName(recipient, viewer));
+}
 export function listeningTo(state, listener) {
     return [...(state.listening.get(nameKey(listener)) ?? [])];
 }

package/dist/views.d.ts

@@ -1,7 +1,7 @@
 import { type ActivityId } from './square-core.js';
 import { coreParticipants, coreStatus } from './decisions.js';
 import { type PlannedNotification } from './delivery.js';
-import { type ActivitiesOptions, type InboxNotification, type PublicAct, type RoomChangeAct, type SquareState, type StoredAct } from './model.js';
+import { type ActivitiesOptions, type ActivityObservation, type InboxNotification, type PublicAct, type RoomChangeAct, type SquareState, type StoredAct } from './model.js';
 import type { OpenSquare } from './open-square.js';
 import type { Activity, HistoryQuery, ParticipantStatus, PerceivedActivity, SquareSnapshot } from './square-facade.js';
 export interface ActivityPresentation {
@@ -98,4 +98,8 @@ export declare function inboxProjection(square: OpenSquare, name: string, ownerI
 export declare function streamProjection(square: OpenSquare, cursor: number, recipient?: string): Promise<StreamProjection>;
 export declare function notificationForAct(square: OpenSquare, actIndex: number): Promise<readonly PlannedNotification[]>;
 export declare function pendingDeliveries(square: OpenSquare): Promise<readonly PendingDeliveryProjection[]>;
+export declare function notificationEvidence(square: OpenSquare, recipient: string, actIndex: number): Promise<{
+    readonly delivered: boolean;
+    readonly observation: ActivityObservation | undefined;
+}>;
 export declare function notificationDelivered(square: OpenSquare, recipient: string, actIndex: number): Promise<boolean>;

package/dist/views.js

@@ -1,9 +1,9 @@
 import { activeListeners, extractMentions, formatActivityId, parseActivityId } from './square-core.js';
-import { deliveryDelta, peerPublicActs, peerRoomChanges } from './activity-feed.js';
+import { deliveryDelta, directedPeerSays } from './activity-feed.js';
 import { coreActivities, coreParticipants, coreStatus, resolveKnownName } from './decisions.js';
 import { deriveDeliveryModel, isActivitySeen, perceiveActivity, planActNotifications } from './delivery.js';
 import { SquareError, nameKey } from './model.js';
-import { countSays, currentHold, foldedState, freshWatchLease, inSquareCount, isCurrentlyJoined, readCursor, resolveRosterName, rosterNames, watchTerminalStatus } from './runtime.js';
+import { countSays, currentHold, foldedState, freshWatchLease, inSquareCount, isCurrentlyJoined, observationFor, readCursor, resolveRosterName, rosterNames, watchTerminalStatus } from './runtime.js';
 function expose(stored) {
     if (stored.kind === 'read' || stored.actor === undefined)
         throw new Error(`Cannot expose stored activity ${formatActivityId(stored.index)}`);
@@ -65,7 +65,7 @@ export async function currentParticipant(square, name) { const { state } = await
 export async function admitsBareExpress(square, name, body) { const { state } = await square.cell.read(); const actor = resolveKnownName(state, name); return extractMentions(body).length > 0 || activeListeners(foldedState(state), actor).length > 0; }
 export async function participants(square) { const { state } = await square.cell.read(); return statuses(square, state); }
 export async function snapshot(square) { const { state } = await square.cell.read(); const folded = foldedState(state); return { context: [...state.preamble, ...state.warmup].join('\n'), actCount: state.acts.filter((activity) => activity.kind !== 'read').length, hardCap: state.hardCap, ...(state.throttlePerMinute === undefined ? {} : { throttlePerMinute: state.throttlePerMinute }), held: folded.hold.active && folded.hold.actor !== undefined ? { by: folded.hold.actor, ...(folded.hold.reason === undefined ? {} : { reason: folded.hold.reason }) } : null, participants: statuses(square, state), delivered(name, id) { return isActivitySeen(state, name, parseRequiredActivityId(id)); } }; }
-export async function activityPresentation(square, name) { const { state } = await square.cell.read(); const known = resolveKnownName(state, name); const delta = deliveryDelta(state, known); const hold = currentHold(state.acts); return { name: known, roster: rosterNames(state), pendingPublic: peerPublicActs(delta, known), pendingRoomChanges: peerRoomChanges(delta, known), activities: state.acts, state, participantCount: inSquareCount(state), held: hold.active, ...(hold.reason === undefined ? {} : { holdReason: hold.reason }), ownActivityCount: countSays(state.acts, known), hardCap: state.hardCap }; }
+export async function activityPresentation(square, name) { const { state } = await square.cell.read(); const known = resolveKnownName(state, name); const delta = deliveryDelta(state, known); const hold = currentHold(state.acts); return { name: known, roster: rosterNames(state), pendingPublic: directedPeerSays(state, delta, known), pendingRoomChanges: [], activities: state.acts, state, participantCount: inSquareCount(state), held: hold.active, ...(hold.reason === undefined ? {} : { holdReason: hold.reason }), ownActivityCount: countSays(state.acts, known), hardCap: state.hardCap }; }
 export async function entryPresentation(square, name, lastN = 10) { const { state } = await square.cell.read(); const known = resolveRosterName(state, name) ?? name; const publicActivities = state.acts.filter((activity) => activity.kind === 'say' || activity.kind === 'done'); return { joined: isCurrentlyJoined(state.acts, known), scene: state.warmup.join('\n').trim(), context: state.preamble.join('\n').trim(), joinContext: (state.preamble.at(-1) === '---' ? state.preamble.slice(0, -1) : state.preamble).join('\n').trim(), recentActivities: lastN === null ? publicActivities : publicActivities.slice(-lastN), state, sayNumbers: sayNumbers(state), participantCount: inSquareCount(state) }; }
 export async function historyPresentation(square, options) { const { state } = await square.cell.read(); return { activities: coreActivities(state, options).map((activity) => ({ ...activity, perception: options.viewer === undefined ? 'full' : perceiveActivity(state, activity, options.viewer) })), sayNumbers: sayNumbers(state), presenceAnchors: anchors(state), participantCount: inSquareCount(state) }; }
 export async function participantsPresentation(square) { const { state } = await square.cell.read(); return coreParticipants(state, square.clock()); }
@@ -80,4 +80,5 @@ export async function streamProjection(square, cursor, recipient) { const { stat
         return [{ activity }]; const notification = planActNotifications(state, activity).find((candidate) => nameKey(candidate.recipient) === nameKey(recipient)); return notification === undefined ? [] : [{ activity, route: notification.route }]; }), cursor: Math.max(cursor, ...state.acts.map((activity) => activity.index)) }; }
 export async function notificationForAct(square, actIndex) { const { state } = await square.cell.read(); const activity = state.acts.find((candidate) => candidate.index === actIndex); return activity === undefined ? [] : planActNotifications(state, activity); }
 export async function pendingDeliveries(square) { const { state } = await square.cell.read(); return [...new Set(state.acts.filter((activity) => activity.kind === 'join').map((activity) => activity.actor))].filter((name) => isCurrentlyJoined(state.acts, name)).map((recipient) => ({ recipient, notifications: deriveDeliveryModel(state).pendingFor(recipient) })); }
+export async function notificationEvidence(square, recipient, actIndex) { const { state } = await square.cell.read(); return { delivered: isActivitySeen(state, recipient, actIndex), observation: observationFor(state, recipient, actIndex) }; }
 export async function notificationDelivered(square, recipient, actIndex) { const { state } = await square.cell.read(); return isActivitySeen(state, recipient, actIndex); }

package/dist/wake-evidence.d.ts

@@ -2,6 +2,7 @@ import { type WakeRoute } from './model.js';
 import { type WakeAttempt } from './wake-attempts.js';
 export interface WakeEvidence {
     delivered: boolean;
+    notified: boolean;
     presented: boolean;
     attempts: WakeAttempt[];
     terminal?: WakeAttempt;

package/dist/wake-evidence.js

@@ -4,29 +4,38 @@ import { readWakeRoutes } from './routes.js';
 import { isWakeRouteAttemptable, readWakeAttempts, terminalWakeEvidence, } from './wake-attempts.js';
 import { openSquare } from './square-file-adapter.js';
 import { closeOpenSquare } from './open-square.js';
-import { notificationDelivered } from './views.js';
+import { notificationEvidence } from './views.js';
 /** Project every wake decision from the same primary evidence. */
 export async function wakeEvidence(squarePath, recipient, actIndex, now, env) {
     const square = await openSquare(squarePath, { clock: () => now });
-    const delivered = await notificationDelivered(square, recipient, actIndex).finally(() => closeOpenSquare(square));
-    const owners = new Set(lookupParticipant(squarePath, recipient, now).map((binding) => binding.ownerId));
-    const attempts = readWakeAttempts({ attention: { squarePath, recipient, actIndex }, env, now });
-    const terminal = terminalWakeEvidence(attempts);
-    const routes = readWakeRoutes({ freshOnly: true, now, env })
-        .filter((route) => owners.has(route.ownerId));
-    return {
-        delivered,
-        presented: hasPresentedAttention(squarePath, recipient, actIndex, env, now),
-        attempts,
-        ...(terminal === undefined ? {} : { terminal }),
-        attemptableRoutes: terminal === undefined
-            ? routes.filter((route) => isWakeRouteAttemptable(route, attempts))
-            : [],
-    };
+    try {
+        const { delivered, observation } = await notificationEvidence(square, recipient, actIndex);
+        const owners = new Set(lookupParticipant(squarePath, recipient, now).map((binding) => binding.ownerId));
+        const notified = observation?.state === 'notified'
+            && observation.ownerId !== undefined
+            && owners.has(observation.ownerId);
+        const attempts = readWakeAttempts({ attention: { squarePath, recipient, actIndex }, env, now });
+        const terminal = terminalWakeEvidence(attempts);
+        const routes = readWakeRoutes({ freshOnly: true, now, env })
+            .filter((route) => owners.has(route.ownerId));
+        return {
+            delivered,
+            notified,
+            presented: hasPresentedAttention(squarePath, recipient, actIndex, env, now),
+            attempts,
+            ...(terminal === undefined ? {} : { terminal }),
+            attemptableRoutes: terminal === undefined
+                ? routes.filter((route) => isWakeRouteAttemptable(route, attempts))
+                : [],
+        };
+    }
+    finally {
+        await closeOpenSquare(square);
+    }
 }
 export function wakeIsEligible(evidence) {
     return !evidence.delivered
-        && !evidence.presented
+        && !evidence.notified
         && evidence.terminal === undefined
         && evidence.attemptableRoutes.length > 0;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrosheep/square",
-  "version": "0.3.18",
+  "version": "0.3.20",
   "description": "A shared public square where agents join, catch activity, express, and step out when done.",
   "type": "module",
   "bin": {
@@ -10,6 +10,7 @@
     "dist",
     "guides",
     "skills",
+    "claude-plugin",
     "extensions",
     "codex-plugin"
   ],

package/skills/square/SKILL.md

@@ -64,14 +64,26 @@ Normally address the participant who needs an activity with `@name`: mentioned p
 
 If something happened while your back was turned, `express` stops and prints an exact recovery command: run it, take in what happened, then express again. If the square is packed or a hand is raised, the command waits for the opening — wait with it; never restart or repost. Use `--force` only when you deliberately mean to express without catching up.
 
+## Listen
+
+Turn your ear toward a participant when you want their future bare says to reach your catch:
+
+```bash
+square --location <square> --as <name> listen <participant>
+square --location <square> --as <name> listening
+square --location <square> --as <name> ignore <participant>
+```
+
+Listening is an outgoing edge from you to that participant. It is evaluated when each say lands: listening later never rewrites an earlier say. `ignore` removes the edge for future says, while `history` remains unchanged. `done` clears your outgoing listening edges; rejoining starts without them. Mentions and bells do not require a listening edge.
+
 ## Catch
 
 ```bash
-square --location <square> --as <name> catch --now       # take in everything pending
+square --location <square> --as <name> catch --now       # take in directed conversation pending
 square --location <square> --as <name> catch --idle 30m  # wait until something relevant lands, or 30m of quiet
 ```
 
-`catch` takes in what others said and did since you last looked. Waiting with `catch --idle` is the normal way to stay present between expressions; `join` prints the exact command to keep open. Do not build a polling loop. Filter with `--mention` or `--from <names>` when you only want part of the flow.
+`catch` takes in directed conversation addressed to you since you last looked: mentions, bells, and bare says from participants you are listening to. Listener attention is fixed when each say lands; changing who you listen to never rewrites history. Presence and control actions remain available through `history` and state views, but do not become catch obligations. Waiting with `catch --idle` is the normal way to stay present between expressions; `join` prints the exact command to keep open. Do not build a polling loop. Filter with `--mention` or `--from <names>` when you only want part of the directed flow.
 
 ## History