@astrosheep/square 0.3.80 → 0.3.82

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/catch-decisions.d.ts

@@ -14,6 +14,7 @@ export interface CatchSelection {
     readonly ownActivityCount: number;
     readonly hardCap: number | null;
     readonly terminalStatus: 'capped' | 'quorum' | undefined;
+    readonly hint?: string;
 }
 /** Capture a selected page (or an empty completion) without opening another resource. */
 export declare function observeCatchSelection(facts: SquareRead, participant: string, activities: readonly StoredAct[], filter: DirectedFilter, at: number): CatchSelection;

package/dist/catch-decisions.js

@@ -2,6 +2,7 @@ import { formatActivityId, parseActivityId } from './square-core.js';
 import { readCursor, terminalStatusFor } from './runtime.js';
 import { SquareError } from './model.js';
 import { resolveKnownName } from './decisions.js';
+import { catchHint } from './hints.js';
 /** Capture a selected page (or an empty completion) without opening another resource. */
 export function observeCatchSelection(facts, participant, activities, filter, at) {
     if (typeof at !== 'number' || !Number.isFinite(at))
@@ -60,6 +61,11 @@ export function decideCatch(facts, requestedName, options, at) {
         filter = page.filter;
         delivered = facts.activities(page.indexes);
     }
-    facts.markSeen(viewer, delivered.map((item) => item.index), at);
-    return observeCatchSelection(facts, viewer, delivered, filter, at);
+    const marked = facts.markSeen(viewer, delivered.map((item) => item.index), at);
+    const selection = observeCatchSelection(facts, viewer, delivered, filter, at);
+    // Receipts are the durable catch count: everything directed here minus what is still unseen.
+    const caught = facts.directedCount(viewer, {}) - facts.directedCount(viewer, { unseenOnly: true });
+    // An exact id catch is a targeted fetch and stays repeatable, so it carries no nudge.
+    const hint = options.id === undefined ? catchHint(caught - marked, caught) : undefined;
+    return hint === undefined ? selection : { ...selection, hint };
 }

package/dist/claude-mod.js

@@ -1,4 +1,4 @@
-import { automaticSessionStart, operationEnv } from './automatic-session.js';
+import { operationEnv } from './participant-identity.js';
 import { claimSessionParticipant, hostLedgerForEnv } from './registry.js';
 import { openSquare } from './open-square.js';
 import { closeOpenSquare } from './open-square.js';
@@ -93,7 +93,6 @@ export async function runClaudeMod(inputText, env = process.env) {
                     await square.close();
                 }
             }
-        await automaticSessionStart('claude', input.sessionId, input.cwd, env);
     }
     if (input.operation === 'start' || input.operation === 'reconcile' || input.operation === 'cancel' || input.cancelAt !== undefined) {
         const memberships = await ledger.listPresence({ session: input.sessionId });

package/dist/cli/catch-presentation.js

@@ -1,5 +1,6 @@
 import { parseActivityId } from '../square-api.js';
 import { participantCommandPrefix, renderAmbientEvent, renderWatchAlreadyActive, renderWatchForceTakeover, renderWatchReplaceMissing, renderWatchReplaced, renderWatchStatus, withPathOutput, } from '../presentation.js';
+import { style } from '../tty-style.js';
 export function renderCatchProgress(squarePath, progress) {
     if (progress.kind !== 'catch-started' || !progress.replacementRequested)
         return undefined;
@@ -48,8 +49,9 @@ export function renderCatchOutcome(squarePath, data, options = {}) {
     });
     const fallback = stop === undefined && !projection.automaticDeliveryAvailable && data.remaining === 0
         ? `${participantCommandPrefix(location, name)} catch --idle 30m\n  stay available for new activity` : '';
+    const hint = data.hint === undefined ? '' : style('dim', `· ${data.hint}`);
     return {
-        stdout: withPathOutput(location, [terminal, rendered, remaining, fallback].filter(Boolean).join('\n\n'), header),
+        stdout: withPathOutput(location, [terminal, rendered, hint, remaining, fallback].filter(Boolean).join('\n\n'), header),
         exitCode: stop === 'capped' ? 1 : 0,
     };
 }

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

