@astrosheep/square 0.3.80 → 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/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

@@ -54,8 +54,9 @@ export declare function decideAct(facts: SquareRead, input: {
 }): 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

@@ -171,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`);
     }
@@ -178,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

@@ -34,7 +34,8 @@ const COMMANDS = [
             '  --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

@@ -99,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, 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';
@@ -238,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;
@@ -246,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[];
@@ -184,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/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.80",
+  "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.80",
+  "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

@@ -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.80",
+  "version": "0.3.81",
   "description": "Shared Square activity with reliable participant attention at Codex boundaries.",
   "author": {
     "name": "Square"

package/skills/square/SKILL.md

@@ -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