@astrosheep/square 0.3.86 → 0.3.88

package/dist/claude-delivery.js

@@ -1,30 +1,40 @@
 import { stat } from 'node:fs/promises';
-import { randomUUID } from 'node:crypto';
-import { openSquare } from './open-square.js';
-import { closeOpenSquare } from './open-square.js';
-import { hostLedgerForEnv } from './registry.js';
-import { projectPresentationEvidence, presentationSuppressesWake } from './square-projections.js';
-import { nativePendingPreview } from './inbox.js';
+import { createHash, randomUUID } from 'node:crypto';
+import { createArtifactPort } from './artifact.js';
 import { presentPending } from './presentation-operations.js';
-import { canonicalPath } from './canonical-path.js';
+import { projectSessionCandidates, nativePendingPreview } from './inbox.js';
+import { sameBody } from './model.js';
 import { parseActivityId } from './square-core.js';
+import { asSeatRef } from './seats.js';
 import { writeClaudeNative } from './packages/agent-delivery/src/claude-native.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.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.
- */
+function sameAddress(left, right) {
+    if (left === undefined)
+        return false;
+    const keys = Object.keys(left);
+    return keys.length === Object.keys(right).length && keys.every((key) => left[key] === right[key]);
+}
+function hashPayload(payload) { return createHash('sha256').update(payload).digest('hex'); }
+function previewFacts(facts, request) {
+    const index = parseActivityId(request.activity);
+    if (index === undefined || request.route.kind !== 'claude-native' || request.route.address.endpoint === undefined)
+        return undefined;
+    return nativePendingPreview(facts, { location: request.location, routeKind: 'claude-native', sessionId: request.route.sessionId,
+        participant: request.participant, actIndex: index, address: { endpoint: request.route.address.endpoint }, now: Date.now() });
+}
+async function preview(artifact, request) {
+    return (await artifact.read((facts) => previewFacts(facts, request))).value;
+}
 async function writeClaudeWake(sessionId, endpoint, messageId, payload, timeoutMs, signal) {
     const result = await writeClaudeNative({ sessionId, endpoint, messageId }, payload, { deadline: Date.now() + timeoutMs, signal });
     if (result.outcome === 'unavailable')
         return { outcome: 'failed', unavailable: true, retainRoute: true, signature: 'claude_endpoint_unavailable', message: result.message };
     return { outcome: 'unknown', signature: 'native_admission_unconfirmed', message: result.outcome === 'written' ? 'Claude accepted the local write; native admission is unconfirmed.' : result.message };
 }