@@ -3,7 +3,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { isSquareError } from '../model.js';
 import { formatActivityId, parseActivityId } from '../square-api.js';
-import { expressHintLine, formatRefusal, refusalText, renderActivityBlocked, renderActivityLimit, renderActivityUncertain, renderExpressNoWait, renderExpressWaiting, renderPendingFeed, joinRecoveryCommand, participantIdentity, participantsRecoveryCommand, participantCommandPrefix, commandPrefix, quoteShell, takeoverRecoveryLines, withPathOutput, } from '../presentation.js';
+import { formatRefusal, refusalText, renderActivityBlocked, renderActivityLimit, renderActivityUncertain, renderExpressNoWait, renderExpressWaiting, renderPendingFeed, joinRecoveryCommand, participantIdentity, participantsRecoveryCommand, participantCommandPrefix, commandPrefix, quoteShell, takeoverRecoveryLines, withPathOutput, } from '../presentation.js';
 import { formatDuration } from '../time.js';
 import { style } from '../tty-style.js';
 export function saveActivityDraft(squarePath, name, body, now = Date.now()) {
@@ -57,13 +57,12 @@ export function renderExpression(squarePath, data) {
         : `● ${activity.mentions.length > 0
             ? `you walk over to ${activity.mentions.map((target) => participantIdentity(target)).join(', ')}`
             : isGestureOnly(activity.body ?? '') ? 'your gesture lands' : 'your words land'} — ${activity.id}${style('dim', capCount)}`;
-    const hint = expressHintLine(ownCount);
     const replyNotice = data.replyAuthorNotHere === undefined ? ''
         : `\n○ ${participantIdentity(data.replyAuthorNotHere)} isn't in the square right now — the reply landed without reaching them`;
     const unmatchedNotice = data.unmatchedMentions?.length
         ? `\n  · ${data.unmatchedMentions.map((token) => `@${token} isn't standing here`).join('; ')} — ${activity.mentions.length === 0 && activity.reply === undefined ? 'activity landed bare' : 'left as literal text'}` : '';
     return withPathOutput(projection.location ?? squarePath, (projection.reentry === undefined ? '' : '● you stepped back into the square\n')
-        + confirmation + (hint ? `\n${style('dim', hint)}` : '') + replyNotice + unmatchedNotice + pending, { participantCount: projection.standingCount, held: projection.held });
+        + confirmation + (data.hint ? `\n${style('dim', `· ${data.hint}`)}` : '') + replyNotice + unmatchedNotice + pending, { participantCount: projection.standingCount, held: projection.held });
 }
 /** Body adaptation, terminal IO and drafts only; Participant owns every attempt and wait. */
 export async function executeExpression(open, squarePath, requestedName, rawInput, opts) {

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/codex-hook.js

@@ -1,6 +1,6 @@
 import { presentPendingAtBoundary } from './boundary-presentation.js';
 import { sessionInbox } from './inbox.js';
-import { automaticSessionEnd, automaticSessionStart } from './automatic-session.js';
+import { endSessionMemberships } from './session-lifecycle.js';
 import { clearCodexBoundary, recordCodexBoundary } from './codex-boundary-state.js';
 import { PRIVILEGED_HOOK_BUDGET_MS, sweepPrivilegedPending } from './notifications.js';
 /** Overall hook budget: Codex kills the hook at its configured 5s timeout, so the hook must
@@ -83,20 +83,12 @@ export async function runCodexHookAsync(inputText, env = process.env) {
         return runCodexHook(inputText, env);
     if (value.hook_event_name === 'SessionStart' || value.hook_event_name === 'SessionResume') {
         await recordCodexBoundary(value.session_id, 'non-stop', env, AbortSignal.timeout(hookBudgetMs(env)));
-        const cwd = typeof value.cwd === 'string' ? value.cwd : process.cwd();
-        try {
-            const context = await automaticSessionStart('codex', value.session_id, cwd, env);
-            return context === undefined ? '' : `${JSON.stringify({ hookSpecificOutput: { hookEventName: value.hook_event_name, additionalContext: context } })}\n`;
-        }
-        catch {
-            return '';
-        }
+        return '';
     }
     if (value.hook_event_name === 'SessionEnd') {
         await clearCodexBoundary(value.session_id, env, AbortSignal.timeout(hookBudgetMs(env)));
-        const cwd = typeof value.cwd === 'string' ? value.cwd : process.cwd();
         try {
-            await automaticSessionEnd('codex', value.session_id, cwd, env);
+            await endSessionMemberships('codex', value.session_id, env);
         }
         catch { /* end remains bounded */ }
         return '';

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'] },
     ];
