@astrosheep/square 0.3.61 → 0.3.62

package/dist/boundary-presentation.d.ts

@@ -1,6 +1,5 @@
 import type { InboxMembership } from './model.js';
-/** A fresh blocking catch owns only the notifications admitted by its filter. */
-export declare function pendingAtBoundary(inbox: InboxMembership[]): InboxMembership[];
+export { pendingAtBoundary } from './square-projections.js';
 export declare function renderPendingAtBoundary(inbox: InboxMembership[]): string;
 /** Serialize a boundary across hook processes so one stale inbox cannot render twice. */
 export declare function presentPendingAtBoundary<T>(sessionId: string, present: (context: string) => T | Promise<T>, lookup?: (sessionId: string, env?: NodeJS.ProcessEnv, signal?: AbortSignal) => Promise<InboxMembership[]> | InboxMembership[], env?: NodeJS.ProcessEnv, signal?: AbortSignal): Promise<T | undefined>;

package/dist/boundary-presentation.js

@@ -1,14 +1,14 @@
+import { hostLedgerRoot } from './host-ledger-root.js';
 import { createHash } from 'node:crypto';
-import os from 'node:os';
 import path from 'node:path';
-import { leaseOwnsNotification } from './delivery.js';
 import { withFileLock } from './file-lock.js';
 import { openSquare } from './square-file-adapter.js';
 import { closeOpenSquare } from './open-square.js';
 import { presentPending } from './presentation-operations.js';
 import { hostLedgerForEnv, sessionInbox } from './inbox.js';
 import { attentionBodyIsClipped, renderAttentionPreview } from './attention-presentation.js';
-import { presentationSuppressesWake, projectPresentationEvidence } from './square-projections.js';
+import { pendingAtBoundary, presentationSuppressesWake, projectPresentationEvidence } from './square-projections.js';
+export { pendingAtBoundary } from './square-projections.js';
 import { formatActivityId } from './square-core.js';
 const CONTEXT_MAX = 1200;
 const presentationLocks = new Map();
@@ -38,20 +38,6 @@ async function awaitWithSignal(promise, signal) {
 function pendingCount(inbox) {
     return inbox.reduce((total, membership) => total + membership.notifications.length, 0);
 }
-/** A fresh blocking catch owns only the notifications admitted by its filter. */
-export function pendingAtBoundary(inbox) {
-    return inbox
-        .map((membership) => {
-        const lease = membership.catchLease;
-        if (lease === undefined)
-            return membership;
-        return {
-            ...membership,
-            notifications: membership.notifications.filter((notification) => !leaseOwnsNotification(lease, { ...notification, recipient: membership.name })),
-        };
-    })
-        .filter((membership) => membership.notifications.length > 0);
-}
 export function renderPendingAtBoundary(inbox) {
     return renderBoundary(inbox).context;
 }
@@ -165,8 +151,7 @@ async function presentPendingAtBoundaryUnlocked(sessionId, present, lookup = ses
 }
 /** Serialize a boundary across hook processes so one stale inbox cannot render twice. */
 export async function presentPendingAtBoundary(sessionId, present, lookup = sessionInbox, env = process.env, signal) {
-    const ledgerRoot = env.SQUARE_HOST_LEDGER_USER
-        ?? (env.SQUARE_REGISTRY === undefined ? path.join(os.homedir(), '.square', 'host-ledger') : path.dirname(env.SQUARE_REGISTRY));
+    const ledgerRoot = hostLedgerRoot(env);
     const ownerKey = createHash('sha256').update(sessionId).digest('hex');
     return withFileLock(path.join(ledgerRoot, `presentation-boundary-${ownerKey}.lock`), { retryMs: 10, signal }, () => presentPendingAtBoundaryUnlocked(sessionId, present, lookup, env, signal));
 }

package/dist/cli/context.d.ts

@@ -1,5 +1,7 @@
 import { type HardCap } from '../model.js';
 export interface CommandContext {
+    cwd: string;
+    env: NodeJS.ProcessEnv;
     squarePath?: string;
     name?: string;
     homeDir: string;

package/dist/cli/context.js

@@ -113,6 +113,7 @@ const LOCATION_REQUIRED_COMMANDS = new Set([
     'history',
     'status',
     'participants',
+    'mcp-server',
     'doctor',
 ]);
 function configuredLocation() {
@@ -126,22 +127,10 @@ function configuredName() {
     validateName(value);
     return value;
 }
-function withoutAsCommand(rawArgs) {
-    const args = [];
-    for (let index = 0; index < rawArgs.length; index++) {
-        if (rawArgs[index] === '--as') {
-            index += 1;
-            continue;
-        }
-        args.push(rawArgs[index]);
-    }
-    return `square ${args.map((arg) => /^[A-Za-z0-9_./:=@+,-]+$/.test(arg) ? arg : `'${arg.replace(/'/g, "'\\''")}'`).join(' ')}`;
-}
 export async function parseGlobalArgs(rawArgs) {
     const args = [...rawArgs];
     let requestedPath;
     let name;
-    let hasExplicitName = false;
     for (let index = 0; index < args.length; index++) {
         if (args[index] === '--location') {
             requestedPath = requireValue(args, index, args[index]);
@@ -150,15 +139,11 @@ export async function parseGlobalArgs(rawArgs) {
         }
         else if (args[index] === '--as') {
             name = requireValue(args, index, args[index]);
-            hasExplicitName = true;
             args.splice(index, 2);
             index -= 1;
         }
     }
     const command = args[0];
-    if (command === 'history' && hasExplicitName) {
-        fail(`✕ history is an archive and does not use --as\n${withoutAsCommand(rawArgs)}`);
-    }
     if (name === undefined)
         name = configuredName();
     if (name !== undefined)
@@ -174,7 +159,6 @@ export async function parseGlobalArgs(rawArgs) {
             hostLedger: createHostLedgerPort(),
             location: squarePath,
             sessionId,
-            scopes: ['user', 'local'],
         })))).flat();
         const names = new Set(bindings.map((binding) => binding.participant));
         name = names.size === 1 ? [...names][0] : undefined;
