@astrosheep/square 0.3.101 → 0.3.102

package/dist/mcp.js

@@ -1,6 +1,6 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { SQUARE_TOOLS, SQUARE_TOOL_INSTRUCTIONS, squareToolsEnabled, squareToolFailure, squareToolFailureText } from './square-tools.js';
+import { SQUARE_TOOLS, SQUARE_TOOL_INSTRUCTIONS, SquareExpressDrafts, squareToolsEnabled, squareToolFailure, squareToolFailureText } from './square-tools.js';
 import { operationEnv } from './participant-identity.js';
 import { codexWakeAddress } from './codex-address.js';
 import { readClaudeMcpCall } from './claude-mcp-context.js';
@@ -12,6 +12,7 @@ export function createSquareMcpServer(options) {
     const baseEnv = { ...(resourceOptions.env ?? process.env) };
     const toolsEnabled = squareToolsEnabled(baseEnv);
     const resources = createSquareResourceOwner();
+    const drafts = new SquareExpressDrafts();
     // Calls to the configured square borrow one server-owned connection.
     const inFlight = new Set();
     const server = new McpServer({ name: 'square', version: SQUARE_IDENTITY.packageVersion }, {
@@ -22,21 +23,30 @@ export function createSquareMcpServer(options) {
             server.registerTool(tool.name, { description: tool.description, inputSchema: tool.inputSchema }, (args, extra) => {
                 const call = (async () => {
                     let square;
+                    let toolArgs = args;
+                    let owner;
+                    let draftToken;
+                    let expressAttempted = false;
                     try {
-                        const { location } = args;
                         const threadId = extra._meta?.threadId;
                         const opencodeSessionId = extra._meta?.['ai.opencode/sessionID'];
                         // Claude's plugin endpoint requires the mod's call-local coordinate, never startup identity.
                         const claude = baseEnv.SQUARE_CLAUDE_MCP_CONTEXT === '1'
                             ? await readClaudeMcpCall(extra._meta?.['claudecode/toolUseId'], baseEnv)
                             : undefined;
-                        const owner = claude !== undefined
+                        owner = claude !== undefined
                             ? harnessOwner({ channel: 'claude-code', session: claude.sessionId, ...(claude.agentId === undefined ? {} : { agent: claude.agentId }) })
                             : typeof threadId === 'string' && threadId.trim()
                                 ? harnessOwner({ channel: 'codex', session: threadId })
                                 : typeof opencodeSessionId === 'string' && opencodeSessionId.trim()
                                     ? harnessOwner({ channel: 'opencode', session: opencodeSessionId })
                                     : configuredOwner;
+                        if (tool.name === 'express') {
+                            const resolved = drafts.resolve(toolArgs, owner);
+                            toolArgs = resolved.args;
+                            draftToken = resolved.token;
+                        }
+                        const { location } = toolArgs;
                         const env = claude !== undefined
                             ? { ...operationEnv('claude', claude.sessionId, baseEnv),
                                 // Preserve Claude's session + child flag semantics; an agent loop ID is not a session ID.
@@ -59,10 +69,12 @@ export function createSquareMcpServer(options) {
                             ? wakeAddress : undefined;
                         let text;
                         try {
-                            text = await tool.run(square, args, { signal: extra.signal }, {
+                            expressAttempted = tool.name === 'express';
+                            text = await tool.run(square, toolArgs, { signal: extra.signal }, {
                                 owner, wakeAddress: claude === undefined && typeof threadId === 'string' && threadId.trim()
                                     ? codexWakeAddress(threadId, env) : callWake,
                             });
+                            drafts.consume(draftToken);
                         }
                         finally {
                             await square.close();
@@ -71,10 +83,12 @@ export function createSquareMcpServer(options) {
                     }
                     catch (error) {
                         const failure = squareToolFailure(error, extra.signal);
-                        const participant = args.as;
+                        const participant = toolArgs.as;
+                        const draft = tool.name === 'express' ? drafts.retain(toolArgs, owner, draftToken, failure, expressAttempted) : undefined;
                         return { isError: true, content: [{ type: 'text', text: squareToolFailureText(failure, {
                                         location: square?.location ?? options.path,
                                         participant: typeof participant === 'string' ? participant : undefined,
+                                        draft,
                                     }) }] };
                     }
                 })();

package/dist/square-tools.d.ts

@@ -6,6 +6,16 @@ export interface ToolIdentity {
     readonly wakeAddress?: WakeAddress;
 }
 type JsonObject = Record<string, unknown>;
+export declare class SquareExpressDrafts {
+    private readonly drafts;
+    private purgeExpired;
+    resolve(args: JsonObject, owner?: Owner): {
+        args: JsonObject;
+        token?: string;
+    };
+    consume(token?: string): void;
+    retain(args: JsonObject, owner: Owner | undefined, token: string | undefined, failure: JsonObject, expressAttempted: boolean): string | undefined;
+}
 interface ToolDefinition {
     name: string;
     description: string;
@@ -21,5 +31,6 @@ export declare function squareToolFailure(error: unknown, signal?: AbortSignal):
 export declare function squareToolFailureText(failure: JsonObject, context?: {
     location?: string;
     participant?: string;
+    draft?: string;
 }): string;
 export {};

package/dist/square-tools.js

@@ -1,7 +1,50 @@
+import crypto from 'node:crypto';
 import { z } from 'zod/v4';
 import { isSquareError, SquareError } from './model.js';
 import { requireOwner, requireJoinName, selectOwnSeat, CATCH_DEFAULT_LIMIT } from './square-api.js';
 import { renderCatchOutcome, renderExpression, renderFailureLines, renderHistoryResult, renderJoinResult, renderLifecycleResult, renderListenerChange, renderStatusResult, } from './operation-presentation.js';
+/** Process-local recovery: FIFO 64, fixed two-hour TTL, consumed only by a successful express. */
+const EXPRESS_DRAFT_TTL_MS = 2 * 60 * 60 * 1000;
+const EXPRESS_DRAFT_LIMIT = 64;
+export class SquareExpressDrafts {
+    drafts = new Map();
+    purgeExpired() {
+        const now = Date.now();
+        for (const [token, draft] of this.drafts)
+            if (draft.expiresAt <= now)
+                this.drafts.delete(token);
+    }
+    resolve(args, owner) {
+        if (args.draft === undefined)
+            return { args };
+        this.purgeExpired();
+        if (typeof args.draft !== 'string' || Object.keys(args).length !== 1)
+            throw new SquareError('invalid_args', 'An express draft token cannot be combined with other arguments.');
+        const draft = this.drafts.get(args.draft);
+        if (draft === undefined || draft.owner !== owner)
+            throw new SquareError('invalid_args', 'Unknown, expired, or inaccessible express draft.');
+        return { args: draft.args, token: args.draft };
+    }
+    consume(token) {
+        if (token !== undefined)
+            this.drafts.delete(token);
+    }
+    retain(args, owner, token, failure, expressAttempted) {
+        const effect = failure.operation?.expressEffect;
+        // After an attempt, only an admission or argument refusal proves that retrying cannot duplicate an activity.
+        const unsent = !expressAttempted || effect === 'unsent' || (effect === undefined && failure.code === 'invalid_args');
+        if (!unsent || effect === 'landed' || effect === 'unknown' || typeof args.body !== 'string' || args.draft !== undefined)
+            return undefined;
+        this.purgeExpired();
+        if (token !== undefined && this.drafts.has(token))
+            return token;
+        const created = `dr_${crypto.randomBytes(16).toString('base64url')}`;
+        this.drafts.set(created, { owner, args, expiresAt: Date.now() + EXPRESS_DRAFT_TTL_MS });
+        if (this.drafts.size > EXPRESS_DRAFT_LIMIT)
+            this.drafts.delete(this.drafts.keys().next().value);
+        return created;
+    }
+}
 const location = z.string().optional().describe('Which square: a .square file path. Relative paths start from the working directory. Leave it out for the configured square.');
 const participant = z.string().optional().describe('Your name in the square. Leave it out if you hold exactly one name here.');
 const activityId = z.string().regex(/^act\/(0|[1-9][0-9]*)$/);
@@ -45,14 +88,21 @@ export const SQUARE_TOOLS = [
     }, (square, { as, takeover }, control, identity) => square.join(requireJoinName(as), { ...identity, owner: requireOwner(identity.owner), takeover, observe: true }, control), rendering((result) => renderJoinResult(result))),
     tool('express', 'Speak or act in the square. Plain words, half-formed ideas and *actions* all belong here. Mention or reply to someone to be heard by them; ring the bell to be heard by everyone. Said to no one in particular, your words reach those who listen to you.', {
         as: participant,
-        body: z.string().describe('What you say or do. Markdown works; *asterisks* mark an action.'),
+        body: z.string().optional().describe('What you say or do. Markdown works; *asterisks* mark an action. Required unless retrying with a draft token.'),
+        draft: z.string().optional().describe('Retry a failed express kept in this process. Pass only the token; the original body and options are restored.'),
         mentions: stringArray.optional().describe('Who you are speaking to. An @name in the body that matches someone here counts too.'),
         reach: z.enum(['bell']).optional().describe('"bell" calls everyone in the square. Cannot be used with mentions.'),
         reply: activityId.optional().describe('The activity you are answering, like act/12. Its author hears you if still here.'),
         noMention: z.boolean().optional().describe('Leave @names in the body as plain text. Mentions and reply still reach people.'),
         force: z.boolean().optional().describe('Speak now, even if something reached you that you have not caught yet.'),
         noWait: z.boolean().optional().describe('If you are speaking too fast, return at once instead of waiting.'),
-    }, async (square, { body, as, ...options }, control, identity) => (await selectOwnSeat(square, identity.owner, as)).express(body, { ...options, observe: true }, control), rendering((result) => renderExpression(result.observation?.location ?? '', result))),
+    }, async (square, { body, draft, as, ...options }, control, identity) => {
+        if (draft !== undefined)
+            throw new SquareError('invalid_args', 'Unknown or expired express draft.');
+        if (body === undefined)
+            throw new SquareError('invalid_args', 'Express needs a body or a draft token.');
+        return (await selectOwnSeat(square, identity.owner, as)).express(body, { ...options, observe: true }, control);
+    }, rendering((result) => renderExpression(result.observation?.location ?? '', result))),
     tool('catch', 'Take in what reached you since you last looked: mentions, replies, bells, and words from those you listen to. What you catch no longer waits for you; history lets you look back.', {
         as: participant,
         id: activityId.optional().describe('Take in this activity in full, like act/12, even if you caught it before. Do not combine with idle, from, mention or limit.'),
@@ -103,5 +153,15 @@ export function squareToolFailure(error, signal) {
 }
 /** Readable failure text with the same recovery commands the CLI offers, never raw JSON. */
 export function squareToolFailureText(failure, context = {}) {
-    return renderFailureLines(failure, { squarePath: context.location, name: context.participant }).join('\n');
+    const report = failure;
+    const lines = renderFailureLines(report, { squarePath: context.location, name: context.participant });
+    if (report.code === 'behind')
+        lines[0] = `✕ your words stay unsent — ${report.message}`;
+    if (context.draft !== undefined) {
+        lines.push(`· draft kept in memory: ${context.draft}`);
+        lines.push(report.code === 'behind'
+            ? '· catch the pending activity, then retry express with only:'
+            : '· correct the problem above, then retry express with only:', `{ "draft": "${context.draft}" }`);
+    }
+    return lines.join('\n');
 }

package/package.json

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

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

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

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

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

package/plugins/pi/square-pi.js

@@ -3,7 +3,7 @@ import { Container, Markdown, Spacer, Text } from '@earendil-works/pi-tui';
 import { z } from 'zod/v4';
 
 import { Square, harnessOwner } from '../../dist/square-api.js';
-import { SQUARE_TOOLS, SQUARE_TOOL_INSTRUCTIONS, squareToolsEnabled, squareToolFailure, squareToolFailureText } from '../../dist/square-tools.js';
+import { SQUARE_TOOLS, SQUARE_TOOL_INSTRUCTIONS, SquareExpressDrafts, squareToolsEnabled, squareToolFailure, squareToolFailureText } from '../../dist/square-tools.js';
 
 import { presentPendingAtBoundary, renderPendingAtBoundary } from '../../dist/boundary-presentation.js';
 import { operationEnv } from '../../dist/participant-identity.js';
@@ -143,6 +143,7 @@ export function renderSquareCard(message, { expanded, outputPad = 1 }, theme) {
 }
 
 export default function squarePiExtension(pi) {
+  const drafts = new SquareExpressDrafts();
   if (squareToolsEnabled(process.env)) for (const tool of SQUARE_TOOLS) {
     pi.registerTool({
       name: `square_${tool.name}`,
@@ -152,20 +153,40 @@ export default function squarePiExtension(pi) {
       exposure: 'codemode',
       namespace: { name: 'square', description: 'A shared square where agents gather to talk, think, and act together.', instructions: SQUARE_TOOL_INSTRUCTIONS },
       async execute(_id, args, signal, _onUpdate, ctx) {
+        let toolArgs = args;
+        let owner;
+        let draftToken;
+        let expressAttempted = false;
+        let square;
         try {
           const sessionId = ctx.sessionManager.getSessionId();
-          const square = await Square.at({
+          owner = harnessOwner({ channel: 'pi', session: sessionId });
+          if (tool.name === 'express') {
+            const resolved = drafts.resolve(toolArgs, owner);
+            toolArgs = resolved.args;
+            draftToken = resolved.token;
+          }
+          square = await Square.at({
             cwd: ctx.cwd,
             env: operationEnv('pi', sessionId, process.env),
-            path: args.location,
+            path: toolArgs.location,
           }, { signal });
           let text;
-          try { text = await tool.run(square, args, { signal }, { owner: harnessOwner({ channel: 'pi', session: sessionId }) }); }
+          try {
+            expressAttempted = tool.name === 'express';
+            text = await tool.run(square, toolArgs, { signal }, { owner });
+            drafts.consume(draftToken);
+          }
           finally { await square.close(); }
           return { content: [{ type: 'text', text }] };
         } catch (error) {
           const failure = squareToolFailure(error, signal);
-          return { isError: true, content: [{ type: 'text', text: squareToolFailureText(failure, { location: args.location ?? process.env.SQUARE_LOCATION, participant: args.as }) }] };
+          const draft = tool.name === 'express' ? drafts.retain(toolArgs, owner, draftToken, failure, expressAttempted) : undefined;
+          return { isError: true, content: [{ type: 'text', text: squareToolFailureText(failure, {
+            location: square?.location ?? toolArgs.location ?? process.env.SQUARE_LOCATION,
+            participant: toolArgs.as,
+            draft,
+          }) }] };
         }
       },
     });