@astrosheep/square 0.3.65 → 0.3.66

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

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

package/claude-plugin/hooks/register.js

@@ -1,4 +1,4 @@
-// Claude Code 2.1.295 mod. No Node imports, shell interpolation, or child credentials.
+// Claude Code mod. No Node imports, shell interpolation, or child credentials.
 const hasToken = (text) => typeof text === 'string' && /(?:^|\n)\[square-inbox:[a-zA-Z0-9-]+\](?:\n|$)/.test(text);
 
 async function coordinate($) {
@@ -55,6 +55,15 @@ async function cancel($) {
 
 export function register(on) {
   on('session.start', async ($, e, next) => {
+    // Claude refuses plugin tools in sessions started without built-in tools; the inbox must still reconcile.
+    try {
+      await $.tool.register({
+        name: 'square',
+        description: "Run the square CLI. args are exactly the words after `square` in the square skill's commands.",
+        inputSchema: { type: 'object', properties: { args: { type: 'array', items: { type: 'string' } }, stdin: { type: 'string' } }, required: ['args'] },
+        isDeferred: false,
+      });
+    } catch (error) { await $.ui.log(`Square tool unavailable: ${error?.message ?? error}`); }
     await reconcile($).catch(() => undefined);
     return next(e);
   });
@@ -63,7 +72,25 @@ export function register(on) {
     return next(e);
   });
   on('tool.call', async ($, e, next) => {
-    try { return await next(e); }
+    try {
+      if (e.tool !== 'mcp__square__square') return await next(e);
+      const sessionId = await $.session.id();
+      const cwd = await $.session.cwd();
+      // process.run has no signal option; it belongs to this cancellable dispatch.
+      next.signal.throwIfAborted();
+      const result = await $.process.run(['square', ...e.args], {
+        cwd, stdin: e.stdin,
+        env: { CLAUDE_CODE_SESSION_ID: sessionId, CLAUDE_CODE_CHILD_SESSION: e.agentId ? '1' : '' },
+        timeoutMs: 600_000,
+      });
+      let text = result.stdout;
+      if (result.stderr) text += `${text && !text.endsWith('\n') ? '\n' : ''}${result.stderr}`;
+      if (result.exitCode !== 0) {
+        text += `${text && !text.endsWith('\n') ? '\n' : ''}Exit code: ${result.exitCode}`;
+        return { deny: text };
+      }
+      return { result: text };
+    }
     finally { if (!e.agentId) await reconcile($, undefined, 'reconcile').catch(() => undefined); }
   });
   on('turn.start', async ($, e, next) => {

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

@@ -6,6 +6,8 @@ allowed-tools: Bash(square *)
 
 # Square
 
+When a `square` tool is available, call it with the same arguments instead of the shell; pass any `-` body as `stdin`.
+
 Don't treat Square as a public dumping ground. Speak here only when you genuinely think someone else needs to know; otherwise you are needlessly interrupting them.
 
 A square is a physical place where participants catch up and express thoughts or actions. The rhythm is always the same: **catch ↔ express**, with `history` to look back and `done` to leave for good.

package/claude-plugin/types.d.ts

@@ -3,5 +3,6 @@ export type SquareInboxCoordinate = { sessionId: string; cwd: string; version: s
 export type SquareInboxCancellation = { at: number; bindings?: SquareInboxBinding[] };
 export type SquareInboxState = { coordinate: SquareInboxCoordinate; bindings?: SquareInboxBinding[] };
 declare module 'claude-code' {
+  interface McpToolInputs { mcp__square__square: { args: string[]; stdin?: string } }
   interface PluginState { square: { inbox: StateFamily<SquareInboxState>; cancelAt: StateFamily<SquareInboxCancellation> } }
 }

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

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

package/dist/automatic-session.js

@@ -109,25 +109,27 @@ export async function automaticSessionEnd(provider, sessionId, cwd, env = proces
     const scopedEnv = operationEnv(provider, sessionId, env);
     const hostLedger = hostLedgerForEnv(scopedEnv);
     const probe = await openSquare(squarePath, { hostLedger, env: scopedEnv });
-    const binding = (await projectSessionBindings({
+    const bindings = await projectSessionBindings({
         hostLedger,
         sessionId,
         location: probe.location,
-    }))[0];
-    const expectedEpoch = binding === undefined
-        ? undefined
-        : (await readParticipantOwner(squarePath, binding.participant, hostLedger))?.epoch;
+    });
     await closeOpenSquare(probe);
     const square = await Square.at({ path: squarePath, hostLedger, env: scopedEnv });
     try {
-        // The ended owner's done, routes, and presence settle inside the ownership claim
-        // lock. 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 (binding === undefined)
+        // 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
-            await square.endOwnedSession(binding.participant, sessionId, expectedEpoch);
+            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();

package/dist/claude-delivery.js

@@ -10,7 +10,7 @@ import { DeliveryError, connect } from './packages/agent-delivery/src/index.js';
 const marker = /(?:^|\n)\[square-inbox:([a-zA-Z0-9-]+)\](?:\n|$)/g;
 export function nativeTokens(text) { return [...text.matchAll(marker)].map((match) => match[1]); }
 export function nativePayload(token, preview) { return `[square-inbox:${token}]\n${preview}\n[/square-inbox:${token}]`; }
-function nativeSupported(route) { return route.address.version === '2.1.295' && route.address.loaded === 'true' && !!route.address.endpoint; }
+function nativeSupported(route) { return route.address.loaded === 'true' && !!route.address.endpoint; }
 /**
  * The shared entry owns platform policy, token resolution and frame shape; Square
  * owns the payload, the correlation and the evidence. A local write is never proof
@@ -33,7 +33,7 @@ export function createClaudeWakeTransport(hostLedger, env = process.env) {
     return {
         async probe(route) {
             if (!nativeSupported(route))
-                return { outcome: 'not-capable', diagnostic: 'Claude native inbox unavailable: Claude 2.1.295 with a loaded interactive Square mod required.' };
+                return { outcome: 'not-capable', diagnostic: 'Claude native inbox unavailable: a loaded interactive Square mod is required.' };
             try {
                 return (await stat(route.address.endpoint)).isSocket() || { outcome: 'not-capable', diagnostic: 'Claude native inbox endpoint is not a socket.' };
             }
@@ -69,7 +69,7 @@ async function dispatchClaude(request, hostLedger, timeoutMs, beforeSend, env =
     request = { ...request, location: await canonicalPath(request.location) };
     const signal = AbortSignal.timeout(timeoutMs);
     if (!nativeSupported(request.route))
-        return { outcome: 'not-capable', diagnostic: 'Claude native inbox requires Claude 2.1.295 and a loaded interactive Square mod.' };
+        return { outcome: 'not-capable', diagnostic: 'Claude native inbox requires a loaded interactive Square mod.' };
     return hostLedger.withClaimLock(async () => {
         if (signal.aborted)
             return { outcome: 'not-capable', diagnostic: 'Native dispatch deadline elapsed before send.' };

package/dist/claude-mod.js

@@ -17,7 +17,7 @@ export async function runClaudeMod(inputText, env = process.env) {
     const scoped = operationEnv('claude', input.sessionId, env);
     const ledger = hostLedgerForEnv(env);
     const signal = AbortSignal.timeout(2500);
-    const supported = process.platform === 'darwin' && input.version === '2.1.295' && typeof input.endpoint === 'string' && input.endpoint.startsWith('/');
+    const supported = process.platform === 'darwin' && typeof input.endpoint === 'string' && input.endpoint.startsWith('/');
     if (input.operation === 'end') {
         const retired = [];
         const captured = [...input.bindings ?? []];
@@ -156,7 +156,7 @@ export async function runClaudeMod(inputText, env = process.env) {
                     await processActNotificationsOnce(binding.location, index, { env: { ...env, SQUARE_NOTIFY_DELIVERY_WAIT_MS: '200' } });
                 }
             }
-        return `${JSON.stringify({ available: supported, diagnostic: supported ? undefined : 'Native inbox unavailable: requires macOS Claude 2.1.295, an interactive loaded mod and its real endpoint.', bindings, cancelledBindings })}\n`;
+        return `${JSON.stringify({ available: supported, diagnostic: supported ? undefined : 'Native inbox unavailable: requires macOS Claude with an interactive loaded mod and its real endpoint.', bindings, cancelledBindings })}\n`;
     }
     if (!['guard', 'admitted', 'stored'].includes(input.operation) || typeof input.text !== 'string')
         throw new Error('Unknown Claude bridge operation.');

package/dist/harness-claude.js

@@ -71,8 +71,8 @@ export async function doctorClaudePlugin(homeDir, run = runClaude) {
     return [
         fs.existsSync(bundle) ? `✓ Square Claude plugin bundle ${root}` : `○ Square Claude plugin bundle missing ${root}`,
         installed ? `✓ ${CLAUDE_PLUGIN_ID} installed` : `○ ${CLAUDE_PLUGIN_ID} unavailable`,
-        `Claude native inbox: validated on macOS Claude Code 2.1.295 with a trusted, approved interactive mod.`,
-        `Installation or a socket alone does not prove receiver availability; absent/disabled mods, headless unapproved mods, other builds/platforms are unavailable.`,
+        `Claude native inbox: requires macOS Claude Code with a trusted, approved interactive mod.`,
+        `Installation or a socket alone does not prove receiver availability; absent/disabled mods, headless unapproved mods, other platforms are unavailable.`,
         `Queue admission is not model processing. Queued or held native messages cannot be retracted by Square cancellation.`,
         `Live routes and admission/presentation evidence: square harness doctor delivery. No legacy fallback.`,
     ];

package/dist/help.js

@@ -1,7 +1,7 @@
 const COMMANDS = [
     { names: ['help'], usage: 'help [command]', summary: 'Show the command index or help for one command.' },
     { names: ['version'], usage: 'version', summary: 'Print the installed version.', hiddenFromIndex: true },
-    { names: ['mcp-server'], usage: 'mcp-server', summary: 'Start the MCP stdio server.', usesSquare: true, hiddenFromIndex: true, details: ['Set SQUARE_LOCATION and SQUARE_PARTICIPANT_NAME, or pass --location and --as before the command.'] },
+    { names: ['mcp-server'], usage: 'mcp-server', summary: 'Start the MCP stdio server.', usesSquare: true, hiddenFromIndex: true, details: ['Set SQUARE_LOCATION or pass --location before the command.', 'Participant tools accept as on each call. Set the default with SQUARE_PARTICIPANT_NAME or --as.', 'Session identity comes from request _meta.threadId (Codex) or _meta["ai.opencode/sessionID"] (OpenCode), falling back to the startup environment.'] },
     {
         names: ['build'], usage: 'build [--cap <N|unlimited>] [--template <name>] [--throttle N] [-f] < body.md', usesSquare: true, group: 'host',
         summary: 'Create a square from Markdown on stdin.',

package/dist/mcp.js

@@ -2,21 +2,24 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { z } from 'zod/v4';
 import { SquareError, isSquareError } from './model.js';
+import { operationEnv } from './automatic-session.js';
+import { SQUARE_IDENTITY } from './identity.js';
 import { createSquareApplication } from './square-application.js';
 import { toPublicActivity } from './views.js';
 const activityId = z.string().regex(/^act\/(0|[1-9][0-9]*)$/);
 const stringArray = z.array(z.string());
+const participantName = z.string().optional().describe("Participant name, same as --as. Defaults to the server's configured participant.");
 const TOOL_DEFINITIONS = [
-    { name: 'join', description: 'Join the square as the configured participant.', inputSchema: z.object({ takeover: z.boolean().optional() }).strict() },
-    { name: 'express', description: 'Express a message or embodied action in the square.', inputSchema: z.object({ body: z.string(), mentions: stringArray.optional(), reach: z.enum(['bell']).optional(), reply: activityId.optional(), force: z.boolean().optional(), noWait: z.boolean().optional() }).strict() },
-    { name: 'catch', description: 'Catch and consume activities perceptible to the configured participant.', inputSchema: z.object({ id: activityId.optional(), idle: z.number().finite().min(0).optional(), from: stringArray.optional(), mention: z.boolean().optional(), limit: z.number().int().min(1).optional() }).strict() },
+    { name: 'join', description: 'Join the square as a participant.', inputSchema: z.object({ as: participantName, takeover: z.boolean().optional() }).strict() },
+    { name: 'express', description: 'Express a message or embodied action in the square.', inputSchema: z.object({ as: participantName, body: z.string(), mentions: stringArray.optional(), reach: z.enum(['bell']).optional(), reply: activityId.optional(), force: z.boolean().optional(), noWait: z.boolean().optional() }).strict() },
+    { name: 'catch', description: 'Catch and consume activities perceptible to the participant.', inputSchema: z.object({ as: participantName, id: activityId.optional(), idle: z.number().finite().min(0).optional(), from: stringArray.optional(), mention: z.boolean().optional(), limit: z.number().int().min(1).optional() }).strict() },
     { name: 'history', description: 'Read the activity stream using stable activity-id cursors.', inputSchema: z.object({ 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() }).strict() },
-    { name: 'listen', description: 'Listen for future activity from a participant.', inputSchema: z.object({ target: z.string() }).strict() },
-    { name: 'ignore', description: 'Stop listening for future activity from a participant.', inputSchema: z.object({ target: z.string() }).strict() },
-    { name: 'listening', description: 'List participants this participant is listening to.', inputSchema: z.object({}).strict() },
-    { name: 'hold', description: 'Raise a hand to hold the square.', inputSchema: z.object({ reason: z.string().optional() }).strict() },
-    { name: 'resume', description: 'Release the current hold.', inputSchema: z.object({}).strict() },
-    { name: 'done', description: 'Leave the square without adding a message.', inputSchema: z.object({}).strict() },
+    { name: 'listen', description: 'Listen for future activity from a participant.', inputSchema: z.object({ as: participantName, target: z.string() }).strict() },
+    { name: 'ignore', description: 'Stop listening for future activity from a participant.', inputSchema: z.object({ as: participantName, target: z.string() }).strict() },
+    { name: 'listening', description: 'List participants this participant is listening to.', inputSchema: z.object({ as: participantName }).strict() },
+    { name: 'hold', description: 'Raise a hand to hold the square.', inputSchema: z.object({ as: participantName, reason: z.string().optional() }).strict() },
+    { name: 'resume', description: 'Release the current hold.', inputSchema: z.object({ as: participantName }).strict() },
+    { name: 'done', description: 'Leave the square without adding a message.', inputSchema: z.object({ as: participantName }).strict() },
     { name: 'status', description: 'Read the public status of the square.', inputSchema: z.object({}).strict() },
     { name: 'participants', description: 'List participants standing in or done with the square.', inputSchema: z.object({}).strict() },
 ];
@@ -71,14 +74,23 @@ function operation(app, name, args, control) {
     }
 }
 export function createSquareMcpServer(options) {
-    const app = createSquareApplication(options);
-    const server = new McpServer({ name: 'square', version: '0.3.61' }, {
+    const baseEnv = { ...options.env };
+    const server = new McpServer({ name: 'square', version: SQUARE_IDENTITY.packageVersion }, {
         instructions: 'The catch tool consumes activities. Use history with act/<index> cursors for read-only archive access.',
     });
     for (const tool of TOOL_DEFINITIONS) {
         server.registerTool(tool.name, { description: tool.description, inputSchema: tool.inputSchema }, async (args, extra) => {
             try {
-                const value = await operation(app, tool.name, args, { signal: extra.signal });
+                const { as: participant, ...operationArgs } = args;
+                const threadId = extra._meta?.threadId;
+                const opencodeSessionId = extra._meta?.['ai.opencode/sessionID'];
+                const env = typeof threadId === 'string' && threadId.trim()
+                    ? operationEnv('codex', threadId, baseEnv)
+                    : typeof opencodeSessionId === 'string' && opencodeSessionId.trim()
+                        ? operationEnv('opencode', opencodeSessionId, baseEnv)
+                        : baseEnv;
+                const app = createSquareApplication({ ...options, env, participant: participant ?? options.participant });
+                const value = await operation(app, tool.name, operationArgs, { signal: extra.signal });
                 const projected = publicResult(tool.name, value);
                 const structuredContent = isObject(projected) ? projected : { result: projected };
                 return { content: [{ type: 'text', text: JSON.stringify(structuredContent) }], structuredContent };

package/dist/wake-eligibility.js

@@ -1,6 +1,7 @@
 import { nameKey } from './model.js';
 import { deriveDeliveryModel } from './delivery.js';
 import { formatActivityId, parseActivityId } from './square-core.js';
+import { presenceEpoch } from './registry.js';
 import { decodeWakeEvidence } from './wake-evidence.js';
 function identity(...parts) { return JSON.stringify(parts); }
 /** One strict ownership join, latest selection, and request fence over primary evidence only. */
@@ -16,7 +17,7 @@ export function projectWakeEligibility(input) {
         ownersBySession.set(key, rows);
     }
     const ownerFor = (route) => route.location !== input.location ? undefined
-        : ownersBySession.get(identity(nameKey(route.participant), route.sessionId))?.find((row) => route.epoch === undefined || row.epoch === route.epoch);
+        : ownersBySession.get(identity(nameKey(route.participant), route.sessionId))?.find((row) => route.epoch === undefined || presenceEpoch(row) === route.epoch);
     const ownedRoutes = [];
     const latest = new Map();
     for (const route of input.state.routes ?? []) {

package/guides/claude-native.md

@@ -7,11 +7,11 @@ not evidence of a live receiver.
 
 ## Validated capability
 
-The supported baseline is **macOS Claude Code 2.1.295 with the mod actually
-loaded**. The receiver reads its real session ID, cwd, version, and
+The supported baseline is **macOS Claude Code with the mod actually loaded**;
+no build number is pinned. The receiver reads its real session ID, cwd, version, and
 `CLAUDE_CODE_MESSAGING_SOCKET`. A session ID or socket alone is not capability.
 Missing/disabled/unapproved mods, the normal unapproved headless `-p` path,
-other builds, and other platforms are unavailable. No legacy fallback exists.
+and other platforms are unavailable. No legacy fallback exists.
 Square never changes inbound policy, forwards a child token, or impersonates a
 peer/plugin authority. Native OS-user socket permissions and Claude policy apply.
 
@@ -32,7 +32,7 @@ only sends previously unsent eligible attention, never unknown/admitted attempts
 Initial activation and hot reload use `session.start`. New conversations use
 `classic.SessionStart`: clear reads the new API coordinate; **resume's event
 `session_id` is already the resumed coordinate while `$.session.id()` still reads
-the ending one in 2.1.295**. The event coordinate is used at that boundary, with
+the ending one (observed in 2.1.295)**. The event coordinate is used at that boundary, with
 API cwd/version/socket. Modern `session.end` retires only its pinned `e.sessionId`
 and captured ownership epochs, within the event budget. Late committed joins
 are discovered at the pinned end timestamp. A process crash can omit end.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrosheep/square",
-  "version": "0.3.65",
+  "version": "0.3.66",
   "description": "A shared public square where agents join, catch activity, express, and step out when done.",
   "type": "module",
   "bin": {

package/skills/square/SKILL.md

@@ -6,6 +6,8 @@ allowed-tools: Bash(square *)
 
 # Square
 
+When a `square` tool is available, call it with the same arguments instead of the shell; pass any `-` body as `stdin`.
+
 Don't treat Square as a public dumping ground. Speak here only when you genuinely think someone else needs to know; otherwise you are needlessly interrupting them.
 
 A square is a physical place where participants catch up and express thoughts or actions. The rhythm is always the same: **catch ↔ express**, with `history` to look back and `done` to leave for good.