-export function createClaudeWakeTransport(hostLedger, env = process.env) {
+export function createClaudeWakeTransport(env = process.env) {
     return {
         async probe(route) {
             if (!nativeSupported(route))
@@ -36,108 +46,108 @@ export function createClaudeWakeTransport(hostLedger, env = process.env) {
                 return { outcome: 'not-capable', diagnostic: 'Claude native inbox endpoint unavailable.' };
             }
         },
-        attempt: (request, timeoutMs, beforeSend) => dispatchClaude(request, hostLedger, timeoutMs, beforeSend, env),
+        attempt: (request, timeoutMs, beforeSend) => dispatchClaude(request, timeoutMs, beforeSend, env),
     };
 }
-async function currentDelivery(row, hostLedger) {
-    if (row.nativeDelivery?.harness !== 'claude')
+async function dispatchClaude(request, timeoutMs, beforeSend, env = process.env) {
+    void env;
+    const signal = AbortSignal.timeout(timeoutMs);
+    if (!nativeSupported(request.route) || request.artifact === undefined || request.claimToken === undefined)
+        return { outcome: 'not-capable', diagnostic: 'Claude native delivery needs a current artifact claim and loaded inbox.' };
+    if (signal.aborted || !await beforeSend())
+        return { outcome: 'unknown', signature: 'native_send_suppressed' };
+    const prepared = await preview(request.artifact, request);
+    if (prepared === undefined)
+        return { outcome: 'not-capable', diagnostic: 'Claude activity is no longer current.' };
+    const messageId = randomUUID();
+    const payload = nativePayload(request.claimToken, prepared.payload);
+    const correlation = { harness: 'claude', token: request.claimToken, messageId, payloadHash: hashPayload(payload) };
+    if (!await request.artifact.prepareDelivery({ seat: request.seat, claimToken: request.claimToken, correlation }))
+        return { outcome: 'not-capable', diagnostic: 'Claude delivery claim is no longer current.' };
+    const fresh = await preview(request.artifact, request);
+    if (fresh === undefined || nativePayload(request.claimToken, fresh.payload) !== payload)
+        return { outcome: 'not-capable', diagnostic: 'Claude activity changed before native write.' };
+    if (signal.aborted || !await beforeSend())
+        return { outcome: 'not-capable', diagnostic: 'Claude activity was consumed before native write.' };
+    return writeClaudeWake(request.route.sessionId, request.route.address.endpoint, messageId, payload, timeoutMs, signal);
+}
+function currentPayload(facts, request) {
+    const seat = facts.seat(request.participant), evidence = facts.deliveryByToken(request.claimToken);
+    if (seat === undefined || evidence === undefined || seat.generation !== evidence.generation
+        || seat.generation !== request.seat.generation || !sameBody(seat.body, request.seat.body)
+        || seat.body.channel !== 'claude-code' || seat.body.session !== request.route.sessionId
+        || evidence.activity !== request.activity || !['dispatching', 'unknown', 'accepted'].includes(evidence.outcome)
+        || seat.wakeAddress?.kind !== 'claude-native' || !sameAddress(seat.wakeAddress.address, request.route.address))
         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)
+    const native = previewFacts(facts, request);
+    if (native === undefined)
         return undefined;
-    const square = await openSquare(owner.location, { hostLedger });
-    try {
-        const { value: preview } = await square.artifact.read((facts) => nativePendingPreview(facts, { 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);
-    }
+    const payload = nativePayload(request.claimToken, native.payload);
+    return evidence.correlation?.payloadHash === hashPayload(payload) ? payload : undefined;
 }
-/** 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 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;
+async function rowsForSession(sessionId, env, tokens) {
+    const rows = [];
+    const paths = new Set((await projectSessionCandidates({ sessionId, channel: 'claude-code', env })).map(candidate => candidate.location));
+    for (const location of paths) {
+        const artifact = createArtifactPort(location);
         try {
-            const index = parseActivityId(request.activity);
-            const preview = index === undefined ? undefined : (await square.artifact.read((facts) => nativePendingPreview(facts, { 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() }))).value;
-            if (!preview)
-                return { outcome: 'not-capable', diagnostic: 'Catch or consumption owns this activity.' };
-            payload = nativePayload(request.claimToken, preview.payload);
+            const found = await artifact.read((facts) => tokens.flatMap((token) => {
+                const evidence = facts.deliveryByToken(token);
+                if (evidence?.kind !== 'wake' || evidence.correlation?.harness !== 'claude' || evidence.correlation.token !== token
+                    || evidence.route?.kind !== 'claude-native' || evidence.route.address.sessionId !== sessionId)
+                    return [];
+                const row = { artifact, evidence };
+                const seat = facts.seat(evidence.participant), index = parseActivityId(evidence.activity);
+                const item = index === undefined ? undefined : facts.activity(index);
+                if (seat === undefined || item?.kind !== 'say')
+                    return [row];
+                const route = { location, participant: seat.participant, sessionId, channel: 'claude-code',
+                    ...evidence.route, updatedAt: evidence.at };
+                const request = { location, participant: seat.participant, activity: evidence.activity,
+                    actor: item.actor, seat: asSeatRef(seat), claimToken: token, attemptN: evidence.attemptN, route, artifact };
+                return [{ ...row, request, payload: currentPayload(facts, request) }];
+            }));
+            rows.push(...found.value);
+            if (found.value.length === 0)
+                await artifact.close();
         }
-        finally {
-            await closeOpenSquare(square);
+        catch {
+            await artifact.close();
         }
-        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, messageId: randomUUID() };
-        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, native.messageId, payload, timeoutMs, signal);
-    }, signal);
+    }
+    return rows;
 }
-/** Retired tokens veto a frame; only live correlations and bound memberships confer authority. */
+/** Recognize the whole frame first; one inactive token vetoes it before any evidence/receipt write. */
 export async function observeClaudeDelivery(sessionId, text, operation, env = process.env) {
-    const ledger = hostLedgerForEnv(env);
-    return ledger.withClaimLock(async () => {
-        const tokens = nativeTokens(text);
-        const { deliveries: rows, retired } = await ledger.lookupNativeTokens({ harness: 'claude', session: sessionId, tokens });
-        // A stale token vetoes the entire frame, including a mixed current/stale frame,
-        // before admission, artifact reads or presentation can confer any authority.
-        if (retired.length)
-            return { recognized: true, current: false };
-        let current = false;
+    const tokens = nativeTokens(text);
+    if (tokens.length === 0)
+        return { recognized: false, current: false };
+    const rows = await rowsForSession(sessionId, env, [...new Set(tokens)]);
+    const recognized = rows.length > 0;
+    const frames = [...text.matchAll(/(?:^|\n)(\[square-inbox:([a-zA-Z0-9-]+)\]\n[\s\S]*?\n\[\/square-inbox:\2\])(?=\n|$)/g)];
+    try {
+        if (!recognized || rows.some(row => {
+            const matching = frames.filter(frame => frame[2] === row.evidence.claimToken);
+            return row.payload === undefined || matching.length !== tokens.filter(token => token === row.evidence.claimToken).length
+                || matching.some(frame => frame[1] !== row.payload);
+        }))
+            return { recognized, current: false };
         for (const row of rows) {
-            if (row.nativeDelivery?.harness !== 'claude' || !['dispatching', 'unknown', 'accepted'].includes(row.outcome))
+            if (operation === 'guard')
                 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: (facts) => {
-                            const index = parseActivityId(row.activity);
-                            if (index === undefined)
-                                return false;
-                            const preview = nativePendingPreview(facts, { 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);
-                }
-            }
+            const request = row.request, payload = row.payload;
+            const admitted = await row.artifact.transactAs({ kind: 'participant', seat: request.seat }, facts => currentPayload(facts, request) === payload && facts.completeDelivery({ seat: request.seat,
+                activity: row.evidence.activity, claimToken: request.claimToken, outcome: 'accepted', at: Date.now() })).catch(() => ({ value: false }));
+            if (!admitted.value)
+                return { recognized, current: false };
+            if (operation === 'stored')
+                await presentPending({ artifact: row.artifact, location: request.location,
+                    participant: request.participant, activity: request.activity, seat: request.seat, sink: { present() { } },
+                    current: facts => currentPayload(facts, request) === payload });
         }
-        return { recognized: rows.length > 0, current };
-    });
+        return { recognized, current: true };
+    }
+    finally {
+        await Promise.all([...new Set(rows.map(row => row.artifact))].map(artifact => artifact.close()));
+    }
 }

package/dist/claude-mcp-context.js

@@ -3,7 +3,7 @@ import { promises as fs } from 'node:fs';
 import path from 'node:path';
 import { z } from 'zod/v4';
 import { withFileLock } from './file-lock.js';
-import { hostLedgerRoot } from './host-ledger-root.js';
+import { squareIndexPath } from './square-index.js';
 import { SquareError } from './model.js';
 const LEASE_MS = 10 * 60 * 1000;
 const text = z.string().max(4096).refine(value => value.trim().length > 0 && !/[\x00-\x1f\x7f]/u.test(value));
@@ -12,7 +12,7 @@ const coordinate = z.object({
 });
 const record = coordinate.extend({ token: z.string().regex(/^[a-f0-9]{64}$/u), expiresAt: z.number() });
 const unavailable = () => new SquareError('unavailable', 'Claude MCP call context unavailable');
-const storeRoot = (env) => path.resolve(hostLedgerRoot(env), 'claude-mcp-calls');
+const storeRoot = (env) => path.join(path.dirname(squareIndexPath(env)), 'claude-mcp-calls');
 const callFile = (root, id) => path.join(root, `${createHash('sha256').update(id).digest('hex')}.json`);
 async function readRecord(file) {
     try {

package/dist/claude-mod.js

@@ -1,14 +1,18 @@
 import { operationEnv } from './participant-identity.js';
-import { claimSessionParticipant, hostLedgerForEnv } from './registry.js';
-import { openSquare } from './open-square.js';
-import { closeOpenSquare } from './open-square.js';
-import { publishWakeRoute, retireWakeRouteFromArtifact } from './routes.js';
+import { createArtifactPort } from './artifact.js';
+import { recordClaudeDeliveryStatus } from './claude-delivery-status.js';
 import { Square } from './square-api.js';
 import { observeClaudeDelivery } from './claude-delivery.js';
 import { processActNotificationsOnce } from './notifications.js';
 import { sweepPending } from './delivery-operations.js';
 import { beginClaudeMcpCall, endClaudeMcpCall } from './claude-mcp-context.js';
-import { recordClaudeDeliveryStatus } from './claude-delivery-status.js';
+import { asSeatRef } from './seats.js';
+import { projectSessionSeats, projectSessionCandidates } from './inbox.js';
+import { InternalSquareError, SquareError, sameBody } from './model.js';
+/** Persisted hook state keeps its wire coordinate; internal consumers keep the located seat. */
+function claudeBinding({ location, seat }) {
+    return { location, participant: seat.participant, session: seat.body.session, generation: seat.generation };
+}
 /** 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)
@@ -28,31 +32,30 @@ export async function runClaudeMod(inputText, env = process.env) {
         return '{}\n';
     }
     const scoped = operationEnv('claude', input.sessionId, env);
-    const ledger = hostLedgerForEnv(env);
     const signal = AbortSignal.timeout(2500);
+    const body = { channel: 'claude-code', session: input.sessionId, ...(input.agentId === undefined ? {} : { agent: input.agentId }) };
     const supported = process.platform === 'darwin' && typeof input.endpoint === 'string' && input.endpoint.startsWith('/');
+    const sessionSeats = () => projectSessionSeats({ body, env }, signal);
     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 member of await sessionSeats()) {
+                if (member.joinedAt > input.endedAt || captured.some((item) => item.location === member.location
+                    && item.participant === member.seat.participant && item.generation === member.seat.generation))
+                    continue;
+                captured.push(claudeBinding(member));
             }
         for (const binding of captured) {
-            if (binding.session !== input.sessionId || !Number.isSafeInteger(binding.epoch))
+            if (binding.session !== input.sessionId)
                 continue;
-            const square = await Square.at({ path: binding.location, hostLedger: ledger, env: scoped });
+            const square = await Square.at({ path: binding.location, env: scoped, body,
+                participant: binding.participant });
             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 });
-                }
+                const ended = await square.endOwnedSession(binding.participant, input.sessionId, binding.generation, body);
+                if (ended?.activity)
+                    retired.push({ ...binding, generation: binding.generation });
             }
             finally {
                 await square.close();
@@ -64,122 +67,133 @@ export async function runClaudeMod(inputText, env = process.env) {
     }
     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 { value: last } = await probe.artifact.read((facts) => facts.activityHeads({
-                        actors: [row.participant], actorMatch: 'exact', kinds: ['join', 'done'],
-                    }, { edge: 'newest', limit: 1 }).items[0], signal);
-                    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')
+    if (input.operation === 'start' && input.resume) {
+        // Resume is proven by the artifact's latest participant lifecycle, while HOME
+        // contributes only candidate paths. A stale candidate never establishes a seat.
+        const candidates = await projectSessionCandidates({ body, env });
+        const seen = new Set();
+        for (const candidate of candidates) {
+            if (signal.aborted)
+                break;
+            const probe = createArtifactPort(candidate.location, undefined, signal);
+            let names;
+            try {
+                names = (await probe.read(facts => facts.completedSeatsForBody(body).map(seat => seat.participant), signal)).value;
+            }
+            catch (error) {
+                if (error instanceof InternalSquareError && error.code === 'not_found')
+                    throw new SquareError('unavailable', `Square is unavailable at ${candidate.location}`);
+                throw error;
+            }
+            finally {
+                await probe.close();
+            }
+            for (const participant of names) {
+                const key = `${candidate.location}\0${participant}`;
+                if (seen.has(key))
                     continue;
-                const square = await Square.at({ path: row.location, hostLedger: ledger, env: scoped });
+                seen.add(key);
+                const square = await Square.at({ path: candidate.location, env: scoped, body, participant });
                 try {
-                    await square.join(row.participant);
-                }
-                catch {
-                    await ledger.removePresenceIfUnchanged(claimed.record);
+                    await square.join(participant);
                 }
                 finally {
                     await square.close();
                 }
             }
+        }
     }
     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))
+        for (const member of await sessionSeats()) {
+            if (signal.aborted)
+                break;
+            const { location, seat: capturedSeat, joinedAt } = member;
+            const matches = (item) => item !== undefined
+                && item.location === location && item.participant === capturedSeat.participant && item.session === capturedSeat.body.session
+                && (item.generation === undefined || item.generation === capturedSeat.generation);
+            const expected = input.bindings?.find(matches);
+            const cancelled = input.cancelledBindings?.find(matches) ?? (input.operation === 'cancel' ? expected : undefined);
+            const lateCancelledJoin = input.operation === 'cancel' && input.cancelAt !== undefined
+                && joinedAt <= input.cancelAt && expected === undefined;
+            if (lateCancelledJoin && !cancelledBindings.some(matches))
+                cancelledBindings.push(claudeBinding(member));
+            if (input.operation !== 'start' && input.operation !== 'reconcile' && !lateCancelledJoin && expected === undefined)
                 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 { value: existing } = await square.artifact.read((facts) => facts.routes().find((route) => route.participant === binding.participant && route.sessionId === input.sessionId && route.kind === 'claude-native' && route.epoch === epoch), signal);
-                    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 { value: through } = await square.artifact.read((facts) => {
-                            let beforeIndex;
-                            for (;;) {
-                                const page = facts.activityHeads({ beforeIndex }, { edge: 'newest', limit: 100 });
-                                const last = [...page.items].reverse().find((activity) => activity.at <= cutoff);
-                                if (last !== undefined)
-                                    return last.index;
-                                if (!page.hasMore)
-                                    return -1;
-                                beforeIndex = page.items[0].index;
-                            }
-                        }, signal);
-                        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 });
+            const artifact = createArtifactPort(location, undefined, signal);
+            try {
+                const { value: currentSeat } = await artifact.read((facts) => facts.seat(capturedSeat.participant), signal);
+                if (currentSeat === undefined || currentSeat.generation !== capturedSeat.generation
+                    || !sameBody(currentSeat.body, capturedSeat.body))
+                    continue;
+                const seat = asSeatRef(currentSeat);
+                const existing = currentSeat.wakeAddress?.kind === 'claude-native' ? currentSeat.wakeAddress : undefined;
+                const cutoff = input.cancelAt !== undefined && (cancelled !== undefined || lateCancelledJoin) ? input.cancelAt : undefined;
+                if (cutoff !== undefined) {
+                    const { value: through } = await artifact.read((facts) => {
+                        let beforeIndex;
+                        for (;;) {
+                            const page = facts.activityHeads({ beforeIndex }, { edge: 'newest', limit: 100 });
+                            const last = [...page.items].reverse().find((activity) => activity.at <= cutoff);
+                            if (last !== undefined)
+                                return last.index;
+                            if (!page.hasMore)
+                                return -1;
+                            beforeIndex = page.items[0].index;
+                        }
+                    }, signal);
+                    if (through >= 0)
+                        await artifact.cancelDeliveries(seat, through, signal);
                 }
-                finally {
-                    await closeOpenSquare(square);
+                if (!supported) {
+                    if (existing !== undefined)
+                        await artifact.transactAs({ kind: 'participant', seat }, (facts) => facts.updateWakeAddress(seat, undefined), signal);
+                    continue;
                 }
-            }, signal);
+                if (existing === undefined || existing.address.endpoint !== input.endpoint)
+                    recovery.add(location);
+                await artifact.transactAs({ kind: 'participant', seat }, (facts) => facts.updateWakeAddress(seat, {
+                    kind: 'claude-native', address: { sessionId: input.sessionId, endpoint: input.endpoint, version: input.version, platform: 'darwin', loaded: 'true' },
+                }), signal);
+            }
+            catch (error) {
+                if (error instanceof InternalSquareError && error.code === 'not_found')
+                    throw new SquareError('unavailable', `Square is unavailable at ${location}`);
+                throw error;
+            }
+            finally {
+                await artifact.close();
+            }
         }
     }
     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 }));
+        const members = await sessionSeats();
         // One startup recovery pass for known unsent work. Unknown/admitted sends never replay.
         if (supported && input.operation !== 'cancel')
-            for (const binding of bindings) {
+            for (const { location } of members) {
                 if (signal.aborted)
                     break;
-                if (input.operation !== 'start' && !recovery.has(binding.location))
+                if (input.operation !== 'start' && !recovery.has(location))
                     continue;
-                const square = await openSquare(binding.location, { hostLedger: ledger, env, signal });
+                const artifact = createArtifactPort(location, undefined, signal);
                 let indices;
                 try {
-                    indices = await sweepPending({ artifact: square.artifact, hostLedger: ledger, location: binding.location, now: Date.now(), graceMs: 0, limit: 8 });
+                    indices = await sweepPending({ artifact, location, now: Date.now(), graceMs: 0, limit: 8 });
+                }
+                catch (error) {
+                    if (error instanceof InternalSquareError && error.code === 'not_found')
+                        throw new SquareError('unavailable', `Square is unavailable at ${location}`);
+                    throw error;
                 }
                 finally {
-                    await closeOpenSquare(square);
+                    await artifact.close();
                 }
                 for (const index of indices) {
                     if (signal.aborted)
                         break;
-                    await processActNotificationsOnce(binding.location, index, { env: { ...env, SQUARE_NOTIFY_DELIVERY_WAIT_MS: '200' } });
+                    await processActNotificationsOnce(location, index, { env: { ...env, SQUARE_NOTIFY_DELIVERY_WAIT_MS: '200' } });
                 }
             }
-        return `${JSON.stringify({ available: supported, diagnostic: supported ? undefined : 'Native inbox unavailable: requires macOS Claude with an interactive loaded mod and its real endpoint.', bindings, cancelledBindings })}\n`;
+        return `${JSON.stringify({ available: supported, diagnostic: supported ? undefined : 'Native inbox unavailable: requires macOS Claude with an interactive loaded mod and its real endpoint.', bindings: members.map(claudeBinding), cancelledBindings })}\n`;
     }
     if (!['guard', 'admitted', 'stored'].includes(input.operation) || typeof input.text !== 'string')
         throw new Error('Unknown Claude bridge operation.');

package/dist/cli/context.d.ts

@@ -1,6 +1,6 @@
 import { type HardCap } from '../model.js';
 import { Square } from '../square-api.js';
-import type { OperationControl } from '../square-facade.js';
+import type { Body, OperationControl } from '../square-facade.js';
 export interface CommandContext {
     cwd: string;
     env: NodeJS.ProcessEnv;
@@ -36,6 +36,8 @@ export declare function parseGlobalArgs(rawArgs: string[]): Promise<ParsedGlobal
 export declare function locationIsRequired(command: string): boolean;
 export declare function defaultContext(command: string, squarePath?: string, name?: string): CommandContext;
 export declare function squareInput(context: CommandContext): {
+    wakeAddress?: import("../model.js").WakeAddress | undefined;
+    body?: Body | undefined;
     cwd: string;
     env: NodeJS.ProcessEnv;
     path: string | undefined;