@astrosheep/square 0.3.63 → 0.3.65

package/dist/boundary-presentation.js

@@ -5,11 +5,11 @@ 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 { hostLedgerForEnv } from './registry.js';
+import { sessionInbox } from './inbox.js';
 import { attentionBodyIsClipped, renderAttentionPreview } from './attention-presentation.js';
-import { pendingAtBoundary, presentationSuppressesWake, projectPresentationEvidence } from './square-projections.js';
+import { projectBoundaryEligibility } from './square-projections.js';
 export { pendingAtBoundary } from './square-projections.js';
-import { formatActivityId } from './square-core.js';
 const CONTEXT_MAX = 1200;
 const presentationLocks = new Map();
 /** One settled promise loses to an abort so an in-process presentation wait stays bounded too. */
@@ -35,9 +35,6 @@ async function awaitWithSignal(promise, signal) {
             signal.removeEventListener('abort', onAbort);
     }
 }
-function pendingCount(inbox) {
-    return inbox.reduce((total, membership) => total + membership.notifications.length, 0);
-}
 export function renderPendingAtBoundary(inbox) {
     return renderBoundary(inbox).context;
 }
@@ -84,13 +81,7 @@ async function presentPendingAtBoundaryUnlocked(sessionId, present, lookup = ses
     if (signal?.aborted)
         return undefined;
     const hostLedger = hostLedgerForEnv(env);
-    const pending = [];
-    for (const membership of pendingAtBoundary(inbox)) {
-        const evidence = await projectPresentationEvidence({ hostLedger, location: membership.squarePath, participant: membership.name, sessionId });
-        const notifications = membership.notifications.filter((notification) => !presentationSuppressesWake(evidence.filter((row) => row.activity === formatActivityId(notification.actIndex))));
-        if (notifications.length > 0)
-            pending.push({ ...membership, notifications });
-    }
+    const pending = await projectBoundaryEligibility({ hostLedger, sessionId, inbox });
     if (pending.length === 0 || signal?.aborted)
         return undefined;
     const delivered = renderBoundary(pending);

package/dist/canonical-path.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The one canonicalizer for square locations.
+ *
+ * Resolve, then realpath the nearest existing ancestor and rejoin the non-existing
+ * suffix: a square that does not exist yet under a symlinked directory still lands
+ * on the same identity as the directory it will appear in. Any other read error
+ * keeps the plain resolution.
+ */
+export declare function canonicalPath(value: string): Promise<string>;
+/** The synchronous face of {@link canonicalPath}, using the native realpath. */
+export declare function canonicalPathSync(value: string): string;

package/dist/canonical-path.js

@@ -0,0 +1,47 @@
+import fs from 'node:fs';
+import path from 'node:path';
+/**
+ * The one canonicalizer for square locations.
+ *
+ * Resolve, then realpath the nearest existing ancestor and rejoin the non-existing
+ * suffix: a square that does not exist yet under a symlinked directory still lands
+ * on the same identity as the directory it will appear in. Any other read error
+ * keeps the plain resolution.
+ */
+export async function canonicalPath(value) {
+    let current = path.resolve(value);
+    const suffix = [];
+    for (;;) {
+        try {
+            return path.join(await fs.promises.realpath(current), ...suffix.reverse());
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                return path.resolve(value);
+            const parent = path.dirname(current);
+            if (parent === current)
+                return path.resolve(value);
+            suffix.push(path.basename(current));
+            current = parent;
+        }
+    }
+}
+/** The synchronous face of {@link canonicalPath}, using the native realpath. */
+export function canonicalPathSync(value) {
+    let current = path.resolve(value);
+    const suffix = [];
+    for (;;) {
+        try {
+            return path.join(fs.realpathSync.native(current), ...suffix.reverse());
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                return path.resolve(value);
+            const parent = path.dirname(current);
+            if (parent === current)
+                return path.resolve(value);
+            suffix.push(path.basename(current));
+            current = parent;
+        }
+    }
+}

package/dist/catch-decisions.js

@@ -1,8 +1,9 @@
-import { audienceOf, formatActivityId, parseActivityId } from './square-core.js';
+import { activityAuthors, audienceOf, formatActivityId, parseActivityId } from './square-core.js';
 import { derivePerceptionProjection } from './perception-projection.js';
-import { matchesMentionTarget, recordObservation } from './runtime.js';
+import { recordObservation } from './runtime.js';
+import { matchesCatchSelection } from './catch-selection.js';
 import { participantIdentity } from './participant-identity.js';
-import { SquareError, sameName, validateName } from './model.js';
+import { SquareError, validateName } from './model.js';
 import { resolveRosterName } from './runtime.js';
 export const CATCH_DEFAULT_LIMIT = 10;
 export const CATCH_MAX_LIMIT = 100;
@@ -17,7 +18,7 @@ function resolveCatchName(state, requestedName) {
     validateName(requestedName);
     const known = resolveRosterName(state, requestedName);
     if (known === undefined) {
-        throw new SquareError('invalid_args', `✕ ${participantIdentity(requestedName)} has never stepped into this square`);
+        throw new SquareError('invalid_args', `✕ ${participantIdentity(requestedName)} has never stepped into this square`, { reason: 'never_joined' });
     }
     return known;
 }
@@ -35,7 +36,11 @@ export function decideCatch(state, requestedName, options, at, project = deriveP
             throw new SquareError('invalid_args', 'Invalid catch id: expected an activity id like act/12.');
         const activity = state.acts.find((item) => item.index === index);
         if (activity === undefined || activity.kind !== 'say' || !delivery.directedTo(activity, viewer)) {
-            throw new SquareError('invalid_args', 'That activity is not available to catch.');
+            throw new SquareError('invalid_args', `✕ ${formatActivityId(index)} isn't addressed to you`, {
+                reason: 'not_addressed',
+                activityId: formatActivityId(index),
+                activityExists: activity !== undefined,
+            });
         }
         const perception = delivery.perceive(activity, viewer);
         const changed = recordObservation(state, viewer, index, 'seen', at);
@@ -49,17 +54,16 @@ export function decideCatch(state, requestedName, options, at, project = deriveP
             remaining: state.acts.filter((item) => item.kind === 'say' && delivery.directedTo(item, viewer) && !delivery.isSeen(viewer, item.index)).length,
         };
     }
-    const from = options.from;
-    const mentionOnly = options.mention === true;
+    const filter = { participants: options.from, mention: options.mention === true ? viewer : undefined };
+    const authors = activityAuthors(state.acts);
     const delivered = [];
     const perceptions = new Map();
     const matching = [];
     for (const activity of state.acts) {
         if (activity.kind !== 'say' || !delivery.directedTo(activity, viewer))
             continue;
-        if (from !== undefined && !from.some((participant) => sameName(participant, activity.actor)))
-            continue;
-        if (mentionOnly && audienceOf(activity).kind !== 'bell' && !matchesMentionTarget(activity, viewer))
+        const replyAuthor = activity.reply === undefined ? undefined : authors.get(activity.reply);
+        if (!matchesCatchSelection(activity.actor, audienceOf(activity), filter, replyAuthor))
             continue;
         if (delivery.isSeen(viewer, activity.index))
             continue;

package/dist/catch-selection.d.ts

@@ -0,0 +1,6 @@
+import { type Audience } from './square-core.js';
+/** Pure filter over settled audience facts; unread/directed eligibility and paging belong to callers. */
+export declare function matchesCatchSelection(actor: string, audience: Audience, filter: {
+    readonly participants?: readonly string[];
+    readonly mention?: string;
+}, replyAuthor?: string): boolean;

package/dist/catch-selection.js

@@ -0,0 +1,14 @@
+import { sameName } from './model.js';
+import { audienceIncludes } from './square-core.js';
+/** Pure filter over settled audience facts; unread/directed eligibility and paging belong to callers. */
+export function matchesCatchSelection(actor, audience, filter, replyAuthor) {
+    if (filter.participants !== undefined && !filter.participants.some((participant) => sameName(participant, actor))) {
+        return false;
+    }
+    if (filter.mention === undefined)
+        return true;
+    // A reply is directed attention in its own right: the viewer is reached as the
+    // author of the activity they answered, exactly like a mention.
+    return audienceIncludes(audience, filter.mention)
+        || (replyAuthor !== undefined && sameName(replyAuthor, filter.mention));
+}

package/dist/claude-delivery.d.ts

@@ -0,0 +1,11 @@
+import type { HostLedgerPort, PresenceRecord } from './host-ledger.js';
+import type { WakeTransportPort } from './ports.js';
+export declare function nativeTokens(text: string): string[];
+export declare function nativePayload(token: string, preview: string): string;
+export declare function createClaudeWakeTransport(hostLedger: HostLedgerPort, env?: NodeJS.ProcessEnv): WakeTransportPort;
+/** Authority comes only from bound memberships and the existing attempt ledger. */
+export declare function observeClaudeDelivery(sessionId: string, text: string, operation: 'guard' | 'admitted' | 'stored', env?: NodeJS.ProcessEnv): Promise<{
+    recognized: boolean;
+    current: boolean;
+}>;
+export type ClaudeBinding = Pick<PresenceRecord, 'location' | 'participant' | 'session' | 'epoch'>;

package/dist/claude-delivery.js

@@ -0,0 +1,145 @@
+import { stat } from 'node:fs/promises';
+import { openSquare } from './square-file-adapter.js';
+import { closeOpenSquare } from './open-square.js';
+import { hostLedgerForEnv } from './registry.js';
+import { nativePendingPreview, projectPresentationEvidence, presentationSuppressesWake } from './square-projections.js';
+import { presentPending } from './presentation-operations.js';
+import { canonicalPath } from './canonical-path.js';
+import { parseActivityId } from './square-core.js';
+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; }
+/**
+ * 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
+ * of native admission.
+ */
+async function writeClaudeWake(sessionId, endpoint, payload, timeoutMs, signal) {
+    try {
+        const agent = await connect({ harness: 'claude', sessionId, endpoint, timeoutMs });
+        await agent.steer(payload, { signal });
+        return { outcome: 'unknown', signature: 'native_admission_unconfirmed', message: 'Claude accepted the local write; native admission is unconfirmed.' };
+    }
+    catch (error) {
+        if (error instanceof DeliveryError && !error.maybeDelivered) {
+            return { outcome: 'failed', unavailable: true, retainRoute: true, signature: 'claude_endpoint_unavailable', message: error.message };
+        }
+        return { outcome: 'unknown', signature: 'native_admission_unconfirmed', message: error instanceof Error ? error.message : String(error) };
+    }
+}
+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.' };
+            try {
+                return (await stat(route.address.endpoint)).isSocket() || { outcome: 'not-capable', diagnostic: 'Claude native inbox endpoint is not a socket.' };
+            }
+            catch {
+                return { outcome: 'not-capable', diagnostic: 'Claude native inbox endpoint unavailable.' };
+            }
+        },
+        attempt: (request, timeoutMs, beforeSend) => dispatchClaude(request, hostLedger, timeoutMs, beforeSend, env),
+    };
+}
+async function currentDelivery(row, hostLedger) {
+    if (row.nativeDelivery?.harness !== 'claude')
+        return undefined;
+    const native = row.nativeDelivery;
+    const owner = (await hostLedger.listPresence({ location: row.location, participant: row.participant })).find((binding) => binding.session === row.session && binding.epoch === native.epoch);
+    const index = parseActivityId(row.activity);
+    if (!owner || index === undefined || !row.claimToken)
+        return undefined;
+    const square = await openSquare(owner.location, { hostLedger });
+    try {
+        const state = (await square.artifact.read()).state;
+        const preview = nativePendingPreview(state, { location: row.location, routeKind: 'claude-native', sessionId: row.session, participant: row.participant, actIndex: index, epoch: native.epoch, address: { endpoint: native.endpoint }, cancelledThrough: owner.cancelledThrough, now: Date.now() });
+        if (!preview || nativePayload(row.claimToken, preview.payload) !== native.payload)
+            return undefined;
+        return { cancelledThrough: owner.cancelledThrough, clipped: preview.clipped };
+    }
+    finally {
+        await closeOpenSquare(square);
+    }
+}
+/** Square owns rendering, correlation and evidence; socket transport owns none of them. */
+async function dispatchClaude(request, hostLedger, timeoutMs, beforeSend, env = process.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 hostLedger.withClaimLock(async () => {
+        if (signal.aborted)
+            return { outcome: 'not-capable', diagnostic: 'Native dispatch deadline elapsed before send.' };
+        if (!request.claimToken || !await (beforeSend?.() ?? Promise.resolve(true)))
+            return { outcome: 'unknown', signature: 'native_send_suppressed' };
+        const owner = (await hostLedger.listPresence({ location: request.location, participant: request.participant })).find((binding) => binding.session === request.route.sessionId && binding.epoch === request.route.epoch);
+        if (!owner)
+            return { outcome: 'not-capable', diagnostic: 'Claude binding changed.' };
+        const square = await openSquare(request.location, { hostLedger });
+        let payload;
+        try {
+            const index = parseActivityId(request.activity);
+            const preview = index === undefined ? undefined : nativePendingPreview((await square.artifact.read()).state, { location: request.location, routeKind: 'claude-native', sessionId: request.route.sessionId, participant: request.participant, actIndex: index, epoch: request.route.epoch, address: { endpoint: request.route.address.endpoint }, cancelledThrough: owner.cancelledThrough, now: Date.now() });
+            if (!preview)
+                return { outcome: 'not-capable', diagnostic: 'Catch or consumption owns this activity.' };
+            payload = nativePayload(request.claimToken, preview.payload);
+        }
+        finally {
+            await closeOpenSquare(square);
+        }
+        if (!await (beforeSend?.() ?? Promise.resolve(true)))
+            return { outcome: 'not-capable', diagnostic: 'Native activity was consumed before send.' };
+        const native = { harness: 'claude', payload, epoch: owner.epoch ?? 0, endpoint: request.route.address.endpoint };
+        const row = { location: request.location, participant: request.participant, session: request.route.sessionId, activity: request.activity, kind: 'wake', outcome: 'dispatching', routeKind: 'claude-native', attemptN: request.attemptN, claimToken: request.claimToken, nativeDelivery: native };
+        if (!await currentDelivery(row, hostLedger) || !await hostLedger.prepareNativeWake(row))
+            return { outcome: 'not-capable', diagnostic: 'Native delivery is no longer current.' };
+        if (!await (beforeSend?.() ?? Promise.resolve(true)) || !await currentDelivery(row, hostLedger))
+            return { outcome: 'not-capable', diagnostic: 'Catch, cancellation or consumption won before native write.' };
+        return writeClaudeWake(row.session, native.endpoint, payload, timeoutMs, signal);
+    }, signal);
+}
+/** Authority comes only from bound memberships and the existing attempt ledger. */
+export async function observeClaudeDelivery(sessionId, text, operation, env = process.env) {
+    const ledger = hostLedgerForEnv(env);
+    return ledger.withClaimLock(async () => {
+        const tokens = nativeTokens(text);
+        const rows = (await ledger.listEvidence({ kind: 'wake', session: sessionId })).filter((row) => row.nativeDelivery?.harness === 'claude' && row.claimToken && tokens.includes(row.claimToken) && ['dispatching', 'unknown', 'accepted'].includes(row.outcome));
+        let current = false;
+        for (const row of rows) {
+            if (row.nativeDelivery?.harness !== 'claude')
+                continue;
+            const native = row.nativeDelivery;
+            const pending = await currentDelivery(row, ledger).catch(() => undefined);
+            if (!pending || !text.includes(native.payload))
+                continue;
+            current = true;
+            if (operation === 'admitted') {
+                if (text === native.payload)
+                    await ledger.confirmWakeAdmission({ ...row, claimToken: row.claimToken });
+            }
+            if (operation === 'stored') {
+                await ledger.confirmWakeAdmission({ ...row, claimToken: row.claimToken });
+                const prior = await projectPresentationEvidence({ hostLedger: ledger, location: row.location, participant: row.participant, sessionId, activity: row.activity });
+                if (presentationSuppressesWake(prior))
+                    continue;
+                const square = await openSquare(row.location, { hostLedger: ledger, env });
+                try {
+                    await presentPending({ artifact: square.artifact, hostLedger: ledger, location: row.location, participant: row.participant, session: sessionId, activity: row.activity, sink: { present() { } }, markSeen: !pending.clipped, current: (state) => {
+                            const index = parseActivityId(row.activity);
+                            if (index === undefined)
+                                return false;
+                            const preview = nativePendingPreview(state, { location: row.location, routeKind: 'claude-native', sessionId: row.session, participant: row.participant, actIndex: index, epoch: native.epoch, address: { endpoint: native.endpoint }, cancelledThrough: pending.cancelledThrough, now: Date.now() });
+                            return preview !== undefined && nativePayload(row.claimToken, preview.payload) === native.payload;
+                        } });
+                }
+                finally {
+                    await closeOpenSquare(square);
+                }
+            }
+        }
+        return { recognized: rows.length > 0, current };
+    });
+}

