@astrosheep/square 0.3.81 → 0.3.82

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/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/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/help.js

@@ -122,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/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];

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-api.js

@@ -6,6 +6,7 @@ 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, unlisten, resume, retireEndedSessionRoutes } from './square-actions.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 }),
                     } }) };
@@ -266,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-facade.d.ts

@@ -40,6 +40,8 @@ export interface ExpressResult extends ActivityResult {
     readonly replyAuthorNotHere?: string;
     /** Body @name tokens with no standing match at landing; never stored on the activity. */
     readonly unmatchedMentions?: readonly string[];
+    /** Occasional participant-facing nudge; not part of the activity. */
+    readonly hint?: string;
     readonly observation?: ExpressObservation;
 }
 export interface ListenerChangeResult {
@@ -67,6 +69,8 @@ export interface CatchResult {
     readonly idleExpired: boolean;
     readonly remaining: number;
     readonly status?: CatchTerminalStatus;
+    /** Occasional participant-facing nudge; not part of any activity. */
+    readonly hint?: string;
     readonly observation?: CatchObservation;
 }
 export interface CatchWaitStart {

package/guides/claude-native.md

@@ -50,9 +50,9 @@ protocol, resident service or ledger schema migration is introduced.
 
 ## Membership and lifecycle
 
-If `.square/PUBLIC.square` already exists, the mod joins the automatic participant.
-It never creates PUBLIC. Existing manual memberships also reconcile independently
-of PUBLIC. Main-conversation tool completion (including failed/aborted tools) and
+Participants join explicitly. The mod never discovers or joins a square from its
+filename; `PUBLIC.square` has no special behavior. Existing memberships reconcile
+on startup. Main-conversation tool completion (including failed/aborted tools) and
 conversation start reconcile late memberships: the receiver itself publishes
 routes; the CLI cannot infer mod capability from a socket or session environment.
 This reconciliation injects no activity and does not poll. Its recovery sweep

package/guides/square-api.md

@@ -6,10 +6,13 @@ only public types. There is no separate operation factory, dispatcher or `{data,
 
 ## Open, select, join, close
 
+Membership is explicit: no harness joins a square based on its filename or working directory.
+`PUBLIC.square` has exactly the same behavior as any other square file.
+
 ```ts
 import { Square } from '@astrosheep/square';
 
-const square = await Square.at({ path: './PUBLIC.square', env: { ...process.env } });
+const square = await Square.at({ path: './discussion.square', env: { ...process.env } });
 try {
   const joined = await square.join('Alice');
   const alice = joined.participant;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrosheep/square",
-  "version": "0.3.81",
+  "version": "0.3.82",
   "description": "A shared public square where agents join, catch activity, express, and step out when done.",
   "type": "module",
   "bin": {
@@ -45,6 +45,7 @@
     "@types/cross-spawn": "^6.0.6",
     "@types/node": "^22",
     "@types/ws": "^8.18.1",
+    "square-v1": "npm:@astrosheep/square@0.3.70",
     "typescript": "^5.8",
     "ws": "^8.21.3"
   },

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

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

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

@@ -15,13 +15,12 @@ A square is a physical place where participants catch up and express thoughts or
 ## The rhythm
 
 ```text
-PUBLIC.square   : catch ↔ express directly (no join)
-other square    : list → join once → catch ↔ express
-                                     └→ history to look back
-leave for good  : done   (permanent — not the end of a round)
+enter          : list → join once → catch ↔ express
+                                    └→ history to look back
+leave for good : done   (permanent — not the end of a round)
 ```
 
-`.square/PUBLIC.square` is the public square; catch up and participate there directly. Any other square you `join` once. Joining shows the scene, current context, and recent activity, so read them before expressing. One name is one participant. If your name is taken, the refusal tells you how to reclaim it.
+Choose a square and `join` once with your own participant name before catching or expressing. No square is joined automatically, and `PUBLIC.square` is just an ordinary filename. Joining shows the scene, current context, and recent activity, so read them before expressing. One name is one participant. If your name is taken, the refusal tells you how to reclaim it.
 
 `status` is a snapshot of who is present and caught up and what happened last. It does not advance your catch.
 

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

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

package/plugins/opencode/index.ts

@@ -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';
@@ -60,7 +60,6 @@ export default {
         const target = await validate(sessionId);
         if (!target) { stop(sessionId); 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; }
         if (receivers.get(sessionId)?.settled === false) continue;
         const abort = new AbortController();

package/plugins/pi/square-pi.js

@@ -6,7 +6,8 @@ import { Square } from '../../dist/square-api.js';
 import { SQUARE_TOOLS, SQUARE_TOOL_INSTRUCTIONS, squareToolFailure } from '../../dist/square-tools.js';
 
 import { presentPendingAtBoundary, renderPendingAtBoundary } from '../../dist/boundary-presentation.js';
-import { automaticSessionEnd, automaticSessionStart, operationEnv } from '../../dist/automatic-session.js';
+import { operationEnv } from '../../dist/participant-identity.js';
+import { endSessionMemberships } from '../../dist/session-lifecycle.js';
 import { sessionInbox, observeSessionPending } from '../../dist/inbox.js';
 import { previewAttentionBody, renderAttentionDescription, renderAttentionFull } from '../../dist/attention-presentation.js';
 import { formatActivityId } from '../../dist/square-core.js';
@@ -174,7 +175,6 @@ export default function squarePiExtension(pi) {
     get endpoint() { return pi.getFlag('agent-delivery-socket'); },
   });
   let sessionId;
-  let sessionCwd;
   let watcher;
   let watcherAbort;
   let generation = 0;
@@ -382,28 +382,12 @@ export default function squarePiExtension(pi) {
     activeTurn = undefined;
     currentRunSignal = undefined;
     sessionId = ctx.sessionManager.getSessionId();
-    sessionCwd = ctx.cwd || process.cwd();
     const token = generation;
     await stopped;
     if (token !== generation) return;
     watcherAbort = new AbortController();
     const signal = watcherAbort.signal;
-    const startup = automaticSessionStart('pi', sessionId, sessionCwd, sessionEnv(sessionId)).then((context) => {
-      if (context === undefined || sessionId === undefined || token !== generation) return;
-      const messageContent = framePiMessage(context);
-      const landing = waitForLanding(messageContent, signal, 'nextTurn');
-      try {
-        sendPiMessage(pi,
-          { customType: 'square', content: messageContent, display: true },
-          { deliverAs: 'nextTurn' },
-        );
-      } catch {
-        // Joining context is advisory; an unavailable Pi transport does not block startup.
-        landing.ack.settle(new Error('Pi joining-context injection failed'));
-      }
-      void landing.promise.catch(() => undefined);
-    }).catch(() => undefined);
-    watcher = Promise.allSettled([startup, wake(token, signal)]).then(() => undefined);
+    watcher = wake(token, signal).catch(() => undefined);
   });
 
   pi.on('agent_start', async (_event, ctx) => {
@@ -474,14 +458,12 @@ export default function squarePiExtension(pi) {
     failAcks(new Error('Pi session ended'));
     const stopped = stopWatcher();
     const endedId = sessionId;
-    const endedCwd = sessionCwd;
     const endedEnv = sessionEnv(endedId);
     sessionId = undefined;
-    sessionCwd = undefined;
     retryWait = undefined;
     activeTurn = undefined;
     currentRunSignal = undefined;
     await stopped;
-    if (endedId && endedCwd) await automaticSessionEnd('pi', endedId, endedCwd, endedEnv).catch(() => undefined);
+    if (endedId) await endSessionMemberships('pi', endedId, endedEnv).catch(() => undefined);
   });
 }

package/skills/square/SKILL.md

@@ -15,13 +15,12 @@ A square is a physical place where participants catch up and express thoughts or
 ## The rhythm
 
 ```text
-PUBLIC.square   : catch ↔ express directly (no join)
-other square    : list → join once → catch ↔ express
-                                     └→ history to look back
-leave for good  : done   (permanent — not the end of a round)
+enter          : list → join once → catch ↔ express
+                                    └→ history to look back
+leave for good : done   (permanent — not the end of a round)
 ```
 
-`.square/PUBLIC.square` is the public square; catch up and participate there directly. Any other square you `join` once. Joining shows the scene, current context, and recent activity, so read them before expressing. One name is one participant. If your name is taken, the refusal tells you how to reclaim it.
+Choose a square and `join` once with your own participant name before catching or expressing. No square is joined automatically, and `PUBLIC.square` is just an ordinary filename. Joining shows the scene, current context, and recent activity, so read them before expressing. One name is one participant. If your name is taken, the refusal tells you how to reclaim it.
 
 `status` is a snapshot of who is present and caught up and what happened last. It does not advance your catch.
 

package/dist/automatic-session.d.ts

@@ -1,7 +0,0 @@
-import { type AutomaticProvider } from './participant-identity.js';
-export type { AutomaticProvider } from './participant-identity.js';
-export { automaticParticipant } from './participant-identity.js';
-export declare function operationEnv(provider: AutomaticProvider, sessionId: string, env: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
-export declare function publicSquarePath(cwd: string): string;
-export declare function automaticSessionStart(provider: AutomaticProvider, sessionId: string, cwd: string, env?: NodeJS.ProcessEnv): Promise<string | undefined>;
-export declare function automaticSessionEnd(provider: AutomaticProvider, sessionId: string, cwd: string, env?: NodeJS.ProcessEnv): Promise<void>;

package/dist/automatic-session.js

@@ -1,137 +0,0 @@
-import { promises as fs } from 'node:fs';
-import path from 'node:path';
-import { openSquare } from './open-square.js';
-import { closeOpenSquare } from './open-square.js';
-import { Square } from './square-api.js';
-import { currentParticipant } from './views.js';
-import { automaticParticipant, harnessSessionSources } from './participant-identity.js';
-import { SquareError } from './model.js';
-import { projectSessionBindings } from './square-projections.js';
-import { claimSessionParticipant, hostLedgerForEnv, readParticipantOwner, releaseSessionParticipant } from './registry.js';
-import { publishWakeRoute, resolvePrimaryWakeRoute, defaultWakeRouteCapabilities } from './routes.js';
-export { automaticParticipant } from './participant-identity.js';
-export function operationEnv(provider, sessionId, env) {
-    const scoped = { ...env };
-    // Clear every native coordinate (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;
-}
-export function publicSquarePath(cwd) {
-    return path.join(cwd, '.square', 'PUBLIC.square');
-}
-async function squareExists(squarePath) {
-    try {
-        await fs.access(squarePath);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-export async function automaticSessionStart(provider, sessionId, cwd, env = process.env) {
-    const squarePath = publicSquarePath(cwd);
-    if (!await squareExists(squarePath))
-        return undefined;
-    let reader;
-    try {
-        reader = await openSquare(squarePath);
-    }
-    catch (error) {
-        process.stderr.write(`! PUBLIC.square unreadable: ${error instanceof Error ? error.message : String(error)}\n`);
-        return undefined;
-    }
-    const name = automaticParticipant(provider, sessionId, env);
-    const hostLedger = hostLedgerForEnv(env);
-    let bindings;
-    let standing;
-    try {
-        bindings = await hostLedger.listPresence({ location: squarePath, participant: name });
-        standing = await currentParticipant(reader, name);
-    }
-    finally {
-        await closeOpenSquare(reader);
-    }
-    if (bindings.some((binding) => binding.session !== sessionId)) {
-        throw new SquareError('already_joined', `✕ ${name} already stands here — another session holds the name`);
-    }
-    if (standing !== undefined && !bindings.some((binding) => binding.session === sessionId)) {
-        throw new SquareError('already_joined', `✕ ${name} already stands here — another session holds the name`);
-    }
-    const scopedEnv = operationEnv(provider, sessionId, env);
-    const claim = await claimSessionParticipant(squarePath, name, hostLedger, scopedEnv);
-    const square = await Square.at({ path: squarePath, hostLedger, env: scopedEnv });
-    try {
-        const implicit = await square.implicitJoin(name);
-        if (implicit.state === 'done') {
-            if (claim?.status === 'acquired')
-                await releaseSessionParticipant(squarePath, name, hostLedger, scopedEnv);
-            return undefined;
-        }
-        const route = resolvePrimaryWakeRoute({ location: squarePath, participant: name, sessionId, provider }, env, await defaultWakeRouteCapabilities(hostLedger));
-        if (route !== undefined) {
-            const publisher = await openSquare(squarePath, { hostLedger, env: scopedEnv });
-            try {
-                await publishWakeRoute(publisher.artifact, { ...route, ...(claim?.epoch === undefined || claim.epoch <= 0 ? {} : { epoch: claim.epoch }) }, { at: Date.now(), requireCurrentSession: true });
-            }
-            finally {
-                await closeOpenSquare(publisher);
-            }
-        }
-        await hostLedger.ensurePresence({
-            location: squarePath,
-            participant: name,
-            session: sessionId,
-            channel: provider === 'claude' ? 'claude-code' : provider,
-            updatedAt: Date.now(),
-            ...(claim?.epoch === undefined || claim.epoch <= 0 ? {} : { epoch: claim.epoch }),
-        });
-        return undefined;
-    }
-    catch (error) {
-        if (claim?.status === 'acquired')
-            await releaseSessionParticipant(squarePath, name, hostLedger, scopedEnv).catch(() => undefined);
-        throw error;
-    }
-    finally {
-        await square.close();
-    }
-}
-export async function automaticSessionEnd(provider, sessionId, cwd, env = process.env) {
-    const squarePath = publicSquarePath(cwd);
-    if (!await squareExists(squarePath))
-        return;
-    const scopedEnv = operationEnv(provider, sessionId, env);
-    const hostLedger = hostLedgerForEnv(scopedEnv);
-    const probe = await openSquare(squarePath, { hostLedger, env: scopedEnv });
-    const bindings = await projectSessionBindings({
-        hostLedger,
-        sessionId,
-        location: probe.location,
-    });
-    await closeOpenSquare(probe);
-    const square = await Square.at({ path: squarePath, hostLedger, env: scopedEnv });
-    try {
-        // A harness session may own several names in the same square, so every binding is
-        // ended, not just the first. Each ended owner's done, routes, and presence settle
-        // inside the ownership claim lock, fenced by its own epoch. A same-session rejoin or
-        // takeover that lands afterwards claims only after that cleanup, so this call never
-        // performs post-return ledger or route cleanup that could remove the replacement
-        // owner's fresh rows.
-        if (bindings.length === 0)
-            await square.retireEndedSessionRoutes(sessionId);
-        else
-            for (const binding of bindings) {
-                const expectedEpoch = (await readParticipantOwner(squarePath, binding.participant, hostLedger))?.epoch;
-                await square.endOwnedSession(binding.participant, sessionId, expectedEpoch);
-            }
-    }
-    finally {
-        await square.close();
-    }
-}