@astrosheep/square 0.3.58 → 0.3.62

package/dist/automatic-session.js

@@ -1,4 +1,5 @@
 import { promises as fs } from 'node:fs';
+import { hostLedgerRoot } from './host-ledger-root.js';
 import path from 'node:path';
 import { openSquare } from './square-file-adapter.js';
 import { closeOpenSquare } from './open-square.js';
@@ -9,7 +10,7 @@ import { SquareError } from './model.js';
 import { createHostLedgerPort } from './host-ledger-file-adapter.js';
 import { projectSessionBindings } from './square-projections.js';
 import { claimSessionParticipant, readParticipantOwner, releaseSessionParticipant } from './registry.js';
-import { publishWakeRoute, retireWakeRoutesForSessionFromArtifact, resolvePrimaryWakeRoute, defaultWakeRouteCapabilities } from './routes.js';
+import { publishWakeRoute, resolvePrimaryWakeRoute, defaultWakeRouteCapabilities } from './routes.js';
 export { automaticParticipant } from './participant-identity.js';
 const providerEnv = {
     codex: 'CODEX_THREAD_ID',
@@ -29,10 +30,9 @@ function operationEnv(provider, sessionId, env) {
     };
 }
 function hostLedgerForEnv(env) {
-    const root = env.SQUARE_REGISTRY === undefined ? undefined : path.dirname(env.SQUARE_REGISTRY);
+    const root = hostLedgerRoot(env);
     return createHostLedgerPort({
-        userPath: env.SQUARE_HOST_LEDGER_USER ?? root,
-        localPath: env.SQUARE_HOST_LEDGER_LOCAL ?? root,
+        rootPath: root,
     });
 }
 export function publicSquarePath(cwd) {
@@ -64,17 +64,17 @@ export async function automaticSessionStart(provider, sessionId, cwd, env = proc
     let bindings;
     let entry;
     try {
-        bindings = await hostLedger.listPresence({ location: squarePath, participant: name, scopes: ['user', 'local'] });
+        bindings = await hostLedger.listPresence({ location: squarePath, participant: name });
         entry = await entryPresentation(reader, name);
     }
     finally {
         await closeOpenSquare(reader);
     }
     if (bindings.some((binding) => binding.session !== sessionId)) {
-        throw new SquareError('already_joined', `${name} is already bound to another session`);
+        throw new SquareError('already_joined', `✕ ${name} already stands here — another session holds the name`);
     }
     if (entry.joined && !bindings.some((binding) => binding.session === sessionId)) {
-        throw new SquareError('already_joined', `${name} is already joined by another session`);
+        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, scopedEnv);
@@ -103,8 +103,7 @@ export async function automaticSessionStart(provider, sessionId, cwd, env = proc
             channel: provider === 'claude' ? 'claude-code' : provider,
             updatedAt: Date.now(),
             ...(claim?.epoch === undefined || claim.epoch <= 0 ? {} : { epoch: claim.epoch }),
-        }, 'user');
-        await square.reconcileBinding();
+        });
         return undefined;
     }
     catch (error) {
@@ -127,7 +126,6 @@ export async function automaticSessionEnd(provider, sessionId, cwd, env = proces
         hostLedger,
         sessionId,
         location: probe.location,
-        scopes: ['user', 'local'],
     }))[0];
     const expectedEpoch = binding === undefined
         ? undefined