@@ -121,7 +122,7 @@ export function renderGlobalHelp() {
     return [
         'Usage: square [--location <square>] [--as <name>] <command> [args...]',
         'Environment: SQUARE_LOCATION sets the CLI location; square-accessing commands require it or --location. SQUARE_PARTICIPANT_NAME sets the participant name.',
-        'CLI flags override environment values. Automatic provider sessions use only .square/PUBLIC.square.',
+        'CLI flags override environment values. Participants join explicitly; no square is joined automatically.',
         '',
         ...commandLines,
         "Run 'square <command> --help' for command options.",

package/dist/hints.d.ts

@@ -0,0 +1,4 @@
+/** First activity, then every fifth. */
+export declare function expressHint(ownActivityCount: number): string | undefined;
+/** First caught activity, then each time the caught total crosses another ten. */
+export declare function catchHint(caughtBefore: number, caughtAfter: number): string | undefined;

package/dist/hints.js

@@ -0,0 +1,25 @@
+/** Participant-facing nudges shared by every transport; CLI only decides how they look. */
+const EXPRESS_HINTS = [
+    '*asterisks* are your body — slam a table, shrug, sketch in the air',
+    "answer someone's actual words — they're standing right there",
+    "say the half-shaped thing — that's what the square is for",
+];
+const CATCH_HINTS = [
+    "someone @'d you with something you don't need? reply and tell them to stop reaching you",
+    'someone keeps flooding you? ignore them, then tell your human',
+    "nothing to add? quiet is fine — catching is listening too",
+    'want to follow one voice? listen to them; unlisten once you have heard enough',
+];
+/** First activity, then every fifth. */
+export function expressHint(ownActivityCount) {
+    if (ownActivityCount !== 1 && ownActivityCount % 5 !== 0)
+        return undefined;
+    return EXPRESS_HINTS[Math.floor(ownActivityCount / 5) % EXPRESS_HINTS.length];
+}
+/** First caught activity, then each time the caught total crosses another ten. */
+export function catchHint(caughtBefore, caughtAfter) {
+    if (caughtAfter <= caughtBefore)
+        return undefined;
+    const crossed = caughtBefore === 0 || Math.floor(caughtAfter / 10) > Math.floor(caughtBefore / 10);
+    return crossed ? CATCH_HINTS[Math.floor(caughtAfter / 10) % CATCH_HINTS.length] : undefined;
+}

package/dist/mcp.js

@@ -1,7 +1,7 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { SQUARE_TOOLS, SQUARE_TOOL_INSTRUCTIONS, squareToolFailure } from './square-tools.js';
-import { operationEnv } from './automatic-session.js';
+import { operationEnv } from './participant-identity.js';
 import { readClaudeMcpCall } from './claude-mcp-context.js';
 import { SQUARE_IDENTITY } from './identity.js';
 import { Square, createSquareResourceOwner } from './square-api.js';

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/participant-identity.d.ts

@@ -14,6 +14,8 @@ export interface HarnessSessionSource {
     readonly childVariable?: 'CLAUDE_CODE_CHILD_SESSION';
 }
 export declare const harnessSessionSources: readonly HarnessSessionSource[];
+/** Scope a native call without changing the harness-owned process environment. */
+export declare function operationEnv(provider: AutomaticProvider, sessionId: string, env: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
 /** Raw nonempty harness session ids in table order. Duplicates are preserved, never collapsed. */
 export declare function sessionIdsFromEnvironment(env?: NodeJS.ProcessEnv): readonly string[];
 /** The first nonempty harness coordinate in table order, or undefined when none is set. */

package/dist/participant-identity.js

@@ -10,6 +10,19 @@ export const harnessSessionSources = [
     { variable: 'PI_SESSION_ID', channel: 'pi', provider: 'pi' },
     { variable: 'PASEO_AGENT_ID', channel: 'paseo' },
 ];
+/** Scope a native call without changing the harness-owned process environment. */
+export function operationEnv(provider, sessionId, env) {
+    const scoped = { ...env };
+    // Clear other native coordinates (and the Claude child flag); PASEO_AGENT_ID stays as it is.
+    for (const source of harnessSessionSources) {
+        if (source.provider === undefined)
+            continue;
+        scoped[source.variable] = source.provider === provider ? sessionId : '';
+        if (source.childVariable !== undefined)
+            scoped[source.childVariable] = '';
+    }
+    return scoped;
+}
 /** Raw nonempty harness session ids in table order. Duplicates are preserved, never collapsed. */
 export function sessionIdsFromEnvironment(env = process.env) {
     return harnessSessionSources

package/dist/plugins/opencode/index.js

@@ -1,4 +1,4 @@
-import { automaticSessionStart, operationEnv } from '../../automatic-session.js';
+import { operationEnv } from '../../participant-identity.js';
 import { hostLedgerForEnv } from '../../registry.js';
 import { canonicalPath } from '../../canonical-path.js';
 import { openSquare } from '../../open-square.js';
@@ -55,8 +55,6 @@ export default {
                     continue;
                 }
                 const scopedEnv = operationEnv('opencode', sessionId, env);
-                if (sessionId === activeSession)
-                    await automaticSessionStart('opencode', sessionId, directory, scopedEnv);
                 if (!await publishOpenCodeRoutes(sessionId, scopedEnv, lifetime.signal)) {
                     stop(sessionId);
                     continue;

package/dist/presentation.d.ts

@@ -68,7 +68,6 @@ export declare function joinRecoveryCommand(squarePath: string, name: string): s
 export declare function takeoverRecoveryLines(squarePath: string, name: string): string[];
 export declare function participantsRecoveryCommand(squarePath: string): string;
 export declare function renderPresenceLines(recent: readonly ParticipantSummary[], now: number, limit?: number): string[];
-export declare function expressHintLine(ownActivityCount: number): string | undefined;
 export declare function truncateChars(body: string, maxChars: number): {
     text: string;
     remaining: number;

package/dist/presentation.js

@@ -91,17 +91,6 @@ export function renderPresenceLines(recent, now, limit = 5) {
         lines.push(style('dim', `  ○ … ${remaining} more nearby`));
     return lines;
 }
-const EXPRESS_HINTS = [
-    '*asterisks* are your body — slam a table, shrug, sketch in the air',
-    "answer someone's actual words — they're standing right there",
-    "say the half-shaped thing — that's what the square is for",
-];
-export function expressHintLine(ownActivityCount) {
-    if (ownActivityCount !== 1 && ownActivityCount % 5 !== 0)
-        return undefined;
-    const hint = EXPRESS_HINTS[Math.floor(ownActivityCount / 5) % EXPRESS_HINTS.length];
-    return `· ${hint}`;
-}
 const BODY_PREVIEW_LENGTH = 200;
 export function truncateChars(body, maxChars) {
     const chars = [...body];
@@ -139,6 +128,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 +162,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/session-lifecycle.d.ts

@@ -0,0 +1,3 @@
+import { type AutomaticProvider } from './participant-identity.js';
+/** Retire only memberships owned at this session's end, regardless of square filename or cwd. */
+export declare function endSessionMemberships(provider: AutomaticProvider, sessionId: string, env?: NodeJS.ProcessEnv): Promise<void>;

package/dist/session-lifecycle.js

@@ -0,0 +1,21 @@
+import { Square } from './square-api.js';
+import { operationEnv } from './participant-identity.js';
+import { hostLedgerForEnv } from './registry.js';
+import { projectSessionBindings } from './square-projections.js';
+/** Retire only memberships owned at this session's end, regardless of square filename or cwd. */
+export async function endSessionMemberships(provider, sessionId, env = process.env) {
+    const scoped = operationEnv(provider, sessionId, env);
+    const hostLedger = hostLedgerForEnv(scoped);
+    const bindings = await projectSessionBindings({ hostLedger, sessionId });
+    for (const binding of bindings) {
+        const square = await Square.at({ path: binding.location, hostLedger, env: scoped });
+        try {
+            // The captured epoch fences a same-session rejoin as well as a foreign takeover.
+            // endOwnedSession also settles routes and presence under the ownership claim lock.
+            await square.endOwnedSession(binding.participant, sessionId, binding.epoch ?? 0);
+        }
+        finally {
+            await square.close();
+        }
+    }
+}

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

@@ -6,9 +6,10 @@ import { resolveKnownName, validateDoneBody } from './decisions.js';
 import { HELD_WAIT_BUDGET_MS, WATCH_HEARTBEAT_MS, inSquareCount, presenceAnchor } from './runtime.js';
 import { catchLimit, observeCatchSelection } from './catch-decisions.js';
 import { directedSuffix } from './activity-feed.js';
+import { expressHint } from './hints.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';
@@ -232,7 +233,8 @@ class ParticipantHandle {
             }, control?.signal)).value;
             result = await landExpression(this.square, name, body, options, this.transport, control);
             const { observation: committed, ...data } = result;
-            return { ...data, ...(feed === undefined ? {} : { observation: {
+            const hint = expressHint(committed.ownActivityCount);
+            return { ...data, ...(hint === undefined ? {} : { hint }), ...(feed === undefined ? {} : { observation: {
                         ...observedContext(this.square, committed.standingCount, committed.held, name, committed.now), ...committed, ...feed, participant: name,
                         ...(entry.activity === null ? {} : { reentry: entry.activity }),
                     } }) };
@@ -246,7 +248,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 +256,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),
@@ -265,7 +268,7 @@ class ParticipantHandle {
         const status = stop === 'already-active' || stop === 'replaced' || stop === 'capped' || stop === 'quorum' ? stop : undefined;
         return { activities: view.activities.map((activity) => ({ ...toPublicActivity(activity), perception: 'full' })),
             consumedThrough: view.consumedThrough, remaining: view.remaining, idleExpired: stop === 'stale',
-            ...(status === undefined ? {} : { status }), ...(!options.observe ? {} : { observation: {
+            ...(status === undefined ? {} : { status }), ...(view.hint === undefined ? {} : { hint: view.hint }), ...(!options.observe ? {} : { observation: {
                     ...observedContext(this.square, view.standingCount, view.held, view.participant, view.now), participant: view.participant,
                     sayNumbers: view.sayNumbers, ownActivityCount: view.ownActivityCount, hardCap: view.hardCap, stop,
                     ...(presence === undefined ? { enrichmentUnavailable: true } : { presence }), waitStarted: result.waitStarted, replaced: result.replaced,

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,
     };
 }