@astrosheep/square 0.3.79 → 0.3.81

package/dist/artifact.js

@@ -9,7 +9,7 @@ import { observeFileVersion } from './file-changes.js';
 import { canonicalPath } from './canonical-path.js';
 import { InternalSquareError, SquareError } from './model.js';
 import { wrapSquareWrite } from './square-domain.js';
-import { APPLICATION_ID, createSqliteDriver, initializeSqlite, exportSqliteState, inspectSqlite, invalidArtifact, validateSqliteHeader, emptyRuntimeState } from './square-sqlite.js';
+import { APPLICATION_ID, CURRENT_USER_VERSION, createSqliteDriver, initializeSqlite, exportSqliteState, inspectSqlite, invalidArtifact, validateSqliteHeader, emptyRuntimeState } from './square-sqlite.js';
 const guideContents = new Map();
 function readGuide(name) {
     if (!['participant', 'architect', 'brainstorm'].includes(name))
@@ -107,7 +107,7 @@ export function createArtifactPort(location, initial, externalSignal) {
         database = new DatabaseSync(':memory:');
         try {
             initializeSqlite(database, initial);
-            database.exec(`PRAGMA application_id=${APPLICATION_ID}; PRAGMA user_version=2`);
+            database.exec(`PRAGMA application_id=${APPLICATION_ID}; PRAGMA user_version=${CURRENT_USER_VERSION}`);
         }
         catch (error) {
             database.close();
@@ -270,7 +270,7 @@ async function initializeFile(location, state, signal) {
         db.exec('PRAGMA journal_mode=DELETE; PRAGMA synchronous=FULL');
         await inSqliteTransaction(db, true, () => { }, () => {
             initializeSqlite(db, state);
-            db.exec(`PRAGMA application_id=${APPLICATION_ID}; PRAGMA user_version=2`);
+            db.exec(`PRAGMA application_id=${APPLICATION_ID}; PRAGMA user_version=${CURRENT_USER_VERSION}`);
         }, signal);
     }
     finally {

package/dist/cli/context.js

@@ -93,6 +93,7 @@ const LOCATION_REQUIRED_COMMANDS = new Set([
     'express',
     'listen',
     'ignore',
+    'unlisten',
     'listening',
     'done',
     'hold',

package/dist/cli/express-presentation.js

@@ -81,7 +81,7 @@ export async function executeExpression(open, squarePath, requestedName, rawInpu
         name = participant.name;
         attempted = true;
         const outcome = await participant.express(rawInput.replace(/\r\n/g, '\n').trim(), {
-            ...opts, reply: opts.reply, requireExplicitReach: true, observe: true,
+            ...opts, reply: opts.reply, observe: true,
         }, {
             signal: controller.signal,
             onProgress(progress) {
@@ -150,15 +150,13 @@ export async function executeExpression(open, squarePath, requestedName, rawInpu
         }
         const facts = isSquareError(error) ? error.facts : undefined;
         const reason = facts?.reason;
-        const message = reason === 'explicit_reach_required'
-            ? '✕ express needs --mention <name>, --no-mention, --bell, or an @name in the body\n  · --reply <activity-id> also reaches the author it answers'
-            : reason === 'bell_mention_conflict'
-                ? '✕ a bell cannot be combined with a mention'
-                : reason === 'invalid_reply'
-                    ? facts?.activityExists === false
-                        ? `Invalid --reply: ${facts.activityId ?? opts.reply ?? 'that activity'} is not in this square's history`
-                        : 'Invalid --reply: expected an activity id like act/12'
-                    : refusalText(error);
+        const message = reason === 'bell_mention_conflict'
+            ? '✕ a bell cannot be combined with a mention'
+            : reason === 'invalid_reply'
+                ? facts?.activityExists === false
+                    ? `Invalid --reply: ${facts.activityId ?? opts.reply ?? 'that activity'} is not in this square's history`
+                    : 'Invalid --reply: expected an activity id like act/12'
+                : refusalText(error);
         const lines = [message, `· draft kept: ${draftPath}`];
         const repair = reason === 'bell_mention_conflict' || (reason === 'not_standing' && detail?.subject === 'recipient');
         if (isSquareError(error)) {
@@ -170,7 +168,7 @@ export async function executeExpression(open, squarePath, requestedName, rawInpu
             if (repair) {
                 lines.push(participantsRecoveryCommand(squarePath), reason === 'bell_mention_conflict'
                     ? '  · ring the bell without explicit mentions:'
-                    : '  · pick someone standing here, or land it bare:', `${activityRetryCommand(squarePath, name, { ...opts, mentions: [], noMention: opts.reach === 'bell' ? opts.noMention : true })} < ${quoteShell(draftPath)}`);
+                    : '  · retry without explicit recipients:', `${activityRetryCommand(squarePath, name, { ...opts, mentions: [] })} < ${quoteShell(draftPath)}`);
             }
             else if (error.code === 'invalid_args' || error.code === 'invalid_name') {
                 if (opts.mentions?.length)
@@ -179,13 +177,9 @@ export async function executeExpression(open, squarePath, requestedName, rawInpu
                     lines.push(`${commandPrefix(squarePath)} history --limit 10`);
             }
         }
-        if (reason === 'explicit_reach_required') {
-            lines.push('  · choose someone with --mention <name>, or send without addressing anyone:', `${activityRetryCommand(squarePath, name, { ...opts, noMention: true })} < ${quoteShell(draftPath)}`);
-        }
-        else if (reason === 'invalid_reply') {
-            const needsBareReach = facts?.hasReachWithoutReply === false;
-            const withoutReply = { ...opts, reply: undefined, ...(needsBareReach ? { noMention: true } : {}) };
-            lines.push(`${commandPrefix(squarePath)} history --limit 10`, '  · choose a valid --reply from history, or send without a reply using this repair:', ...(needsBareReach ? ['  · this repair is bare; replace --no-mention with --mention <name> to address someone'] : []), `${activityRetryCommand(squarePath, name, withoutReply)} < ${quoteShell(draftPath)}`);
+        if (reason === 'invalid_reply') {
+            const withoutReply = { ...opts, reply: undefined };
+            lines.push(`${commandPrefix(squarePath)} history --limit 10`, '  · choose a valid --reply from history, or send without a reply using this repair:', `${activityRetryCommand(squarePath, name, withoutReply)} < ${quoteShell(draftPath)}`);
         }
         else if (!repair) {
             lines.push('  · correct the problem above before retrying; keep your intended recipients and reply:', `${retryCommand} < ${quoteShell(draftPath)}`);

package/dist/cli/maintenance-commands.js

@@ -12,10 +12,10 @@ export const migrateCommand = {
         const outcome = await migrateSquare(squareInput(context));
         const body = outcome.status === 'migrated' && outcome.counts !== undefined
             ? [
-                '✓ migrated to row storage',
+                '✓ migrated to current row storage',
                 `  · ${outcome.counts.activities} activities · ${outcome.counts.receipts} receipts · ${outcome.counts.leases} leases · ${outcome.counts.routes} routes`,
             ].join('\n')
-            : '· already format 2 — nothing changed';
+            : '· already current format — nothing changed';
         return { output: withPathOutput(squarePath, body, { participantCount: outcome.standing }) };
     },
     present(result) {

package/dist/cli/registry.js

@@ -1,4 +1,4 @@
-import { buildCommand, doneCommand, expressCommand, holdCommand, ignoreCommand, joinCommand, listenCommand, listeningCommand, resumeCommand } from './square-commands.js';
+import { buildCommand, doneCommand, expressCommand, holdCommand, ignoreCommand, joinCommand, listenCommand, listeningCommand, resumeCommand, unlistenCommand } from './square-commands.js';
 import { doctorCommand, migrateCommand } from './maintenance-commands.js';
 import { ledgerCommand } from './ledger-command.js';
 import { harnessCommand, installCommand, uninstallCommand } from './harness-command.js';
@@ -18,6 +18,7 @@ export const commandRegistry = [
     { names: ['express'], spec: expressCommand },
     { names: ['listen'], spec: listenCommand },
     { names: ['ignore'], spec: ignoreCommand },
+    { names: ['unlisten'], spec: unlistenCommand },
     { names: ['listening'], spec: listeningCommand },
     { names: ['done'], spec: doneCommand },
     { names: ['hold'], spec: holdCommand },

package/dist/cli/square-commands.d.ts

@@ -30,6 +30,7 @@ export declare const joinCommand: CommandSpec<JoinIntent, string>;
 export declare const expressCommand: CommandSpec<ActivityIntent>;
 export declare const listenCommand: CommandSpec<ListenerIntent, string>;
 export declare const ignoreCommand: CommandSpec<ListenerIntent, string>;
+export declare const unlistenCommand: CommandSpec<ListenerIntent, string>;
 export declare const listeningCommand: CommandSpec<ListenerIntent, string>;
 export declare const doneCommand: CommandSpec<BodyIntent, string>;
 export declare const holdCommand: CommandSpec<BodyIntent, string>;

package/dist/cli/square-commands.js

@@ -171,8 +171,12 @@ function listenerCommand(verb) {
             const actor = participantIdentity(projection.participant);
             const target = participantIdentity(projection.target);
             const action = data.activity !== null
-                ? verb === 'listen' ? `${actor} turns an ear toward ${target}` : `${actor} turns away from ${target}`
-                : verb === 'listen' ? `${actor} already turns an ear toward ${target}` : `${actor} is not turned toward ${target}`;
+                ? verb === 'listen' ? `${actor} turns an ear toward ${target}`
+                    : verb === 'ignore' ? `${actor} turns away from ${target}`
+                        : `${actor} stops listening to ${target}`
+                : verb === 'listen' ? `${actor} already turns an ear toward ${target}`
+                    : verb === 'ignore' ? `${actor} is not turned toward ${target}`
+                        : `${actor} is not listening to ${target}`;
             return withPathOutput(projection.location, `${data.activity === null ? '○' : '·'} ${action}`, {
                 participantCount: projection.standingCount, held: projection.held,
             });
@@ -182,6 +186,7 @@ function listenerCommand(verb) {
 }
 export const listenCommand = listenerCommand('listen');
 export const ignoreCommand = listenerCommand('ignore');
+export const unlistenCommand = listenerCommand('unlisten');
 export const listeningCommand = {
     parse(argv, context) { return parseListener(argv, context, false); },
     async execute(_intent, context) {

package/dist/decisions.d.ts

@@ -5,7 +5,7 @@ type TimedAct<K extends Act['kind'] = Act['kind']> = Extract<Act, {
 }> & {
     at: number;
 };
-import type { ExpressOptions, ExpressResult, ParticipantSummary as ParticipantStatus, UnreadActivitySummary } from './square-facade.js';
+import type { ExpressResult, ParticipantSummary as ParticipantStatus, UnreadActivitySummary } from './square-facade.js';
 export type { ParticipantSummary as ParticipantStatus, ParticipantPresence as CorePresenceState, UnreadActivitySummary, UnreadActivityPreview } from './square-facade.js';
 export declare function resolveKnownName(facts: SquareRead, name: string): string;
 export interface DecideJoinResult {
@@ -42,12 +42,6 @@ export type ActDecision = ({
 };
 /** Count the directed suffix, but hydrate only its last three previews per spelling. */
 export declare function unreadActivitySummaries(facts: SquareRead, name: string, now: number): UnreadActivitySummary[];
-export declare function expressionReach(input: {
-    body: string;
-} & Pick<ExpressOptions, 'reach' | 'mentions' | 'noMention'>): {
-    bodyMentions: string[];
-    hasReachWithoutReply: boolean;
-};
 export declare function decideAct(facts: SquareRead, input: {
     name: string;
     body: string;
@@ -57,12 +51,12 @@ export declare function decideAct(facts: SquareRead, input: {
     reach?: Reach;
     reply?: number;
     noMention?: boolean;
-    requireExplicitReach?: boolean;
 }): ActDecision;
 export declare function validateDoneBody(body: unknown): void;
 export declare function coreDone(facts: SquareRead, name: string, body: string, now: number): TimedAct<'done'>;
-export declare function coreListen(facts: SquareRead, actor: string, target: string, now: number): TimedAct<"listen" | "ignore"> | undefined;
-export declare function coreIgnore(facts: SquareRead, actor: string, target: string, now: number): TimedAct<"listen" | "ignore"> | undefined;
+export declare function coreListen(facts: SquareRead, actor: string, target: string, now: number): TimedAct<"listen" | "ignore" | "unlisten"> | undefined;
+export declare function coreIgnore(facts: SquareRead, actor: string, target: string, now: number): TimedAct<"listen" | "ignore" | "unlisten"> | undefined;
+export declare function coreUnlisten(facts: SquareRead, actor: string, target: string, now: number): TimedAct<"listen" | "ignore" | "unlisten"> | undefined;
 export declare function coreListening(facts: SquareRead, actor: string): readonly string[];
 export declare function coreHold(facts: SquareRead, actor: string, body: string, now: number): TimedAct<'hold'>;
 export declare function coreResume(facts: SquareRead, actor: string, now: number): TimedAct<'resume'>;

package/dist/decisions.js

@@ -84,11 +84,6 @@ export function unreadActivitySummaries(facts, name, now) {
         previews: summary.previews.map((preview) => ({ number: preview.number, act: byIndex.get(preview.index), perception: 'full' })),
     })).sort((a, b) => a.latestActivityAgeMs - b.latestActivityAgeMs || a.name.localeCompare(b.name));
 }
-export function expressionReach(input) {
-    const bodyMentions = input.reach === 'bell' || input.noMention === true ? [] : scanMentionCandidates(input.body);
-    const hasReachWithoutReply = input.reach === 'bell' || (input.mentions?.length ?? 0) > 0 || input.noMention === true || bodyMentions.length > 0;
-    return { bodyMentions, hasReachWithoutReply };
-}
 export function decideAct(facts, input) {
     const { now, force, body, reach, reply } = input;
     const current = resolveStanding(facts, input.name, true);
@@ -114,7 +109,7 @@ export function decideAct(facts, input) {
             throw activityRefusal('invalid_args', `${participantIdentity(requested)} is not standing in this square`, { reason: 'not_standing', targets: [requested] });
         addMention(resolved);
     }
-    const { bodyMentions, hasReachWithoutReply } = expressionReach(input);
+    const bodyMentions = reach === 'bell' || input.noMention === true ? [] : scanMentionCandidates(body);
     const unmatchedMentions = [];
     for (const token of bodyMentions) {
         const resolved = resolveMention(token, joinedNames);
@@ -123,13 +118,10 @@ export function decideAct(facts, input) {
         else
             unmatchedMentions.push(token);
     }
-    if (input.requireExplicitReach && !hasReachWithoutReply && reply === undefined) {
-        throw activityRefusal('invalid_args', 'Express needs a recipient, reply, bell, or explicit bare reach', { reason: 'explicit_reach_required' });
-    }
     const header = facts.header();
     if (reply !== undefined && (!Number.isSafeInteger(reply) || reply < 0 || reply >= header.nextActIndex)) {
         const label = Number.isSafeInteger(reply) && reply >= 0 ? formatActivityId(reply) : String(reply);
-        throw activityRefusal('invalid_args', `Unknown reply activity: ${label}`, { reason: 'invalid_reply', activityId: label, activityExists: false, hasReachWithoutReply });
+        throw activityRefusal('invalid_args', `Unknown reply activity: ${label}`, { reason: 'invalid_reply', activityId: label, activityExists: false });
     }
     const replyAuthor = reply === undefined ? undefined : facts.activity(reply)?.actor;
     const replyAuthorNotHere = replyAuthor === undefined || sameName(replyAuthor, name) || facts.participant(replyAuthor)?.joined ? undefined : replyAuthor;
@@ -179,6 +171,8 @@ function attentionChange(facts, kind, actor, target, now) {
     requireStanding(current);
     const outgoing = facts.attention(current.name);
     const existing = outgoing.find((item) => sameName(item.target, target));
+    if (kind === 'unlisten')
+        return existing?.kind === 'listen' ? { kind, actor: current.name, target, at: now } : undefined;
     if (kind === 'listen' && existing?.kind !== 'listen' && outgoing.filter((item) => item.kind === 'listen').length >= MAX_IDENTITY_SET_SIZE) {
         throw new SquareError('invalid_args', `A participant can listen to at most ${MAX_IDENTITY_SET_SIZE} others`);
     }
@@ -186,6 +180,7 @@ function attentionChange(facts, kind, actor, target, now) {
 }
 export function coreListen(facts, actor, target, now) { return attentionChange(facts, 'listen', actor, target, now); }
 export function coreIgnore(facts, actor, target, now) { return attentionChange(facts, 'ignore', actor, target, now); }
+export function coreUnlisten(facts, actor, target, now) { return attentionChange(facts, 'unlisten', actor, target, now); }
 export function coreListening(facts, actor) {
     const current = resolveStanding(facts, actor);
     return facts.attention(current.name).filter((item) => item.kind === 'listen').map((item) => item.target);

package/dist/help.js

@@ -26,15 +26,16 @@ const COMMANDS = [
             "  --bell            Call everyone; body @names stay literal. Cannot combine with --mention.",
             '  --no-mention      Keep body @names literal; explicit --mention and --reply still apply.',
             '  --reply <activity-id>   Also reach the author of an earlier activity (for example act/12).',
-            '  Choose reach with a flag above or an @name in the body. Unmatched @names stay literal, with a notice.',
-            '  With no mention, bell, or reply, the activity lands bare; only listeners receive it.',
+            '  Address with --mention, --bell, --reply, or a standing @name in the body. Otherwise the activity lands bare; unmatched @names stay literal, with a notice.',
+            '  Bare activities are delivered only to participants listening to the sender.',
             '',
             'Options:',
             '  -f, --force       Express without first catching unread activity or satisfying attention etiquette.',
             '  --no-wait         If held or throttled, save a draft and return instead of waiting. A held wait gives up on its own after 10 minutes.',
         ],
     },
-    { names: ['listen'], usage: '--as <name> listen <participant>', usesSquare: true, group: 'participant', summary: 'Turn an ear toward one participant\'s future bare says.' },
+    { names: ['listen'], usage: '--as <name> listen <participant>', usesSquare: true, group: 'participant', summary: 'Turn an ear toward one participant\'s future activity.' },
+    { names: ['unlisten'], usage: '--as <name> unlisten <participant>', usesSquare: true, group: 'participant', summary: 'Stop listening without blocking that participant\'s mentions or replies.' },
     { names: ['ignore'], usage: '--as <name> ignore <participant>', usesSquare: true, group: 'participant', summary: 'Ignore one participant\'s future mentions and 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.'] },
     {
@@ -89,8 +90,8 @@ const COMMANDS = [
     },
     {
         names: ['migrate'], usage: 'migrate', usesSquare: true, group: 'maintenance',
-        summary: 'Convert an existing version 1 square to row storage in place.',
-        details: ['For the selected .square artifact only. Global identity and delivery records use square ledger migrate instead.', 'Stop sessions and services 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 square is left untouched; an unrelated or unsupported artifact is refused without a write. There is no --check, --backup or --force.'],
+        summary: 'Convert an existing version 1 or 2 square to current format 3 in place.',
+        details: ['For the selected .square artifact only. Global identity and delivery records use square ledger migrate instead.', 'Stop sessions and services using this artifact before conversion. Back up the stopped artifact, migrate it, then run square --location <path> doctor before starting updated clients.', 'A version 3 square is left untouched; an unrelated or unsupported artifact is refused without a write. There is no --check, --backup or --force.'],
     },
     {
         names: ['ledger'], usage: 'ledger <verify|migrate|gc>', usesSquare: false, group: 'maintenance',
@@ -106,7 +107,7 @@ function isHelpFlag(value) {
 }
 export function renderGlobalHelp() {
     const groups = [
-        { key: 'participant', title: 'In the square:', order: ['join', 'express', 'listen', 'ignore', 'listening', 'catch', 'history', 'status', 'hold', 'resume', 'done'] },
+        { key: 'participant', title: 'In the square:', order: ['join', 'express', 'listen', 'unlisten', 'ignore', 'listening', 'catch', 'history', 'status', 'hold', 'resume', 'done'] },
         { key: 'host', title: 'Prepare and manage:', order: ['build', 'list', 'participants'] },
         { key: 'maintenance', title: 'Setup:', order: ['install', 'uninstall', 'doctor', 'migrate', 'ledger'] },
     ];

package/dist/model.d.ts

@@ -21,7 +21,7 @@ export interface SquareErrorFacts {
     /** Express admission rejected before any activity was committed. */
     activityUnsent?: true;
     /** Refusal reason, including absent participants, conflicting reach, and inaccessible activities. */
-    reason?: 'never_joined' | 'not_standing' | 'bell_mention_conflict' | 'not_addressed' | 'migration_required' | 'explicit_reach_required' | 'invalid_reply' | 'invalid_done_body';
+    reason?: 'never_joined' | 'not_standing' | 'bell_mention_conflict' | 'not_addressed' | 'migration_required' | 'invalid_reply' | 'invalid_done_body';
     /** The activity id a `catch --id` refusal named. */
     activityId?: string;
     /** The host ledger requiring offline migration, rather than the selected artifact. */
@@ -30,8 +30,6 @@ export interface SquareErrorFacts {
     targets?: readonly string[];
     /** Whether the artifact holds that activity at all; an unknown id needs an ordinary page. */
     activityExists?: boolean;
-    /** Express has a recipient, bell, body candidate, or explicit bare reach without its reply. */
-    hasReachWithoutReply?: boolean;
     pending?: number;
     holder?: string;
     holdReason?: string;
@@ -101,7 +99,7 @@ export type PublicAct = Extract<StoredAct, {
     kind: 'say' | 'done';
 }>;
 export type RoomChangeAct = Extract<StoredAct, {
-    kind: 'join' | 'done' | 'hold' | 'resume' | 'listen' | 'ignore';
+    kind: 'join' | 'done' | 'hold' | 'resume' | 'listen' | 'ignore' | 'unlisten';
 }>;
 export declare function formatHardCap(hardCap: HardCap): string;
 export declare function parseParticipantList(value: string): string[];

package/dist/presentation.js

@@ -139,6 +139,8 @@ export function renderRoomChangeText(event) {
             return `${identity} turned an ear toward ${participantIdentity(event.target ?? 'someone')}`;
         case 'ignore':
             return `${identity} turned away from ${participantIdentity(event.target ?? 'someone')}`;
+        case 'unlisten':
+            return `${identity} stopped listening to ${participantIdentity(event.target ?? 'someone')}`;
         default:
             throw new Error('Expected a lifecycle activity');
     }
@@ -171,6 +173,7 @@ function renderEventCliFacts(event, opts = {}) {
             return { text: `${style('release', '✓')} ${renderRoomChangeText(event)}`, bodyClipped: false };
         case 'listen':
         case 'ignore':
+        case 'unlisten':
             return { text: `· ${renderRoomChangeText(event)}`, bodyClipped: false };
         case 'say': {
             const body = renderedBody(event.body, maxBody);

package/dist/runtime.js

@@ -48,7 +48,7 @@ export function readCursor(facts, name) {
     const block = facts.directed(name, { afterIndex: boundary, unseenOnly: true }, { edge: 'oldest', limit: 1 }).items[0]?.index;
     const last = facts.activityHeads({
         afterIndex: boundary, ...(block === undefined ? {} : { beforeIndex: block }), actorRequired: true,
-        kinds: ['join', 'done', 'say', 'hold', 'resume', 'listen', 'ignore'],
+        kinds: ['join', 'done', 'say', 'hold', 'resume', 'listen', 'ignore', 'unlisten'],
     }, { edge: 'newest', limit: 1 }).items[0]?.index;
     return Math.max(boundary, last ?? boundary);
 }

package/dist/square-actions.d.ts

@@ -42,6 +42,7 @@ export interface ListenerCommittedResult {
 }
 export declare function listen(square: OperationContext, actor: string, target: string, control?: OperationControl): Promise<ListenerCommittedResult>;
 export declare function ignore(square: OperationContext, actor: string, target: string, control?: OperationControl): Promise<ListenerCommittedResult>;
+export declare function unlisten(square: OperationContext, actor: string, target: string, control?: OperationControl): Promise<ListenerCommittedResult>;
 export declare function listening(square: OperationContext, actor: string, control?: OperationControl): Promise<readonly string[]>;
 export interface LifecycleCommittedResult extends ActivityResult {
     readonly observation: LandingContext & {

package/dist/square-actions.js

@@ -1,4 +1,4 @@
-import { coreDone, coreHold, coreIgnore, coreListen, coreListening, coreResume, decideAct, decideImplicitJoin, decideJoin, expressionReach, resolveKnownName, validateDoneBody } from './decisions.js';
+import { coreDone, coreHold, coreIgnore, coreListen, coreListening, coreResume, coreUnlisten, decideAct, decideImplicitJoin, decideJoin, resolveKnownName, validateDoneBody } from './decisions.js';
 import { isSquareError, nameKey, SquareError, validateName } from './model.js';
 import { participantIdentity } from './participant-identity.js';
 import { deliverPending } from './delivery-operations.js';
@@ -191,7 +191,6 @@ export async function express(square, name, body, options = {}, control) {
             if (isSquareError(error))
                 error.facts = {
                     ...error.facts, reason: 'invalid_reply', activityId: options.reply,
-                    hasReachWithoutReply: expressionReach({ ...options, body }).hasReachWithoutReply,
                 };
             throw error;
         }
@@ -199,7 +198,7 @@ export async function express(square, name, body, options = {}, control) {
     const committed = (await square.artifact.transact((facts) => {
         // Selected-row decoding is storage work, not evidence that admission safely refused.
         const proposed = decideAct(facts, { name, body, force: options.force ?? false, now, mentions: options.mentions,
-            ...(options.reach === undefined ? {} : { reach: options.reach }), ...(options.noMention === undefined ? {} : { noMention: options.noMention }), ...('requireExplicitReach' in options ? { requireExplicitReach: options.requireExplicitReach === true } : {}), ...(reply === undefined ? {} : { reply }) });
+            ...(options.reach === undefined ? {} : { reach: options.reach }), ...(options.noMention === undefined ? {} : { noMention: options.noMention }), ...(reply === undefined ? {} : { reply }) });
         const holder = proposed.type === 'held' ? facts.hold().actor : undefined;
         const decision = rejectUnsentActivity(() => {
             const decision = proposed;
@@ -239,7 +238,7 @@ async function landListenerChange(square, verb, actor, target, control) {
     throwIfAborted(control);
     const now = square.clock();
     const committed = (await square.artifact.transact((facts) => {
-        const act = verb === 'listen' ? coreListen(facts, actor, target, now) : coreIgnore(facts, actor, target, now);
+        const act = verb === 'listen' ? coreListen(facts, actor, target, now) : verb === 'ignore' ? coreIgnore(facts, actor, target, now) : coreUnlisten(facts, actor, target, now);
         const stored = act === undefined ? null : facts.land(act);
         return { stored, observation: { standingCount: inSquareCount(facts), held: facts.hold().active, now } };
     }, control?.signal)).value;
@@ -247,6 +246,7 @@ async function landListenerChange(square, verb, actor, target, control) {
 }
 export function listen(square, actor, target, control) { return landListenerChange(square, 'listen', actor, target, control); }
 export function ignore(square, actor, target, control) { return landListenerChange(square, 'ignore', actor, target, control); }
+export function unlisten(square, actor, target, control) { return landListenerChange(square, 'unlisten', actor, target, control); }
 export async function listening(square, actor, control) { return (await square.artifact.read((facts) => coreListening(facts, actor), control?.signal)).value; }
 async function landCore(square, verb, actor, body = '', fence = {}, control) {
     if (verb === 'done')

package/dist/square-api.js

@@ -8,7 +8,7 @@ import { catchLimit, observeCatchSelection } from './catch-decisions.js';
 import { directedSuffix } from './activity-feed.js';
 import { assertLiveOwner } from './participant-host.js';
 import { buildMemorySquare, openSquare, closeOpenSquare } from './open-square.js';
-import { catchUp, done, endOwnedSession, express, hold, ignore, implicitJoin, join, takeover, listen, listening, resume, retireEndedSessionRoutes } from './square-actions.js';
+import { catchUp, done, endOwnedSession, express, hold, ignore, implicitJoin, join, takeover, listen, listening, unlisten, resume, retireEndedSessionRoutes } from './square-actions.js';
 import { recoveryObservation, currentParticipant, entryPresentation, resolveParticipant, snapshot, queryStatus, queryParticipants, catchPresence, toPublicActivity, publicActivities, selectHistory, NON_READ, HISTORY_DEFAULT_LIMIT, HISTORY_MAX_LIMIT } from './views.js';
 import { hasAutomaticDeliveryIdentity, hostLedgerForEnv, localParticipantName, localSessionIdentities, presenceEpoch, readParticipantOwner } from './registry.js';
 import { projectSessionBindings } from './square-projections.js';
@@ -246,7 +246,7 @@ class ParticipantHandle {
     }
     async listener(verb, target, options, control) {
         const name = (await resolveParticipant(this.square, this.name, control)).name;
-        const { observation: committed, ...result } = await (verb === 'listen' ? listen : ignore)(this.square, name, target, control);
+        const { observation: committed, ...result } = await (verb === 'listen' ? listen : verb === 'ignore' ? ignore : unlisten)(this.square, name, target, control);
         return { ...result, ...(!options.observe ? {} : { observation: {
                     ...observedContext(this.square, committed.standingCount, committed.held, name, committed.now),
                     participant: name, requestedTarget: target, target: result.activity?.target ?? target,
@@ -254,6 +254,7 @@ class ParticipantHandle {
     }
     listen(target, options = {}, control) { return this.listener('listen', target, options, control); }
     ignore(target, options = {}, control) { return this.listener('ignore', target, options, control); }
+    unlisten(target, options = {}, control) { return this.listener('unlisten', target, options, control); }
     async listening(options = {}, control) {
         const name = (await resolveParticipant(this.square, this.name, control)).name;
         return { listening: await listening(this.square, name, control),

package/dist/square-core.d.ts

@@ -52,6 +52,11 @@ export type Act = {
     actor: Participant;
     target: Participant;
     at?: number;
+} | {
+    kind: 'unlisten';
+    actor: Participant;
+    target: Participant;
+    at?: number;
 };
 export declare function audienceOf(say: {
     body: string;

package/dist/square-domain.d.ts

@@ -4,6 +4,10 @@ export interface LandingEffect {
     readonly activity: StoredAct;
     readonly participant?: ParticipantFact;
     readonly removeListeningOf?: string;
+    readonly removeListening?: {
+        readonly listener: string;
+        readonly target: string;
+    };
     readonly replaceAttention?: AttentionFact;
     readonly audience: readonly LandedRecipient[];
 }

package/dist/square-domain.js

@@ -45,9 +45,13 @@ export function deriveLanding(activity, facts) {
             replaceAttention = { listener: participant.name, target: activity.target, kind: activity.kind, sinceIndex: activity.index };
         }
     }
+    const removeListening = activity.kind === 'unlisten'
+        && facts.outgoing.some((item) => item.kind === 'listen' && sameName(item.target, activity.target))
+        ? { listener: participant.name, target: activity.target } : undefined;
     return {
         activity, participant, audience,
         ...(activity.kind === 'done' ? { removeListeningOf: participant.name } : {}),
+        ...(removeListening === undefined ? {} : { removeListening }),
         ...(replaceAttention === undefined ? {} : { replaceAttention }),
     };
 }
@@ -56,7 +60,7 @@ export function landingFacts(read, activity) {
         actor: activity.actor === undefined ? undefined : read.participant(activity.actor),
         standing: activity.kind === 'say' ? read.roster().filter((item) => item.joined) : [],
         incoming: activity.kind === 'say' ? read.incomingAttention(activity.actor) : [],
-        outgoing: activity.kind === 'listen' || activity.kind === 'ignore' ? read.attention(activity.actor) : [],
+        outgoing: activity.kind === 'listen' || activity.kind === 'ignore' || activity.kind === 'unlisten' ? read.attention(activity.actor) : [],
         replyAuthor: activity.kind === 'say' && activity.reply !== undefined ? read.activity(activity.reply)?.actor : undefined,
     };
 }

package/dist/square-facade.d.ts

@@ -7,7 +7,7 @@ export type ArchiveRecord = Readonly<StoredAct>;
 export interface Activity {
     readonly id: ActivityId;
     readonly at: number;
-    readonly kind: 'join' | 'say' | 'done' | 'hold' | 'resume' | 'listen' | 'ignore';
+    readonly kind: 'join' | 'say' | 'done' | 'hold' | 'resume' | 'listen' | 'ignore' | 'unlisten';
     readonly actor: string;
     readonly body?: string;
     readonly mentions: readonly string[];
@@ -29,7 +29,6 @@ export interface ExpressOptions extends ObservationOptions {
     readonly reply?: ActivityId;
     readonly noMention?: boolean;
     readonly noWait?: boolean;
-    readonly requireExplicitReach?: boolean;
 }
 export interface ActivityResult {
     readonly activity: Activity;
@@ -185,6 +184,7 @@ export interface Participant {
     express(body: string, options?: ExpressOptions, control?: OperationControl): Promise<ExpressResult>;
     listen(target: string, options?: ObservationOptions, control?: OperationControl): Promise<ListenerChangeResult>;
     ignore(target: string, options?: ObservationOptions, control?: OperationControl): Promise<ListenerChangeResult>;
+    unlisten(target: string, options?: ObservationOptions, control?: OperationControl): Promise<ListenerChangeResult>;
     listening(options?: ObservationOptions, control?: OperationControl): Promise<ListeningResult>;
     catch(options?: CatchOptions, control?: OperationControl): Promise<CatchResult>;
     history(query?: HistoryQuery, control?: OperationControl): Promise<HistoryResult>;

package/dist/square-migration.d.ts

@@ -8,17 +8,15 @@ export interface MigrationCounts {
     readonly routes: number;
 }
 export interface MigrationOutcome {
-    readonly status: 'migrated' | 'already-format-2';
+    readonly status: 'migrated' | 'already-current';
     /** Participants standing after the conversion, for the CLI header. */
     readonly standing: number;
     readonly counts?: MigrationCounts;
 }
 /**
- * Explicit in-place conversion of a normally persisted version 1 artifact.
- *
- * The legacy snapshot is read, validated and written here and nowhere else in
- * production; the row schema, codec and landing transition come from the driver.
- * One transaction: preflight framing, the same recheck under the lock, the
- * preserved authority, the derived facts, the format flip and a single COMMIT.
+ * Explicit in-place conversion of a version 1 snapshot or version 2 row
+ * artifact. Each source is validated before and under the write lock; v1 is
+ * imported through the normal current row initializer, while v2 rebuilds only
+ * activities and its indexes before publishing the new format version.
  */
 export declare function migrateSquareFile(location: string, signal?: AbortSignal): Promise<MigrationOutcome>;

package/dist/square-migration.js

@@ -3,7 +3,7 @@ import { inSqliteTransaction } from './sqlite-transaction.js';
 import { canonicalPath } from './canonical-path.js';
 import { isWakeRouteKind } from './model.js';
 import { parseActivityId } from './square-core.js';
-import { APPLICATION_ID, V1_SNAPSHOT_TABLE, createSqliteDriver, initializeSqlite, invalidArtifact, validateLegacyFraming, validateSqliteHeader, validateStoredActivity, validateWatchLease, } from './square-sqlite.js';
+import { APPLICATION_ID, ACTIVITIES_TABLE_SQL, ACTIVITY_INDEXES_SQL, CURRENT_USER_VERSION, V2_USER_VERSION, V1_SNAPSHOT_TABLE, createSqliteDriver, initializeSqlite, invalidArtifact, validateLegacyFraming, validateRowFraming, validateSqliteHeader, validateStoredActivity, validateWatchLease, } from './square-sqlite.js';
 function isObject(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -57,7 +57,7 @@ function validateActs(value) {
     try {
         for (const candidate of value) {
             const act = validateStoredActivity(candidate);
-            if (act.index <= previous)
+            if (act.kind === 'unlisten' || act.index <= previous)
                 return false;
             previous = act.index;
         }
@@ -153,58 +153,78 @@ function counts(state) {
         routes: state.routes?.length ?? 0,
     };
 }
+function rowCounts(database) {
+    const count = (table) => Number(database.prepare(`SELECT COUNT(*) AS n FROM ${table}`).get().n);
+    return { activities: count('activities'), receipts: count('receipts'), leases: count('catch_leases'), routes: count('routes') };
+}
+const ACTIVITY_INDEX_NAMES = ['activity_kind_index', 'activity_actor_index', 'activity_say_actor_index', 'activity_say_time', 'activity_bell_actor_time'];
+function rebuildV2Activities(database) {
+    database.exec([
+        ...ACTIVITY_INDEX_NAMES.map((name) => `DROP INDEX ${name};`),
+        'ALTER TABLE activities RENAME TO activities_v2;',
+        ACTIVITIES_TABLE_SQL,
+        'INSERT INTO activities(act_index,at,kind,actor_json,actor_key_json,reach,reply_index,payload_json) SELECT act_index,at,kind,actor_json,actor_key_json,reach,reply_index,payload_json FROM activities_v2 ORDER BY act_index;',
+        'DROP TABLE activities_v2;',
+        ...ACTIVITY_INDEXES_SQL.map((sql) => `${sql};`),
+    ].join('\n'));
+}
+function validateMigrationSource(database, location) {
+    const before = identity(database);
+    if (before.applicationId !== APPLICATION_ID)
+        throw invalidArtifact('unrelated SQLite database.');
+    if (before.userVersion === 1) {
+        validateLegacyFraming(database, APPLICATION_ID, location);
+        return 1;
+    }
+    if (before.userVersion === V2_USER_VERSION) {
+        validateRowFraming(database, V2_USER_VERSION, location);
+        createSqliteDriver(database).header();
+        return 2;
+    }
+    if (before.userVersion === CURRENT_USER_VERSION) {
+        validateSqliteHeader(database, location);
+        return undefined;
+    }
+    throw invalidArtifact('unsupported SQLite format version.');
+}
 /**
- * Explicit in-place conversion of a normally persisted version 1 artifact.
- *
- * The legacy snapshot is read, validated and written here and nowhere else in
- * production; the row schema, codec and landing transition come from the driver.
- * One transaction: preflight framing, the same recheck under the lock, the
- * preserved authority, the derived facts, the format flip and a single COMMIT.
+ * Explicit in-place conversion of a version 1 snapshot or version 2 row
+ * artifact. Each source is validated before and under the write lock; v1 is
+ * imported through the normal current row initializer, while v2 rebuilds only
+ * activities and its indexes before publishing the new format version.
  */
 export async function migrateSquareFile(location, signal) {
     const squarePath = await canonicalPath(location);
     const database = openExistingSquareDatabase(squarePath);
     try {
-        // Owned framing, read-only, before any pragma or DDL touches the artifact.
-        // Every preflight statement reads one snapshot taken in the helper's
-        // retryable stage: a transient writer lock is waited out like any other
-        // acquisition, and a migrator that commits while we look cannot move the
-        // artifact between the identity read and the schema reads.
-        let alreadyConverted;
+        let alreadyCurrent;
         const preflight = await inSqliteTransaction(database, false, () => {
-            const before = identity(database);
-            if (before.applicationId === APPLICATION_ID && before.userVersion === 1) {
-                validateLegacyFraming(database, APPLICATION_ID, squarePath);
-                return;
-            }
-            // A row artifact means another migrator finished here; anything else is
-            // refused by the row header itself.
-            validateSqliteHeader(database, squarePath);
-            alreadyConverted = { status: 'already-format-2', standing: standing(database) };
-        }, () => alreadyConverted, signal);
-        if (preflight !== undefined)
-            return preflight;
+            const source = validateMigrationSource(database, squarePath);
+            if (source === undefined)
+                alreadyCurrent = { status: 'already-current', standing: standing(database) };
+            return source;
+        }, (source) => source, signal);
+        if (preflight === undefined)
+            return alreadyCurrent;
         database.exec('PRAGMA busy_timeout = 0; PRAGMA synchronous = FULL');
         const result = {};
         await inSqliteTransaction(database, true, () => {
-            // Another migration may have finished between preflight and this lock.
-            const locked = identity(database);
-            if (locked.applicationId !== APPLICATION_ID || locked.userVersion !== 1) {
-                // A valid row artifact is done already; anything else is refused here.
-                validateSqliteHeader(database, squarePath);
-                return;
-            }
-            validateLegacyFraming(database, APPLICATION_ID, squarePath);
-            result.converted = true;
+            const source = validateMigrationSource(database, squarePath);
+            result.source = source;
         }, () => {
-            if (result.converted !== true)
-                return;
-            const legacy = decodeLegacySnapshot(database);
-            initializeSqlite(database, legacy.state, legacy.revision);
-            database.exec(`DROP TABLE ${V1_SNAPSHOT_TABLE}; PRAGMA user_version = 2`);
-            result.outcome = { status: 'migrated', standing: standing(database), counts: counts(legacy.state) };
+            if (result.source === 1) {
+                const legacy = decodeLegacySnapshot(database);
+                initializeSqlite(database, legacy.state, legacy.revision);
+                database.exec(`DROP TABLE ${V1_SNAPSHOT_TABLE}; PRAGMA user_version = ${CURRENT_USER_VERSION}`);
+                result.outcome = { status: 'migrated', standing: standing(database), counts: counts(legacy.state) };
+            }
+            else if (result.source === 2) {
+                rebuildV2Activities(database);
+                database.exec(`PRAGMA user_version = ${CURRENT_USER_VERSION}`);
+                result.outcome = { status: 'migrated', standing: standing(database), counts: rowCounts(database) };
+            }
         }, signal);
-        return result.outcome ?? { status: 'already-format-2', standing: standing(database) };
+        return result.outcome ?? { status: 'already-current', standing: standing(database) };
     }
     finally {
         database.close();

package/dist/square-sqlite.d.ts

@@ -19,6 +19,8 @@ export interface SquareState {
 }
 export declare function emptyRuntimeState(nextActIndex?: number): SquareRuntimeState;
 export declare const APPLICATION_ID = 1397838405;
+export declare const V2_USER_VERSION = 2;
+export declare const CURRENT_USER_VERSION = 3;
 export declare const V1_SNAPSHOT_TABLE = "square_snapshot";
 export interface LegacyFraming {
     readonly applicationId: number;
@@ -32,11 +34,15 @@ export interface LegacyFraming {
  * migration. Anything else is unrelated or unsupported, not repaired.
  */
 export declare function validateLegacyFraming(database: DatabaseSync, applicationId: number, location?: string): LegacyFraming;
-export declare const SCHEMA_SQL = "CREATE TABLE square_meta (\n  id INTEGER PRIMARY KEY CHECK (id = 1),\n  revision INTEGER NOT NULL CHECK (revision BETWEEN 0 AND 9007199254740991),\n  next_act_index INTEGER NOT NULL CHECK (next_act_index BETWEEN 0 AND 9007199254740991),\n  hard_cap INTEGER CHECK (hard_cap BETWEEN 1 AND 9007199254740991),\n  throttle_per_minute INTEGER CHECK (throttle_per_minute BETWEEN 1 AND 9007199254740991),\n  preamble_json TEXT NOT NULL CHECK (json_valid(preamble_json)),\n  warmup_json TEXT NOT NULL CHECK (json_valid(warmup_json))\n);\nCREATE TABLE activities (\n  act_index INTEGER PRIMARY KEY CHECK (act_index BETWEEN 0 AND 9007199254740991),\n  at REAL NOT NULL,\n  kind TEXT NOT NULL CHECK (kind IN ('join','done','say','hold','resume','read','listen','ignore')),\n  actor_json TEXT COLLATE BINARY,\n  actor_key_json TEXT COLLATE BINARY,\n  reach TEXT CHECK (reach = 'bell'),\n  reply_index INTEGER CHECK (reply_index >= 0 AND reply_index < act_index),\n  payload_json TEXT NOT NULL CHECK (json_valid(payload_json)),\n  CHECK ((actor_json IS NULL) = (actor_key_json IS NULL)),\n  CHECK (kind IN ('hold','resume') OR actor_json IS NOT NULL),\n  CHECK (kind = 'say' OR (reach IS NULL AND reply_index IS NULL))\n);\nCREATE INDEX activity_kind_index ON activities(kind, act_index);\nCREATE INDEX activity_actor_index ON activities(actor_key_json, act_index);\nCREATE INDEX activity_say_actor_index ON activities(actor_key_json, act_index) WHERE kind='say';\nCREATE INDEX activity_say_time ON activities(at, act_index) WHERE kind='say';\nCREATE INDEX activity_bell_actor_time ON activities(actor_key_json, at, act_index) WHERE kind='say' AND reach='bell';\n\nCREATE TABLE receipts (\n  owner_json TEXT COLLATE BINARY NOT NULL,\n  act_index INTEGER NOT NULL CHECK (act_index BETWEEN 0 AND 9007199254740991),\n  at REAL NOT NULL,\n  PRIMARY KEY (owner_json, act_index)\n) WITHOUT ROWID;\nCREATE INDEX receipt_owner_time ON receipts(owner_json, at);\nCREATE TABLE catch_leases (\n  owner_json TEXT COLLATE BINARY PRIMARY KEY NOT NULL,\n  lease_id_json TEXT NOT NULL,\n  heartbeat_at REAL NOT NULL,\n  expires_at REAL NOT NULL CHECK (expires_at >= heartbeat_at),\n  filter_json TEXT CHECK (filter_json IS NULL OR json_valid(filter_json))\n) WITHOUT ROWID;\n\nCREATE TABLE routes (\n  position INTEGER PRIMARY KEY CHECK (position >= 0),\n  participant_key_json TEXT COLLATE BINARY NOT NULL,\n  session_json TEXT COLLATE BINARY NOT NULL,\n  kind TEXT NOT NULL CHECK (kind IN ('opencode-server','codex-queue','claude-native','paseo')),\n  updated_at REAL NOT NULL,\n  payload_json TEXT NOT NULL CHECK (json_valid(payload_json))\n);\nCREATE INDEX route_participant ON routes(participant_key_json, position);\nCREATE INDEX route_session ON routes(session_json, position);\n\nCREATE TABLE participants (\n  name_key_json TEXT COLLATE BINARY PRIMARY KEY NOT NULL,\n  name_json TEXT NOT NULL,\n  first_index INTEGER NOT NULL UNIQUE,\n  joined INTEGER NOT NULL CHECK (joined IN (0,1)),\n  done INTEGER NOT NULL CHECK (done IN (0,1)),\n  say_count INTEGER NOT NULL CHECK (say_count >= 0),\n  last_active_at REAL,\n  last_join_index INTEGER,\n  CHECK (NOT (joined=1 AND done=1))\n) WITHOUT ROWID;\nCREATE TABLE attention (\n  listener_key_json TEXT COLLATE BINARY NOT NULL,\n  target_key_json TEXT COLLATE BINARY NOT NULL,\n  target_json TEXT NOT NULL,\n  kind TEXT NOT NULL CHECK (kind IN ('listen','ignore')),\n  since_index INTEGER NOT NULL,\n  PRIMARY KEY (listener_key_json, target_key_json)\n) WITHOUT ROWID;\nCREATE INDEX attention_target ON attention(target_key_json, kind, listener_key_json);\nCREATE TABLE landed_audience (\n  act_index INTEGER NOT NULL,\n  recipient_key_json TEXT COLLATE BINARY NOT NULL,\n  recipient_order INTEGER NOT NULL CHECK (recipient_order >= 0),\n  route TEXT NOT NULL CHECK (route IN ('mention','reply','attention','bell')),\n  PRIMARY KEY (act_index, recipient_key_json),\n  UNIQUE (act_index, recipient_order)\n) WITHOUT ROWID;\nCREATE INDEX audience_recipient ON landed_audience(recipient_key_json, act_index);";
+export declare const ACTIVITIES_TABLE_SQL = "CREATE TABLE activities (\n  act_index INTEGER PRIMARY KEY CHECK (act_index BETWEEN 0 AND 9007199254740991),\n  at REAL NOT NULL,\n  kind TEXT NOT NULL CHECK (kind IN ('join','done','say','hold','resume','read','listen','ignore','unlisten')),\n  actor_json TEXT COLLATE BINARY,\n  actor_key_json TEXT COLLATE BINARY,\n  reach TEXT CHECK (reach = 'bell'),\n  reply_index INTEGER CHECK (reply_index >= 0 AND reply_index < act_index),\n  payload_json TEXT NOT NULL CHECK (json_valid(payload_json)),\n  CHECK ((actor_json IS NULL) = (actor_key_json IS NULL)),\n  CHECK (kind IN ('hold','resume') OR actor_json IS NOT NULL),\n  CHECK (kind = 'say' OR (reach IS NULL AND reply_index IS NULL))\n);";
+export declare const ACTIVITY_INDEXES_SQL: readonly ["CREATE INDEX activity_kind_index ON activities(kind, act_index)", "CREATE INDEX activity_actor_index ON activities(actor_key_json, act_index)", "CREATE INDEX activity_say_actor_index ON activities(actor_key_json, act_index) WHERE kind='say'", "CREATE INDEX activity_say_time ON activities(at, act_index) WHERE kind='say'", "CREATE INDEX activity_bell_actor_time ON activities(actor_key_json, at, act_index) WHERE kind='say' AND reach='bell'"];
+export declare const SCHEMA_SQL: string;
+export declare const SCHEMA_SQL_V2: string;
 export declare function invalidArtifact(detail: string): SquareError;
 export declare function validateStoredActivity(value: unknown): StoredAct;
 export declare function validateWatchLease(value: unknown): WatchLease;
 export declare function validateRoute(value: unknown): RouteFact;
+export declare function validateRowFraming(db: DatabaseSync, version: 2 | 3, location?: string): void;
 export declare function validateSqliteHeader(db: DatabaseSync, location?: string): SquareHeader;
 export interface SqliteDriver extends SquareRead, LandingWriter {
     readonly changed: boolean;

package/dist/square-sqlite.js

@@ -6,6 +6,8 @@ export function emptyRuntimeState(nextActIndex = 0) {
 }
 export const APPLICATION_ID = 0x53515245;
 const V1_USER_VERSION = 1;
+export const V2_USER_VERSION = 2;
+export const CURRENT_USER_VERSION = 3;
 export const V1_SNAPSHOT_TABLE = 'square_snapshot';
 const V1_SNAPSHOT_DDL = `CREATE TABLE ${V1_SNAPSHOT_TABLE} (id INTEGER PRIMARY KEY CHECK(id=1), revision INTEGER NOT NULL CHECK(revision>=0), state TEXT NOT NULL)`;
 const V1_SNAPSHOT_COLUMNS = [
@@ -50,19 +52,12 @@ export function validateLegacyFraming(database, applicationId, location = '') {
 function normalizedLegacySql(sql) {
     return sql.trim().replace(/\s+/g, ' ').replace(/\s*(>=|[(),=])\s*/g, '$1');
 }
-export const SCHEMA_SQL = `CREATE TABLE square_meta (
-  id INTEGER PRIMARY KEY CHECK (id = 1),
-  revision INTEGER NOT NULL CHECK (revision BETWEEN 0 AND 9007199254740991),
-  next_act_index INTEGER NOT NULL CHECK (next_act_index BETWEEN 0 AND 9007199254740991),
-  hard_cap INTEGER CHECK (hard_cap BETWEEN 1 AND 9007199254740991),
-  throttle_per_minute INTEGER CHECK (throttle_per_minute BETWEEN 1 AND 9007199254740991),
-  preamble_json TEXT NOT NULL CHECK (json_valid(preamble_json)),
-  warmup_json TEXT NOT NULL CHECK (json_valid(warmup_json))
-);
-CREATE TABLE activities (
+const V2_ACTIVITY_KIND_CHECK = "kind IN ('join','done','say','hold','resume','read','listen','ignore')";
+const CURRENT_ACTIVITY_KIND_CHECK = "kind IN ('join','done','say','hold','resume','read','listen','ignore','unlisten')";
+export const ACTIVITIES_TABLE_SQL = `CREATE TABLE activities (
   act_index INTEGER PRIMARY KEY CHECK (act_index BETWEEN 0 AND 9007199254740991),
   at REAL NOT NULL,
-  kind TEXT NOT NULL CHECK (kind IN ('join','done','say','hold','resume','read','listen','ignore')),
+  kind TEXT NOT NULL CHECK (${CURRENT_ACTIVITY_KIND_CHECK}),
   actor_json TEXT COLLATE BINARY,
   actor_key_json TEXT COLLATE BINARY,
   reach TEXT CHECK (reach = 'bell'),
@@ -71,12 +66,25 @@ CREATE TABLE activities (
   CHECK ((actor_json IS NULL) = (actor_key_json IS NULL)),
   CHECK (kind IN ('hold','resume') OR actor_json IS NOT NULL),
   CHECK (kind = 'say' OR (reach IS NULL AND reply_index IS NULL))
+);`;
+export const ACTIVITY_INDEXES_SQL = [
+    'CREATE INDEX activity_kind_index ON activities(kind, act_index)',
+    'CREATE INDEX activity_actor_index ON activities(actor_key_json, act_index)',
+    "CREATE INDEX activity_say_actor_index ON activities(actor_key_json, act_index) WHERE kind='say'",
+    "CREATE INDEX activity_say_time ON activities(at, act_index) WHERE kind='say'",
+    "CREATE INDEX activity_bell_actor_time ON activities(actor_key_json, at, act_index) WHERE kind='say' AND reach='bell'",
+];
+export const SCHEMA_SQL = `CREATE TABLE square_meta (
+  id INTEGER PRIMARY KEY CHECK (id = 1),
+  revision INTEGER NOT NULL CHECK (revision BETWEEN 0 AND 9007199254740991),
+  next_act_index INTEGER NOT NULL CHECK (next_act_index BETWEEN 0 AND 9007199254740991),
+  hard_cap INTEGER CHECK (hard_cap BETWEEN 1 AND 9007199254740991),
+  throttle_per_minute INTEGER CHECK (throttle_per_minute BETWEEN 1 AND 9007199254740991),
+  preamble_json TEXT NOT NULL CHECK (json_valid(preamble_json)),
+  warmup_json TEXT NOT NULL CHECK (json_valid(warmup_json))
 );
-CREATE INDEX activity_kind_index ON activities(kind, act_index);
-CREATE INDEX activity_actor_index ON activities(actor_key_json, act_index);
-CREATE INDEX activity_say_actor_index ON activities(actor_key_json, act_index) WHERE kind='say';
-CREATE INDEX activity_say_time ON activities(at, act_index) WHERE kind='say';
-CREATE INDEX activity_bell_actor_time ON activities(actor_key_json, at, act_index) WHERE kind='say' AND reach='bell';
+${ACTIVITIES_TABLE_SQL}
+${ACTIVITY_INDEXES_SQL.join(';\n')};
 
 CREATE TABLE receipts (
   owner_json TEXT COLLATE BINARY NOT NULL,
@@ -134,6 +142,8 @@ CREATE TABLE landed_audience (
 ) WITHOUT ROWID;
 CREATE INDEX audience_recipient ON landed_audience(recipient_key_json, act_index);`;
 const EXPECTED_SCHEMA_SQL = SCHEMA_SQL.split(';').map(s => s.trim()).filter(Boolean).map(normalizedSql).sort();
+export const SCHEMA_SQL_V2 = SCHEMA_SQL.replace(CURRENT_ACTIVITY_KIND_CHECK, V2_ACTIVITY_KIND_CHECK);
+const EXPECTED_SCHEMA_SQL_V2 = SCHEMA_SQL_V2.split(';').map(s => s.trim()).filter(Boolean).map(normalizedSql).sort();
 const encode = JSON.stringify;
 const key = (name) => encode(nameKey(name));
 export function invalidArtifact(detail) {
@@ -189,7 +199,7 @@ function immutable(value) {
     }
     return value;
 }
-const kinds = ['join', 'done', 'say', 'hold', 'resume', 'read', 'listen', 'ignore'];
+const kinds = ['join', 'done', 'say', 'hold', 'resume', 'read', 'listen', 'ignore', 'unlisten'];
 function head(row) {
     const index = integer(row.act_index), at = finite(row.at);
     requireFact(kinds.includes(string(row.kind)));
@@ -237,6 +247,7 @@ export function validateStoredActivity(value) {
             break;
         case 'listen':
         case 'ignore':
+        case 'unlisten':
             shape(a, [...common, 'target']);
             string(a.target, true);
             break;
@@ -247,7 +258,7 @@ export function validateStoredActivity(value) {
 function activity(row) {
     const h = head(row), payload = object(json(row.payload_json));
     // Payload cannot shadow indexed structural columns.
-    const allowed = h.kind === 'say' ? ['body', 'mentions'] : h.kind === 'done' || h.kind === 'hold' ? ['body'] : h.kind === 'read' ? ['through'] : h.kind === 'listen' || h.kind === 'ignore' ? ['target'] : [];
+    const allowed = h.kind === 'say' ? ['body', 'mentions'] : h.kind === 'done' || h.kind === 'hold' ? ['body'] : h.kind === 'read' ? ['through'] : h.kind === 'listen' || h.kind === 'ignore' || h.kind === 'unlisten' ? ['target'] : [];
     requireFact(Object.keys(payload).every(k => allowed.includes(k)));
     return immutable(validateStoredActivity({ ...h, ...payload }));
 }
@@ -315,6 +326,17 @@ function route(row) {
     }));
 }
 function normalizedSql(sql) { return sql.trim().replace(/;$/, '').replace(/\s+/g, ' ').replace(/\s*([(),=])\s*/g, '$1'); }
+function validateOwnedSchema(db, expected, location) {
+    const actual = db.prepare("SELECT sql FROM sqlite_schema WHERE name NOT GLOB 'sqlite_*' AND sql IS NOT NULL").all().map(r => normalizedSql(string(r.sql))).sort();
+    requireFact(actual.length === expected.length && actual.every((sql, i) => sql === expected[i]), 'unsupported row schema.');
+    requireFact(db.prepare('PRAGMA journal_mode').get().journal_mode === (location === ':memory:' ? 'memory' : 'delete'), 'unsupported journal mode.');
+}
+export function validateRowFraming(db, version, location = '') {
+    const identity = db.prepare('SELECT application_id,user_version FROM pragma_application_id,pragma_user_version').get();
+    requireFact(identity.application_id === APPLICATION_ID, 'unrelated SQLite database.');
+    requireFact(identity.user_version === version, 'unsupported SQLite format version.');
+    validateOwnedSchema(db, version === V2_USER_VERSION ? EXPECTED_SCHEMA_SQL_V2 : EXPECTED_SCHEMA_SQL, location);
+}
 export function validateSqliteHeader(db, location = '') {
     const identity = db.prepare('SELECT application_id,user_version FROM pragma_application_id,pragma_user_version').get();
     requireFact(identity.application_id === APPLICATION_ID, 'unrelated SQLite database.');
@@ -322,10 +344,12 @@ export function validateSqliteHeader(db, location = '') {
         validateLegacyFraming(db, APPLICATION_ID, location);
         throw new SquareError('invalid_args', `Square artifact at ${location} needs migration.\nStop sessions using it, back it up, then migrate and verify before restarting.`, { reason: 'migration_required' });
     }
-    requireFact(identity.user_version === 2, 'unsupported SQLite format version.');
-    const actual = db.prepare("SELECT sql FROM sqlite_schema WHERE name NOT GLOB 'sqlite_*' AND sql IS NOT NULL").all().map(r => normalizedSql(string(r.sql))).sort();
-    requireFact(actual.length === EXPECTED_SCHEMA_SQL.length && actual.every((sql, i) => sql === EXPECTED_SCHEMA_SQL[i]), 'unsupported row schema.');
-    requireFact(db.prepare('PRAGMA journal_mode').get().journal_mode === (location === ':memory:' ? 'memory' : 'delete'), 'unsupported journal mode.');
+    if (identity.user_version === V2_USER_VERSION) {
+        validateRowFraming(db, V2_USER_VERSION, location);
+        throw new SquareError('invalid_args', `Square artifact at ${location} needs migration.\nStop sessions using it, back it up, then migrate and verify before restarting.`, { reason: 'migration_required' });
+    }
+    requireFact(identity.user_version === CURRENT_USER_VERSION, 'unsupported SQLite format version.');
+    validateRowFraming(db, CURRENT_USER_VERSION, location);
     return createSqliteDriver(db).header();
 }
 function activitySelection(filter, alias = 'a') {
@@ -550,6 +574,12 @@ export function createSqliteDriver(db) {
             }
             if (effect.removeListeningOf !== undefined)
                 run("DELETE FROM attention WHERE listener_key_json=? AND kind='listen'", [key(effect.removeListeningOf)]);
+            if (effect.removeListening !== undefined) {
+                const target = effect.removeListening;
+                string(target.listener, true);
+                string(target.target, true);
+                run("DELETE FROM attention WHERE listener_key_json=? AND target_key_json=? AND kind='listen'", [key(target.listener), key(target.target)]);
+            }
             if (effect.replaceAttention) {
                 const t = effect.replaceAttention;
                 string(t.listener, true);

package/dist/square-tools.js

@@ -34,8 +34,9 @@ export const SQUARE_TOOLS = [
         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(),
     }, (square, args, control) => square.history(args, control)),
-    tool('listen', 'Listen for future bare 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, {}, control)),
+    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, {}, control)),
     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, {}, control)),
+    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, {}, control)),
     tool('listening', 'List participants this participant is listening to.', { as: participant }, async (square, { as }, control) => (await square.participant(as)).listening({}, control)),
     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, {}, control)),
     tool('resume', 'Release the current hold.', { as: participant }, async (square, { as }, control) => (await square.participant(as)).resume({}, control)),

package/dist/views.d.ts

@@ -6,7 +6,7 @@ import type { Activity, ArchiveRecord, HistoryQuery, HistoryContinuation, Operat
 export type { EntryPresentation, ListPresentation, CatchPresence, StreamProjection } from './square-facade.js';
 export declare const HISTORY_DEFAULT_LIMIT = 10;
 export declare const HISTORY_MAX_LIMIT = 100;
-export declare const NON_READ: readonly ["join", "done", "say", "hold", "resume", "listen", "ignore"];
+export declare const NON_READ: readonly ["join", "done", "say", "hold", "resume", "listen", "ignore", "unlisten"];
 /** The one StoredAct-to-public-Activity field mapping. Rejects read and actorless acts. */
 export declare function toPublicActivity(stored: StoredAct): Activity;
 export declare function parseRequiredActivityId(id: ActivityId): number;

package/dist/views.js

@@ -9,7 +9,7 @@ export const HISTORY_DEFAULT_LIMIT = 10;
 export const HISTORY_MAX_LIMIT = 100;
 const STATUS_HERE_WINDOW_MS = 30 * 60_000;
 const PRESENCE_WINDOW_MS = 8 * 60 * 60_000;
-export const NON_READ = ['join', 'done', 'say', 'hold', 'resume', 'listen', 'ignore'];
+export const NON_READ = ['join', 'done', 'say', 'hold', 'resume', 'listen', 'ignore', 'unlisten'];
 const ARCHIVE = new Set(['join', 'done', 'say', 'hold', 'resume']);
 /** The one StoredAct-to-public-Activity field mapping. Rejects read and actorless acts. */
 export function toPublicActivity(stored) {

package/guides/application-facade-delivery-evidence.md

@@ -179,7 +179,7 @@ These are deliverer closures, not a reviewer verdict. Rows distinguish behavior
 | SDK projection roundtrip / leaked observations | SDK express uses `prepareExpression` + `landExpression`, strips observation/waited and retains delivery; SDK catch uses `catchOwned` and returns only established CatchResult. SDK test asserts established fields and avoids application body projections. SDK Square history stays unbounded, Participant recent-ten; parity history fixture proves both, and projection test preserves detached delivered predicate. |
 | Duplicate contracts, aliases and dead mixed views | Private status/unread producers import/re-export facade contracts; catch observation extends shared expression facts and enriched projection reuses it; required express participant replaces name alias. Retired helper search is empty. Recovery selects only gates/bounded unread summaries, not discarded feed/ordinals/perceptions. |
 | Packed owner orchestration hides effects/count integrity | History, lifecycle branches, maintenance/discovery/recovery, catch conflict and SDK recognize are expanded into readable steps. Remaining one-line SDK delegates are supported simple resource calls, not packed async policy. Inspect implementation diff; all new source is included in count. |
-| Invalid reply / missing reach / done repair regressions | Typed `invalid_reply` covers malformed and valid-but-absent IDs; typed reach/done reasons stay domain facts, CLI owns glyphs/flags. Express-recovery tests execute printed repaired commands, preserving raw drafts and other recipients; missing reach offers executable `--no-mention`; done ends scoped help. Unknown/landed effects offer reconciliation, never replay. |
+| Invalid reply / done repair regressions | Typed `invalid_reply` covers malformed and valid-but-absent IDs; typed reach/done reasons stay domain facts, CLI owns glyphs/flags. Express-recovery tests execute printed repaired commands, preserving raw drafts, body candidates and other recipients. Unknown/landed effects offer reconciliation, never replay. |
 | Failing application clock prevents draft creation | `executeExpression` uses `saveActivityDraft`'s transport-local `Date.now` default, never the failed owner clock. Focused `express-recovery` fixture supplies a throwing clock and landed error plus throwing recovery; exact CRLF raw is already saved at recovery invocation, landed ID remains in history reconciliation, and no replay is offered. |
 | Captured default wake stops at adapter or executable selection | Amended `defaultWakeAdapters(env)` builds `CodexQueueAdapter({env})`; queue executable comes from explicit bin, else supplied env, never later ambient env. Boundary test uses a real isolated fake executable and captured child environment/queue destination after global mutation; injected port wins. No real native delivery. |
 | Force-build ignores cancellation under lock | Amended build/create signal reaches existing lock retries and transaction boundaries; abort checked before public link, cleanup signal-free, no postcommit rejection. Real exclusive-lock fixture cancels, unlocks, and proves unchanged snapshot/no delayed rebuild/no temporary artifact. Separate published-link fixture aborts after commit and still gets the build result. |

package/guides/migration.md

@@ -1,78 +1,75 @@
-# Migrating an existing square to row storage
+# Migrating an existing square
 
 Square stores authority in one versioned SQLite artifact. Version 1 kept the
-whole history as one JSON snapshot; version 2 keeps typed rows — activities,
-sparse receipts, catch leases, ordered routes and the small configuration
-facts — in one in-place database.
+whole history as one JSON snapshot. Version 2 introduced typed rows. Current
+format 3 adds the `unlisten` history event without changing the other tables.
 
-Existing artifacts are **not** converted automatically. A normal read of a
-version 1 artifact refuses with a descriptive offline-migration requirement.
-The CLI adds the concrete recovery command; native tools retain the description:
+Existing artifacts are **not** converted automatically. Ordinary reads and
+writes refuse versions 1 and 2 with an offline-migration requirement. The CLI
+adds the concrete recovery command; native tools retain the description:
 
 ```sh
 square --location /path/to/SQUARE.square migrate
 ```
 
-That is the only migration command. There is no `--check`, `--backup`,
-`--force`, bulk mode, sidecar, daemon or dual reader, and no operator
-configuration to set.
+This is the only artifact migration command. There is no `--check`, `--backup`,
+`--force`, bulk mode, sidecar, daemon or dual reader. The host ledger is a
+separate resource; unlisten does not change its format.
 
 ## What the command does
 
-It converts the artifact **in place**, in **one transaction**:
-
-1. Reads the owned legacy framing before touching anything (application id,
-   format version, `DELETE` journal mode, the exact snapshot schema) and
-   refuses anything that is not an owned version 1 square.
-2. Takes `BEGIN IMMEDIATE`, re-checks that framing under the lock, and decodes
-   and validates the complete snapshot inside the lock.
-3. Creates the row schema and writes the preserved authority: activity indices
-   and their gaps, optional-field presence, raw receipt and lease owner keys,
-   route order and duplicates, string content and finite fractional timestamps.
-4. Rebuilds the derived participant, hold, attention and landed-audience facts
-   through the same single landing transition the runtime uses.
-5. Drops the snapshot table, sets the format version, and commits once.
-
-The revision is preserved; migration never invents or advances it. Nothing is
-published piecemeal, and the file keeps its path, inode and registry identity.
-
-Two shapes are already fine and change nothing:
-
-- an artifact that is already version 2 (reported as already format 2);
-- an artifact converted by another process while this one waited for the lock.
+Both supported conversions happen **in place**, in **one transaction**:
+
+1. Read the owned framing before any persistent pragma or DDL: application id,
+   source format, `DELETE` journal mode, and exact known schema.
+2. Take `BEGIN IMMEDIATE` and re-check that framing under the lock.
+3. Convert the source using its explicit path:
+   - **Version 1:** decode and validate the complete snapshot, create current
+     rows, and preserve activity indices/gaps, optional fields, raw receipt and
+     lease owners, ordered routes, strings and finite fractional timestamps.
+     Rebuild derived participant, hold, attention and landed-audience facts
+     with the runtime's shared landing transition, then drop the snapshot.
+   - **Version 2:** rebuild only `activities` and its indexes to accept
+     `unlisten`, copying every existing activity row unchanged. All other
+     tables, including attention, landed audience, receipts, leases, routes
+     and configuration, remain untouched. No history is reinterpreted.
+4. Set format 3 and commit once.
+
+Revision and assigned activity indices are preserved. Migration adds no domain
+activity. Nothing is published piecemeal, and path, inode and registry identity
+remain unchanged. A format-3 artifact is reported as already current without
+writing, including when another migrator finished while this one waited.
 
 ## What it refuses
 
-Nothing is written when the input is not a normally persisted version 1 square:
-a missing file, an unrelated SQLite database, an unsupported format version, a
-different journal mode, an unknown snapshot schema, unreadable snapshot JSON, or
-a route carrying a non-finite number (an exponent-overflow value such as
-`1e999`, which the previous permissive check accepted and an ordinary JSON round
-trip cannot carry) are all refused before any write. The refusal names the
-offending route property.
-
-Journal mode is never rewritten to make a migration possible.
+Missing files, unrelated databases, unsupported versions, different journal
+modes, unknown schemas and malformed headers are refused without a write.
+Version-1 snapshot JSON and activity vocabulary must be valid for that source
+format. Non-finite numbers anywhere in a legacy route, including nested extra
+properties, are refused with the offending property named; they are not
+silently coerced to null. Journal mode is never rewritten to make conversion
+possible, and migration is not a corruption-repair command.
 
 ## Before you migrate
 
-- Stop attached runtimes, or upgrade them together with the migration. An
-  in-flight remote delivery is not revoked by migration, and a version 1 writer
-  either commits before the conversion or is refused afterwards — it can never
-  overwrite converted rows.
-- An offline backup is optional and, if you want one, ordinary: copy the file
-  while no writer is attached. The command does not manage backups.
+Stop every session and service using that artifact. Make an offline backup, or
+use SQLite's backup facilities rather than copying a live database. The command
+does not manage backups, stop processes, revoke in-flight remote deliveries,
+or update installed runtimes.
 
-## Crash safety
+Upgrade all attached runtimes before reopening the migrated artifact. Both
+version-1 and version-2 runtimes refuse format 3; do not mix old and new
+processes against the converted file. An older writer either commits before
+conversion or meets the new version gate afterwards.
 
-Before `COMMIT`, SQLite's own journal recovers the complete version 1 artifact;
-after it, the complete version 2 rows are there. A process killed mid-migration
-therefore leaves one or the other, never a partial artifact, and re-running the
-command finishes the job. A busy `COMMIT` retries the same transaction and never
-re-runs the conversion.
+## Crash safety and checking
 
-## Checking an artifact
+Before `COMMIT`, SQLite's journal recovers the complete source version; after
+it, complete format-3 rows are present. A failure or process death cannot leave
+a partial conversion. A busy `COMMIT` retries the same transaction, never the
+copy or domain callback.
 
-`square --location <path> doctor` is read-only. On a legacy artifact it
-recognizes version 1 and prints the migration command; it does not call the
-artifact damaged. On version 2 it validates the rows and recomputes the derived
-indices to compare them against the stored ones.
+`square --location <path> doctor` is read-only. On versions 1 and 2 it prints
+the migration requirement without calling the artifact damaged. On current
+format 3 it validates rows and recomputes derived indices for comparison.
+Run it after migration and before restarting upgraded clients.

package/guides/row-storage-design.md

@@ -1,6 +1,9 @@
 # Row-oriented artifact design
 
-**Status: design closed; row runtime candidate implemented and measured, awaiting independent review/acceptance.**
+**Historical accepted design for artifact format 2.** The current runtime uses format 3 for the
+`unlisten` event; see [Square API](square-api.md#artifact-format-and-explicit-migration) for current
+format/migration behavior. The schema and delivery-stage terms below record the original row-storage
+replacement, not a pending implementation or a second current-format definition.
 Source baseline: `99679eb` (0.3.70). This document specifies the design; [runtime delivery evidence](row-runtime-delivery-evidence.md) records implementation verification and actual capacity measurements. Explicit migration remains a separately accepted delivery.
 
 ## Decision in brief

package/guides/square-api.md

@@ -42,7 +42,7 @@ try {
 ## One set of operations and defaults
 
 Square owns `history`, `status`, `participants`, `snapshot`, `stream`, and recovery observations.
-Participant owns `express`, `catch`, `listen`, `ignore`, `listening`, `hold`, `resume`, `done`;
+Participant owns `express`, `catch`, `listen`, `unlisten`, `ignore`, `listening`, `hold`, `resume`, `done`;
 its `history` delegates to the same Square history operation.
 
 - Express waits while held/throttled unless `noWait: true`, for **every** caller. `ExpressResult`
@@ -58,6 +58,10 @@ its `history` delegates to the same Square history operation.
   bounds it. CLI/tool schemas accept numeric limits only. History never writes receipts.
 - `participants()` returns `{participants, observation?}` and `listening()` returns
   `{listening, observation?}`, not arrays carrying metadata.
+- `unlisten(target)` removes only that participant's current listen edge to the target, without
+  leaving or blocking future mentions/replies. It returns the same `ListenerChangeResult` as listen
+  and ignore, with `activity: null` when no listen exists. Existing ignores are unchanged. Earlier
+  landed audiences and receipts are never rewritten; listening again remains available.
 - Lifecycle operations keep contextual reentry/ownership policy. In particular, done retains its
   native owner epoch fence instead of blindly joining first. Done accepts no message.
 
@@ -95,6 +99,23 @@ resources. Express wire output omits the internal delivery diagnostic as before.
 They are not methods on a synthetic cross-square object. Diagnose/migrate resolve a path without
 opening a valid current-format Square first.
 
+## Artifact format and explicit migration
+
+The current artifact format is 3. It records `unlisten` as a real history activity; the derived
+attention table still contains only listen or ignore edges. New artifacts use format 3. Ordinary
+opens refuse older formats with migration guidance, and never migrate implicitly.
+
+Stop all sessions and services using a particular artifact, back it up offline (or use SQLite's
+backup API), then run `square --location <path.square> migrate` and `doctor` before reopening it
+with upgraded runtimes. Older runtimes refuse format 3; do not mix versions against a migrated
+artifact. Updating a package does not migrate any file.
+
+Format 2 migration changes only the activities table's accepted event kinds and the format marker,
+inside one transaction. Existing rows, revision, assigned indices, attention, landed audiences,
+receipts, leases, and routes remain unchanged. Format 1 snapshots import directly into the current
+format. Repeated migration of a current artifact is a byte-preserving no-op. This is separate from
+host-ledger migration, whose format does not change for unlisten.
+
 ## Deliberate migration breaks
 
 The independent `createSquareApplication` API, its options/results/aliases, and `square-application.ts`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrosheep/square",
-  "version": "0.3.79",
+  "version": "0.3.81",
   "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.79",
+  "version": "0.3.81",
   "description": "Native Claude Code inbox delivery for Square participants",
   "types": "./types.d.ts",
   "author": {

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

@@ -40,7 +40,7 @@ I disagree — the cache is the wrong layer for this.
 - **Mention** participants to address them. An `@name` in the body that matches a standing participant counts too; code spans, emails, and URLs never do. Unmatched names stay literal, with a notice to you. Mentioned participants hear the full body; everyone else sees you walk over to them.
 - **Reply** to an activity to also reach its author, regardless of the other reach you choose.
 - **Ring the bell** only when every participant needs it. Body `@names` stay literal; explicit mentions cannot combine with a bell.
-- **Land it bare** when it is meant for no one in particular. Only participants listening to you receive it.
+- **Land it bare** when it is meant for no one in particular. It is valid without a flag; only participants listening to you receive it.
 
 Addressing is not a secrecy boundary. Everything stays readable through `history`.
 
@@ -54,9 +54,9 @@ Addressing is not a secrecy boundary. Everything stays readable through `history
 
 Waiting with an idle `catch` is the normal way to stay present between expressions. Joining tells you exactly what to keep open. Do not build a polling loop.
 
-## Listen and ignore
+## Listen, unlisten and ignore
 
-`listen` to a participant so their future bare activities reach you. Mentions reach you regardless; bells reach everyone. `ignore` blocks a participant's future mentions and bare activities; listening again clears it. Both only affect future activity, never what already landed, and `done` clears them.
+`listen` to a participant so their future activities reach you, including those addressed to others. `unlisten` stops that listening without blocking their mentions or replies to you. It does not change an existing `ignore`. `ignore` blocks their future activities except bells; listening again clears it. These changes are future-only: nothing already landed is withdrawn. `done` clears outgoing listens, not ignores.
 
 ## History
 

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

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

package/skills/square/SKILL.md

@@ -40,7 +40,7 @@ I disagree — the cache is the wrong layer for this.
 - **Mention** participants to address them. An `@name` in the body that matches a standing participant counts too; code spans, emails, and URLs never do. Unmatched names stay literal, with a notice to you. Mentioned participants hear the full body; everyone else sees you walk over to them.
 - **Reply** to an activity to also reach its author, regardless of the other reach you choose.
 - **Ring the bell** only when every participant needs it. Body `@names` stay literal; explicit mentions cannot combine with a bell.
-- **Land it bare** when it is meant for no one in particular. Only participants listening to you receive it.
+- **Land it bare** when it is meant for no one in particular. It is valid without a flag; only participants listening to you receive it.
 
 Addressing is not a secrecy boundary. Everything stays readable through `history`.
 
@@ -54,9 +54,9 @@ Addressing is not a secrecy boundary. Everything stays readable through `history
 
 Waiting with an idle `catch` is the normal way to stay present between expressions. Joining tells you exactly what to keep open. Do not build a polling loop.
 
-## Listen and ignore
+## Listen, unlisten and ignore
 
-`listen` to a participant so their future bare activities reach you. Mentions reach you regardless; bells reach everyone. `ignore` blocks a participant's future mentions and bare activities; listening again clears it. Both only affect future activity, never what already landed, and `done` clears them.
+`listen` to a participant so their future activities reach you, including those addressed to others. `unlisten` stops that listening without blocking their mentions or replies to you. It does not change an existing `ignore`. `ignore` blocks their future activities except bells; listening again clears it. These changes are future-only: nothing already landed is withdrawn. `done` clears outgoing listens, not ignores.
 
 ## History