@@ -135,22 +133,14 @@ export async function automaticSessionEnd(provider, sessionId, cwd, env = proces
     await closeOpenSquare(probe);
     const square = await Square.at({ path: squarePath, hostLedger, env: scopedEnv });
     try {
-        if (binding !== undefined) {
-            const reader = await openSquare(squarePath);
-            const joined = await entryPresentation(reader, binding.participant).finally(() => closeOpenSquare(reader));
-            if (joined.joined) {
-                const ended = await square.endOwnedSession(binding.participant, sessionId, expectedEpoch);
-                if (ended !== null)
-                    await square.reconcileBinding();
-            }
-        }
-        const cleanup = await openSquare(squarePath);
-        try {
-            await retireWakeRoutesForSessionFromArtifact(cleanup.artifact, { location: squarePath, sessionId });
-        }
-        finally {
-            await closeOpenSquare(cleanup);
-        }
+        // 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)
+            await square.retireEndedSessionRoutes(sessionId);
+        else
+            await square.endOwnedSession(binding.participant, sessionId, expectedEpoch);
     }
     finally {
         await square.close();

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

@@ -17,7 +17,7 @@ function resolveCatchName(state, requestedName) {
     validateName(requestedName);
     const known = resolveRosterName(state, requestedName);
     if (known === undefined) {
-        throw new SquareError('invalid_args', `Unknown participant "${participantIdentity(requestedName)}".`);
+        throw new SquareError('invalid_args', `✕ ${participantIdentity(requestedName)} has never stepped into this square`);
     }
     return known;
 }

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

@@ -35,66 +35,66 @@ export function usage(command) {
 export function requireValue(args, index, flag) {
     const value = args[index + 1];
     if (value === undefined || value.startsWith('--'))
-        fail(`Missing value for ${flag}.`);
+        fail(`✕ missing value for ${flag}`);
     return value;
 }
 export function parseDurationMs(value, flag) {
     const match = value.match(/^([1-9]\d*)(ms|s|m|h)$/);
     if (!match)
-        fail(`Invalid ${flag}: expected a positive duration with unit ms, s, m, or h (for example 500ms, 30s, 3m, 1h).`);
+        fail(`✕ invalid ${flag}: expected a positive duration with unit ms, s, m, or h (for example 500ms, 30s, 3m, 1h)`);
     const amount = Number.parseInt(match[1], 10);
     const multiplier = { ms: 1, s: 1000, m: 60000, h: 3600000 };
     const milliseconds = amount * multiplier[match[2]];
     if (!Number.isSafeInteger(milliseconds))
-        fail(`Invalid ${flag}: duration is too large.`);
+        fail(`✕ invalid ${flag}: duration is too large`);
     return milliseconds;
 }
 export function parsePositiveInteger(value, flag) {
     if (!/^[1-9]\d*$/.test(value))
-        fail(`Invalid ${flag}: expected a positive integer.`);
+        fail(`✕ invalid ${flag}: expected a positive integer`);
     const parsed = Number(value);
     if (!Number.isSafeInteger(parsed))
-        fail(`Invalid ${flag}: value is too large.`);
+        fail(`✕ invalid ${flag}: value is too large`);
     return parsed;
 }
 export function parseBoundedLimit(value, flag, max, retry) {
     if (value === undefined || value.startsWith('--') || !/^[1-9]\d*$/.test(value) || !Number.isSafeInteger(Number(value))) {
-        fail(`✕ ${flag} needs a positive integer\n» ${retry}`);
+        fail(`✕ ${flag} needs a positive integer\n${retry}`);
     }
     const parsed = Number(value);
     if (parsed > max)
-        fail(`✕ ${flag} is capped at ${max}\n» ${retry}`);
+        fail(`✕ ${flag} is capped at ${max}\n${retry}`);
     return parsed;
 }
 export function parseNonNegativeInteger(value, flag) {
     if (!/^\d+$/.test(value))
-        fail(`Invalid ${flag}: expected a non-negative integer.`);
+        fail(`✕ invalid ${flag}: expected a non-negative integer`);
     const parsed = Number(value);
     if (!Number.isSafeInteger(parsed))
-        fail(`Invalid ${flag}: value is too large.`);
+        fail(`✕ invalid ${flag}: value is too large`);
     return parsed;
 }
 export function parseHardCap(value) {
     if (value === 'unlimited')
         return null;
     if (!/^[1-9]\d*$/.test(value))
-        fail('Invalid build option: --cap must be a positive integer or unlimited.');
+        fail('✕ invalid build option: --cap must be a positive integer or unlimited');
     const parsed = Number(value);
     if (!Number.isSafeInteger(parsed))
-        fail('Invalid build option: --cap must be a positive integer or unlimited.');
+        fail('✕ invalid build option: --cap must be a positive integer or unlimited');
     return parsed;
 }
 export function parseNameList(value, flag) {
     const names = parseParticipantList(value);
     if (names.length === 0)
-        fail(`Invalid ${flag}: expected at least one participant name.`);
+        fail(`✕ invalid ${flag}: expected at least one participant name`);
     for (const name of names)
         validateName(name);
     return names;
 }
 export function requireParticipant(name) {
     if (!name)
-        fail('Missing required option: --as <name>.');
+        fail('✕ missing required option: --as <name>');
     validateName(name);
     return name;
 }
@@ -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)
@@ -166,7 +151,7 @@ export async function parseGlobalArgs(rawArgs) {
     const explicitSquarePath = requestedPath !== undefined;
     const configured = configuredLocation();
     if (command !== undefined && !['--help', '-h'].includes(command) && locationIsRequired(command) && requestedPath === undefined && configured === undefined) {
-        fail(`✕ ${command} needs a square location\n» square ls`);
+        fail(`✕ ${command} needs a square location\nsquare ls`);
     }
     const squarePath = requestedPath ?? configured;
     if (name === undefined && squarePath !== undefined && command !== undefined && locationIsRequired(command)) {
@@ -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,10 +169,10 @@ 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)
-        fail(`✕ ${context.command} needs a square location\n» square ls`);
+        fail(`✕ ${context.command} needs a square location\nsquare ls`);
     return context.squarePath;
 }

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() { },
+};