@@ -185,7 +169,7 @@ export function locationIsRequired(command) {
     return LOCATION_REQUIRED_COMMANDS.has(command);
 }
 export function defaultContext(command, squarePath, name) {
-    return { command, squarePath, name, homeDir: os.homedir() };
+    return { command, cwd: process.cwd(), env: { ...process.env }, squarePath, name, homeDir: os.homedir() };
 }
 export function requireSquarePath(context) {
     if (context.squarePath === undefined)

package/dist/cli/harness-command.js

@@ -102,7 +102,7 @@ export function formatHarnessResult(result) {
     return `${[...result.notes, ...result.lines, ...result.failures].join('\n')}\n`;
 }
 export function runHarnessCommand(argv, squarePath) {
-    const context = { homeDir: os.homedir(), ...(squarePath === undefined ? {} : { squarePath }), command: 'harness' };
+    const context = { cwd: process.cwd(), env: { ...process.env }, homeDir: os.homedir(), ...(squarePath === undefined ? {} : { squarePath }), command: 'harness' };
     const intent = harnessCommand.parse(argv, context);
     return Promise.resolve(harnessCommand.execute(intent, context)).then(formatHarnessResult);
 }

package/dist/cli/mcp-server-command.d.ts

@@ -0,0 +1,2 @@
+import { type CommandSpec } from './context.js';
+export declare const mcpServerCommand: CommandSpec<undefined, void>;

package/dist/cli/mcp-server-command.js

@@ -0,0 +1,13 @@
+import { fail } from './context.js';
+export const mcpServerCommand = {
+    parse(argv) {
+        if (argv.length > 0)
+            fail('Usage: square [--location <square>] [--as <name>] mcp-server');
+        return undefined;
+    },
+    async execute(_intent, context) {
+        const { runSquareMcpStdio } = await import('../mcp.js');
+        await runSquareMcpStdio({ cwd: context.cwd, env: context.env, squarePath: context.squarePath, participant: context.name });
+    },
+    present() { },
+};

package/dist/cli/observation-commands.js

@@ -12,7 +12,9 @@ import { formatRelativeTime, formatTimestamp, parseTimeOrRelative } from '../tim
 import { cmdWatch } from '../watch.js';
 import { openSquare } from '../square-file-adapter.js';
 import { closeOpenSquare } from '../open-square.js';
-import { historyPresentation, participantsPresentation, statusPresentation } from '../views.js';
+import { createSquareApplication } from '../square-application.js';
+import { historyPresentation } from '../views.js';
+import { hostLedgerForEnv } from '../registry.js';
 import { fail, parseBoundedLimit, parseDurationMs, parseNameList, parseNonNegativeInteger, readStdin, requireParticipant, requireSquarePath, requireValue, usage, } from './context.js';
 import { CATCH_DEFAULT_LIMIT, CATCH_MAX_LIMIT } from '../catch-decisions.js';
 const STATUS_PARTICIPANT_PREVIEW_LIMIT = 10;
@@ -147,7 +149,7 @@ export const catchCommand = {
     },
     async execute(intent, context) {
         const squarePath = requireSquarePath(context);
-        const caught = await cmdWatch(squarePath, requireParticipant(context.name), intent);
+        const caught = await cmdWatch(squarePath, requireParticipant(context.name), intent, { cwd: context.cwd, env: context.env });
         if (caught !== false)
             await sweepPendingNotifications(squarePath);
     },
@@ -303,6 +305,30 @@ function parseHistory(argv, context) {
         continuationArgs: historyContinuationArgs(argv),
     };
 }