package/dist/claude-mod.d.ts

@@ -0,0 +1,8 @@
+export interface ClaudeCoordinate {
+    readonly sessionId: string;
+    readonly cwd: string;
+    readonly version: string;
+    readonly endpoint?: string;
+}
+/** JSON stdin bridge. Identity is explicit per operation; process.env is never rewritten. */
+export declare function runClaudeMod(inputText: string, env?: NodeJS.ProcessEnv): Promise<string>;

package/dist/claude-mod.js

@@ -0,0 +1,164 @@
+import { automaticSessionStart, operationEnv } from './automatic-session.js';
+import { claimSessionParticipant, hostLedgerForEnv } from './registry.js';
+import { openSquare } from './square-file-adapter.js';
+import { closeOpenSquare } from './open-square.js';
+import { publishWakeRoute, retireWakeRouteFromArtifact } from './routes.js';
+import { Square } from './square-wiring.js';
+import { observeClaudeDelivery } from './claude-delivery.js';
+import { processActNotificationsOnce } from './notifications.js';
+import { sweepPending } from './delivery-operations.js';
+/** JSON stdin bridge. Identity is explicit per operation; process.env is never rewritten. */
+export async function runClaudeMod(inputText, env = process.env) {
+    if (inputText.length > 512_000)
+        throw new Error('Claude bridge input exceeds its bound.');
+    const input = JSON.parse(inputText);
+    if (!input || typeof input.sessionId !== 'string' || !input.sessionId || typeof input.cwd !== 'string')
+        throw new Error('Claude bridge coordinate missing.');
+    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('/');
+    if (input.operation === 'end') {
+        const retired = [];
+        const captured = [...input.bindings ?? []];
+        // Discover committed late joins at the pinned end boundary, never later owners.
+        if (input.endedAt !== undefined)
+            for (const row of await ledger.listPresence({ session: input.sessionId })) {
+                if (row.channel === 'claude-code' && (row.updatedAt ?? Infinity) <= input.endedAt && !captured.some((binding) => binding.location === row.location && binding.participant === row.participant))
+                    captured.push(row);
+            }
+        for (const binding of captured) {
+            if (binding.session !== input.sessionId || !Number.isSafeInteger(binding.epoch))
+                continue;
+            const square = await Square.at({ path: binding.location, hostLedger: ledger, env: scoped });
+            try {
+                const ended = await square.endOwnedSession(binding.participant, input.sessionId, binding.epoch);
+                if (ended?.activity) {
+                    retired.push(binding);
+                    const row = { location: binding.location, participant: binding.participant, session: input.sessionId, activity: ended.activity.id, kind: 'lifecycle', bindingEpoch: binding.epoch, outcome: 'retired' };
+                    const claim = await ledger.claimEvidence({ ...row, leaseMs: 1000 });
+                    if (claim.status === 'acquired')
+                        await ledger.appendEvidence({ ...row, claimToken: claim.claimToken });
+                }
+            }
+            finally {
+                await square.close();
+            }
+            if (signal.aborted)
+                break;
+        }
+        return `${JSON.stringify({ retired })}\n`;
+    }
+    const recovery = new Set();
+    const cancelledBindings = [...input.cancelledBindings ?? []];
+    if (input.operation === 'start') {
+        // Host state survives reload, not conversation replacement. Resume authority is
+        // the existing lifecycle ledger plus the exact ended activity, never peer text.
+        if (input.resume)
+            for (const row of await ledger.listEvidence({ kind: 'lifecycle', session: input.sessionId })) {
+                if (signal.aborted || row.outcome !== 'retired' || !Number.isSafeInteger(row.bindingEpoch))
+                    continue;
+                const probe = await openSquare(row.location, { hostLedger: ledger, env: scoped, signal });
+                let eligible = false;
+                try {
+                    const state = (await probe.artifact.read(signal)).state;
+                    const last = state.acts.findLast((activity) => activity.actor === row.participant && ['join', 'done', 'kick'].includes(activity.kind));
+                    eligible = last?.kind === 'done' && `act/${last.index}` === row.activity;
+                }
+                finally {
+                    await closeOpenSquare(probe);
+                }
+                if (!eligible)
+                    continue;
+                const claimed = await ledger.claimPresence({ location: row.location, participant: row.participant, session: input.sessionId, channel: 'claude-code', epoch: row.bindingEpoch + 1, updatedAt: Date.now() }, signal);
+                if (claimed.status !== 'acquired')
+                    continue;
+                const square = await Square.at({ path: row.location, hostLedger: ledger, env: scoped });
+                try {
+                    await square.join(row.participant);
+                }
+                catch {
+                    await ledger.removePresenceIfUnchanged(claimed.record);
+                }
+                finally {
+                    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 });
+        for (const binding of memberships) {
+            if (binding.channel !== 'claude-code' || signal.aborted)
+                continue;
+            const expected = input.bindings?.find((row) => row.location === binding.location && row.participant === binding.participant && row.session === input.sessionId);
+            const cancelled = input.cancelledBindings?.find((row) => row.location === binding.location && row.participant === binding.participant && row.session === input.sessionId)
+                ?? (input.operation === 'cancel' ? expected : undefined);
+            const lateCancelledJoin = input.operation === 'cancel' && input.cancelAt !== undefined && (binding.updatedAt ?? Infinity) <= input.cancelAt && expected === undefined;
+            if (lateCancelledJoin)
+                cancelledBindings.push(binding);
+            if (input.operation !== 'start' && input.operation !== 'reconcile' && !lateCancelledJoin && (!expected || expected.epoch !== binding.epoch))
+                continue;
+            const claim = await claimSessionParticipant(binding.location, binding.participant, ledger, scoped, signal);
+            if (!claim || claim.epoch !== (binding.epoch ?? 0))
+                continue;
+            await ledger.withClaimLock(async () => {
+                const current = (await ledger.listPresence({ location: binding.location, participant: binding.participant })).find((row) => row.session === input.sessionId && (row.epoch ?? 0) === claim.epoch);
+                if (!current)
+                    return;
+                const epoch = claim.epoch || 1;
+                if (current.epoch !== epoch)
+                    await ledger.ensurePresence({ ...current, epoch });
+                const square = await openSquare(binding.location, { hostLedger: ledger, env: scoped, signal });
+                try {
+                    const state = (await square.artifact.read(signal)).state;
+                    const existing = state.routes?.find((route) => route.participant === binding.participant && route.sessionId === input.sessionId && route.kind === 'claude-native' && route.epoch === epoch);
+                    if (!supported) {
+                        if (existing)
+                            await retireWakeRouteFromArtifact(square.artifact, existing, { expectedEpoch: epoch });
+                        return;
+                    }
+                    const cutoff = cancelled?.epoch === epoch || (lateCancelledJoin && current.epoch === binding.epoch && (current.updatedAt ?? Infinity) <= input.cancelAt) ? input.cancelAt : undefined;
+                    if (cutoff !== undefined) {
+                        const through = state.acts.filter((activity) => activity.at <= cutoff).reduce((highest, activity) => Math.max(highest, activity.index), -1);
+                        await ledger.suppressPresence({ ...current, epoch }, through);
+                    }
+                    if (!existing || existing.address.endpoint !== input.endpoint)
+                        recovery.add(binding.location);
+                    await publishWakeRoute(square.artifact, { location: binding.location, participant: binding.participant, sessionId: input.sessionId, channel: 'claude-code', kind: 'claude-native', epoch, address: { sessionId: input.sessionId, endpoint: input.endpoint, version: input.version, platform: 'darwin', loaded: 'true' } }, { requireCurrentSession: true });
+                }
+                finally {
+                    await closeOpenSquare(square);
+                }
+            }, signal);
+        }
+    }
+    if (input.operation === 'start' || input.operation === 'reconcile' || input.operation === 'cancel') {
+        const bindings = (await ledger.listPresence({ session: input.sessionId })).filter((row) => row.channel === 'claude-code').map(({ location, participant, session, epoch }) => ({ location, participant, session, epoch }));
+        // One startup recovery pass for known unsent work. Unknown/admitted sends never replay.
+        if (supported && input.operation !== 'cancel')
+            for (const binding of bindings) {
+                if (signal.aborted)
+                    break;
+                if (input.operation !== 'start' && !recovery.has(binding.location))
+                    continue;
+                const square = await openSquare(binding.location, { hostLedger: ledger, env, signal });
+                let indices;
+                try {
+                    indices = await sweepPending({ artifact: square.artifact, hostLedger: ledger, location: binding.location, now: Date.now(), graceMs: 0, limit: 8 });
+                }
+                finally {
+                    await closeOpenSquare(square);
+                }
+                for (const index of indices) {
+                    if (signal.aborted)
+                        break;
+                    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`;
+    }
+    if (!['guard', 'admitted', 'stored'].includes(input.operation) || typeof input.text !== 'string')
+        throw new Error('Unknown Claude bridge operation.');
+    return `${JSON.stringify(await observeClaudeDelivery(input.sessionId, input.text, input.operation, env))}\n`;
+}

package/dist/cli/context.d.ts

@@ -14,7 +14,6 @@ export interface CommandSpec<Intent = unknown, Result = void> {
 }
 export declare function readStdin(): Promise<string>;
 export declare function resolveBody(arg: string): Promise<string>;
-export declare function readPipedBodyFallback(): Promise<string | undefined>;
 export declare function fail(message: string, exitCode?: number): never;
 export declare function usage(command: string): never;
 export declare function requireValue(args: string[], index: number, flag: string): string;

package/dist/cli/context.js

@@ -2,7 +2,8 @@ import os from 'node:os';
 import { commandUsageHint } from '../help.js';
 import { parseParticipantList, validateName } from '../model.js';
 import { createHostLedgerPort } from '../host-ledger-file-adapter.js';
-import { projectSessionBindings, sessionIdsFromEnvironment } from '../square-projections.js';
+import { projectSessionBindings } from '../square-projections.js';
+import { sessionIdsFromEnvironment } from '../participant-identity.js';
 export async function readStdin() {
     try {
         let content = '';
@@ -17,12 +18,6 @@ export async function readStdin() {
 export async function resolveBody(arg) {
     return arg === '-' ? readStdin() : arg;
 }
-export async function readPipedBodyFallback() {
-    if (process.stdin.isTTY)
-        return undefined;
-    const content = await readStdin();
-    return content.trim() === '' ? undefined : content;
-}
 export function fail(message, exitCode = 2) {
     process.stderr.write(`${message}\n`);
     process.exit(exitCode);
@@ -116,17 +111,6 @@ const LOCATION_REQUIRED_COMMANDS = new Set([
     'mcp-server',
     'doctor',
 ]);
-function configuredLocation() {
-    const value = process.env.SQUARE_LOCATION?.trim();
-    return value === '' ? undefined : value;
-}
-function configuredName() {
-    const value = process.env.SQUARE_PARTICIPANT_NAME?.trim();
-    if (!value)
-        return undefined;
-    validateName(value);
-    return value;
-}
 export async function parseGlobalArgs(rawArgs) {
     const args = [...rawArgs];
     let requestedPath;
@@ -144,12 +128,16 @@ export async function parseGlobalArgs(rawArgs) {
         }
     }
     const command = args[0];
-    if (name === undefined)
-        name = configuredName();
+    if (name === undefined) {
+        const configured = process.env.SQUARE_PARTICIPANT_NAME?.trim();
+        if (configured)
+            name = configured;
+    }
     if (name !== undefined)
         validateName(name);
     const explicitSquarePath = requestedPath !== undefined;
-    const configured = configuredLocation();
+    const configuredLocation = process.env.SQUARE_LOCATION?.trim();
+    const configured = configuredLocation === '' ? undefined : configuredLocation;
     if (command !== undefined && !['--help', '-h'].includes(command) && locationIsRequired(command) && requestedPath === undefined && configured === undefined) {
         fail(`✕ ${command} needs a square location\nsquare ls`);
     }

package/dist/cli/harness-command.d.ts

@@ -24,5 +24,4 @@ export declare const installCommand: CommandSpec<ParsedInstallCommand, HarnessCo
 export declare const uninstallCommand: CommandSpec<ParsedInstallCommand, HarnessCommandResult>;
 export declare const harnessCommand: CommandSpec<ParsedHarnessCommand, HarnessCommandResult>;
 export declare function formatHarnessResult(result: HarnessCommandResult): string;
-export declare function runHarnessCommand(argv: string[], squarePath?: string): Promise<string>;
 export {};

package/dist/cli/harness-command.js

@@ -1,4 +1,3 @@
-import os from 'node:os';
 import { executeHarnessTarget, harnessTargets, } from '../harness.js';
 function installTargets(intent, action) {
     const available = harnessTargets().filter((target) => target.capabilities.includes(action));
@@ -101,8 +100,3 @@ export const harnessCommand = {
 export function formatHarnessResult(result) {
     return `${[...result.notes, ...result.lines, ...result.failures].join('\n')}\n`;
 }
-export function runHarnessCommand(argv, squarePath) {
-    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/observation-commands.d.ts

@@ -25,6 +25,6 @@ interface InboxIntent {
     limit: number;
 }
 export declare const inboxCommand: CommandSpec<InboxIntent, string>;
-export declare const claudeHookCommand: CommandSpec<undefined, string>;
+export declare const claudeModCommand: CommandSpec<undefined, string>;
 export declare const codexHookCommand: CommandSpec<undefined, string>;
 export {};