+function applicationHistoryQuery(options) {
+    return {
+        ...(options.participants === undefined || options.participants.length === 0 ? {} : { from: options.participants }),
+        ...(options.mention === undefined ? {} : { mention: options.mention }),
+        ...(options.afterIndex === undefined ? {} : { after: actId(options.afterIndex) }),
+        ...(options.beforeIndex === undefined ? {} : { before: actId(options.beforeIndex) }),
+        ...(options.grep === undefined ? {} : { grep: options.grep }), ...(options.fixed === undefined ? {} : { fixed: options.fixed }),
+        order: 'asc',
+    };
+}
+function activityAsStored(activity) {
+    const index = parseActivityId(activity.id);
+    if (index === undefined)
+        throw new Error('Application returned a non-canonical activity id');
+    switch (activity.kind) {
+        case 'say': return { index, kind: 'say', actor: activity.actor, at: activity.at, body: activity.body ?? '', mentions: activity.mentions, ...(activity.reach === undefined ? {} : { reach: activity.reach }), ...(activity.reply === undefined ? {} : { reply: parseActivityId(activity.reply) ?? undefined }) };
+        case 'done': return { index, kind: 'done', actor: activity.actor, at: activity.at, body: activity.body ?? '' };
+        case 'hold': return { index, kind: 'hold', actor: activity.actor, at: activity.at, ...(activity.body === undefined ? {} : { body: activity.body }) };
+        case 'resume': return { index, kind: 'resume', actor: activity.actor, at: activity.at };
+        case 'join': return { index, kind: 'join', actor: activity.actor, at: activity.at };
+        case 'listen': return { index, kind: 'listen', actor: activity.actor, target: activity.target ?? '', at: activity.at };
+        case 'ignore': return { index, kind: 'ignore', actor: activity.actor, target: activity.target ?? '', at: activity.at };
+    }
+}
 function historyContinuationCommand(options, squarePath, direction, index) {
     const args = [...(options.continuationArgs ?? []), direction, actId(index), '--limit', String(options.lastN ?? HISTORY_DEFAULT_LIMIT)];
     return `${commandPrefix(squarePath)} history ${args.map((arg) => arg.startsWith('-') || /^act\/\d+$/.test(arg) || /^\d+$/.test(arg) ? arg : quoteShell(arg)).join(' ')}`;
@@ -311,6 +337,10 @@ function boundedHistoryCommand(options, squarePath) {
     const args = [...(options.continuationArgs ?? []), '--limit', String(HISTORY_MAX_LIMIT)];
     return `${commandPrefix(squarePath)} history ${args.map((arg) => arg.startsWith('-') || /^act\/\d+$/.test(arg) || /^\d+$/.test(arg) ? arg : quoteShell(arg)).join(' ')}`;
 }
+/** The archive-visible activity model: content plus the lifecycle moves that keep its story honest — a raised hand pairs with its lowering, and a departure pairs with the return. */
+function isArchiveActivity(item) {
+    return item.kind === 'say' || item.kind === 'done' || item.kind === 'hold' || item.kind === 'resume' || item.kind === 'join';
+}
 function renderFields(sayNumbers, item, fields) {
     return fields.map((field) => {
         switch (field) {
@@ -344,7 +374,7 @@ function jsonLine(sayNumbers, item) {
     });
 }
 function renderHistoryProjection(projection, visible, noTruncate, squarePath) {
-    const shown = visible.filter((activity) => activity.kind === 'say' || activity.kind === 'done');
+    const shown = visible.filter(isArchiveActivity);
     const preview = noTruncate || shown.length <= 1 ? undefined : 200;
     const chunks = [];
     for (const activity of shown) {
@@ -370,12 +400,16 @@ export const historyCommand = {
     parse(argv, context) { return parseHistory(argv, context); },
     async execute(options, context) {
         const squarePath = requireSquarePath(context);
-        const square = await openSquare(squarePath, { clock: nowMs });
+        const square = await openSquare(squarePath, { clock: nowMs, env: context.env, hostLedger: hostLedgerForEnv(context.env) });
         try {
             // Keep the projection chronological; pagination chooses a stable edge,
             // then --order only changes how the selected page is displayed.
             const projection = await historyPresentation(square, { ...options, order: 'asc' });
-            let events = [...projection.activities];
+            const useApplicationHistory = options.atIndexes === undefined && options.beforeContext === undefined && options.afterContext === undefined && options.after === undefined;
+            const applicationHistory = useApplicationHistory
+                ? await createSquareApplication({ cwd: context.cwd, env: { ...context.env, SQUARE_PARTICIPANT_NAME: undefined }, squarePath, clock: nowMs }).history(applicationHistoryQuery(options))
+                : undefined;
+            let events = applicationHistory === undefined ? [...projection.activities] : applicationHistory.map(activityAsStored);
             if (options.lastN === null && events.length > HISTORY_MAX_LIMIT) {
                 fail(`✕ history is capped at ${HISTORY_MAX_LIMIT} activities\n${boundedHistoryCommand(options, squarePath)}`);
             }
@@ -397,8 +431,8 @@ export const historyCommand = {
             const output = pattern === undefined || pattern === ''
                 ? renderHistoryProjection(projection, events, options.noTruncate === true, squarePath)
                 : renderGrepActivitiesView(events, totalMatches, options.noTruncate, squarePath, pattern, options.fixed !== undefined, () => 'full');
-            const publicEvents = events.filter((item) => item.kind === 'say' || item.kind === 'done');
-            const allPublic = projection.activities.filter((item) => item.kind === 'say' || item.kind === 'done');
+            const publicEvents = events.filter(isArchiveActivity);
+            const allPublic = projection.activities.filter(isArchiveActivity);
             const pageMin = publicEvents.length === 0 ? undefined : Math.min(...publicEvents.map((item) => item.index));
             const pageMax = publicEvents.length === 0 ? undefined : Math.max(...publicEvents.map((item) => item.index));
             const hasMore = options.lastN != null && publicEvents.length > 0 && (options.afterIndex !== undefined
@@ -432,10 +466,10 @@ export const participantsCommand = {
     parse(argv, context) { return parseParticipants(argv, context); },
     async execute(intent, context) {
         const squarePath = requireSquarePath(context);
-        const square = await openSquare(squarePath, { clock: nowMs });
-        try {
+        const application = createSquareApplication({ cwd: context.cwd, env: context.env, squarePath, clock: nowMs });
+        {
             const now = nowMs();
-            const participants = await participantsPresentation(square);
+            const participants = await application.participants();
             const lines = participants.slice(0, intent.limit).map((participant) => {
                 const recent = participant.lastActiveAt !== undefined && now - participant.lastActiveAt <= STATUS_HERE_WINDOW_MS;
                 const glyph = participant.state === 'done' ? '○' : participant.presence === 'watching' ? '◎' : participant.activityCount > 0 && recent ? '●' : '○';
@@ -456,9 +490,6 @@ export const participantsCommand = {
                 participantCount,
             });
         }
-        finally {
-            await closeOpenSquare(square);
-        }
     },
     present: (result) => process.stdout.write(result),
 };
@@ -467,9 +498,9 @@ export const statusCommand = {
         usage(context.command); return undefined; },
     async execute(_intent, context) {
         const squarePath = requireSquarePath(context);
-        const square = await openSquare(squarePath, { clock: nowMs });
-        try {
-            const presentation = await statusPresentation(square);
+        const application = createSquareApplication({ cwd: context.cwd, env: context.env, squarePath, clock: nowMs });
+        {
+            const presentation = await application.status();
             const result = presentation.status;
             const active = result.participants.filter((participant) => participant.state === 'active');
             const here = active.filter((participant) => participant.presence === 'watching'
@@ -561,9 +592,6 @@ export const statusCommand = {
             ].join('\n');
             return withPathOutput(squarePath, output, { participantCount: result.activeCount, held: result.holdActive });
         }
-        finally {
-            await closeOpenSquare(square);
-        }
     },
     present: (result) => process.stdout.write(result),
 };

package/dist/cli/program.js

@@ -1,6 +1,6 @@
 import { helpRequest } from '../help.js';
 import { isSquareError } from '../model.js';
-import { formatRefusal, joinRecoveryCommand, participantsRecoveryCommand } from '../presentation.js';
+import { formatRefusal, joinRecoveryCommand, participantsRecoveryCommand, takeoverRecoveryLines } from '../presentation.js';
 import { inSquareCount, nowMs } from '../runtime.js';
 import { openSquare } from '../square-file-adapter.js';
 import { closeOpenSquare } from '../open-square.js';
@@ -23,7 +23,10 @@ async function participantCountFor(squarePath) {
 async function handleSquareError(error, squarePath, name) {
     if (isSquareError(error)) {
         const existing = [error.message];
-        if (squarePath !== undefined && /^✕ .* has never stepped into/.test(error.message)) {
+        if (squarePath !== undefined && name !== undefined && error.code === 'already_joined') {
+            existing.push(...takeoverRecoveryLines(squarePath, name));
+        }
+        else if (squarePath !== undefined && /^✕ .* has never stepped into/.test(error.message)) {
             // The caller's name has never joined this square; only a join admits it.
             if (name !== undefined)
                 existing.push(joinRecoveryCommand(squarePath, name));

package/dist/cli/registry.js

@@ -2,6 +2,7 @@ import { buildCommand, doneCommand, expressCommand, holdCommand, ignoreCommand,
 import { doctorCommand } from './maintenance-commands.js';
 import { harnessCommand, installCommand, uninstallCommand } from './harness-command.js';
 import { helpCommand, versionCommand } from './meta-commands.js';
+import { mcpServerCommand } from './mcp-server-command.js';
 import { catchCommand, claudeHookCommand, codexHookCommand, historyCommand, inboxCommand, listCommand, participantsCommand, statusCommand, streamCommand, } from './observation-commands.js';
 /** Every public command is an executable adapter, including aliases and utility commands. */
 export const commandRegistry = [
@@ -29,6 +30,7 @@ export const commandRegistry = [
     { names: ['participants'], spec: participantsCommand },
     { names: ['help'], spec: helpCommand },
     { names: ['version', '--version', '-v'], spec: versionCommand },
+    { names: ['mcp-server'], spec: mcpServerCommand },
 ];
 export function findCommand(name) {
     return commandRegistry.find((command) => command.names.includes(name));

package/dist/cli/square-commands.d.ts

@@ -19,7 +19,7 @@ interface ActivityIntent {
     noMention: boolean;
     mentions: string[];
     reach?: Reach;
-    reply?: number;
+    reply?: string;
 }
 interface BodyIntent {
     name: string;