@astrosheep/square 0.3.93 → 0.3.95

package/dist/activity-feed.d.ts

@@ -1,6 +1,4 @@
 import type { SquareRead } from './ports.js';
-import type { StoredAct } from './model.js';
-/** Directed suffix includes seen rows beyond an earlier hole, unlike notification pending. */
-export declare function directedSuffix(facts: SquareRead, name: string): Extract<StoredAct, {
-    kind: 'say';
-}>[];
+import type { ExpressContext } from './square-facade.js';
+/** A bounded, nonconsuming glimpse; seen rows beyond a cursor hole must not reappear. */
+export declare function expressionContext(facts: SquareRead, name: string): ExpressContext;

package/dist/activity-feed.js

@@ -1,15 +1,17 @@
-import { readCursor } from './runtime.js';
-/** Directed suffix includes seen rows beyond an earlier hole, unlike notification pending. */
-export function directedSuffix(facts, name) {
-    const result = [];
-    let afterIndex = readCursor(facts, name);
-    while (true) {
-        const page = facts.directed(name, { afterIndex }, { edge: 'oldest', limit: 100 });
-        for (const act of facts.activities(page.items.map((head) => head.index)))
-            if (act.kind === 'say')
-                result.push(act);
-        if (!page.hasMore)
-            return result;
-        afterIndex = page.items.at(-1).index;
-    }
+import { formatActivityId } from './square-core.js';
+const CONTEXT_LIMIT = 5;
+const PREVIEW_CHARS = 400;
+/** A bounded, nonconsuming glimpse; seen rows beyond a cursor hole must not reappear. */
+export function expressionContext(facts, name) {
+    const filter = { afterIndex: facts.participant(name)?.lastJoinIndex ?? -1, unseenOnly: true };
+    const page = facts.directed(name, filter, { edge: 'newest', limit: CONTEXT_LIMIT });
+    const activities = facts.activities(page.items.map(head => head.index)).filter(act => act.kind === 'say')
+        .sort((a, b) => a.index - b.index).map(act => {
+        const body = act.body ?? '(structured activity)';
+        // Keep the boundary between Unicode code points, including non-BMP characters.
+        const chars = Array.from(body.slice(0, PREVIEW_CHARS * 2));
+        const preview = chars.slice(0, PREVIEW_CHARS).join('');
+        return { id: formatActivityId(act.index), actor: act.actor, preview, truncated: preview.length < body.length };
+    });
+    return { activities, remaining: Math.max(0, facts.directedCount(name, filter) - activities.length) };
 }

package/dist/artifact.js

@@ -117,13 +117,13 @@ function synchronous(value) {
     }
 }
 const readMethods = [
-    'header', 'participant', 'roster', 'attention', 'incomingAttention', 'hold',
+    'header', 'participant', 'roster', 'attention', 'incomingAttention',
     'activity', 'activityHeads', 'activities', 'activityCount', 'contextIndexes', 'sayOrdinals', 'recentSayTimes',
     'audience', 'directed', 'directedAt', 'directedCount', 'pendingAudience',
-    'receipt', 'receiptFacts', 'receiptAssignments', 'lease', 'participantCounts', 'seat', 'seatsForBody', 'completedSeatsForBody',
+    'receipt', 'receiptFacts', 'receiptAssignments', 'lease', 'participantCounts', 'seat', 'seatsForOwner',
     'deliveryEvidence', 'deliveryByToken', 'cancelledThrough', 'deliveryDeferrals',
 ];
-const writeMethods = ['applyLanding', 'markSeen', 'putLease', 'removeLease', 'storeSeat', 'removeSeat', 'updateWakeAddress', 'cancelThrough', 'claimDelivery', 'prepareDelivery', 'completeDelivery', 'observeNativeDelivery', 'putDeliveryDeferral', 'renewDeliveryDeferral', 'releaseDeliveryDeferral'];
+const writeMethods = ['applyLanding', 'markSeen', 'putLease', 'removeLease', 'storeSeat', 'removeSeat', 'updateWakeAddress', 'reattachSeat', 'detachSeat', 'cancelThrough', 'claimDelivery', 'prepareDelivery', 'completeDelivery', 'observeNativeDelivery', 'putDeliveryDeferral', 'renewDeliveryDeferral', 'releaseDeliveryDeferral'];
 /** One connection, ordered operations, guarded synchronous transaction capabilities. */
 export function createArtifactPort(location, initial, externalSignal) {
     let database;

package/dist/attention.d.ts

@@ -0,0 +1,19 @@
+export type AudienceRoute = 'mention' | 'reply' | 'attention' | 'bell';
+export interface AudienceRecipient {
+    readonly recipient: string;
+    readonly route: AudienceRoute;
+}
+export interface AudienceInput {
+    readonly actor: string;
+    readonly recipients: readonly string[];
+    readonly mentions?: readonly string[];
+    readonly replyAuthor?: string;
+    readonly reach?: 'bell';
+    readonly incoming?: readonly {
+        readonly listener: string;
+        readonly kind: 'listen' | 'ignore';
+    }[];
+    readonly sameIdentity?: (a: string, b: string) => boolean;
+}
+/** Resolve attention against the caller's eligible recipient snapshot. */
+export declare function resolveAudience(input: AudienceInput): readonly AudienceRecipient[];

package/dist/attention.js

@@ -0,0 +1,30 @@
+/** Resolve attention against the caller's eligible recipient snapshot. */
+export function resolveAudience(input) {
+    const same = input.sameIdentity ?? ((a, b) => a === b);
+    const incoming = input.incoming ?? [];
+    const audience = [];
+    const add = (requested, route) => {
+        const recipient = input.recipients.find((item) => same(item, requested));
+        if (recipient === undefined || same(recipient, input.actor)
+            || audience.some((item) => same(item.recipient, recipient)))
+            return;
+        if (input.reach !== 'bell' && incoming.some((item) => item.kind === 'ignore' && same(item.listener, recipient)))
+            return;
+        audience.push({ recipient, route });
+    };
+    if (input.reach === 'bell') {
+        for (const recipient of input.recipients)
+            add(recipient, 'bell');
+    }
+    else {
+        for (const mention of input.mentions ?? [])
+            add(mention, 'mention');
+        if (input.replyAuthor !== undefined)
+            add(input.replyAuthor, 'reply');
+        for (const recipient of input.recipients) {
+            if (incoming.some((item) => item.kind === 'listen' && same(item.listener, recipient)))
+                add(recipient, 'attention');
+        }
+    }
+    return audience;
+}

package/dist/boundary-presentation.d.ts

@@ -1,5 +1,5 @@
 import { pendingAtBoundary } from './inbox.js';
-import type { Body, PendingMembership } from './model.js';
+import type { Owner, PendingMembership } from './model.js';
 export { pendingAtBoundary };
 export declare function renderPendingAtBoundary(inbox: PendingMembership[]): string;
 /**
@@ -11,4 +11,4 @@ export declare function renderPendingAtBoundary(inbox: PendingMembership[]): str
  * after success, captured-seat commits record only its included items without an eligibility veto.
  * A source that cannot verify its reuse must read the inbox again.
  */
-export declare function presentPendingAtBoundary<T>(identity: Body, present: (context: string) => T | Promise<T>, lookup?: (identity: Body, env?: NodeJS.ProcessEnv, signal?: AbortSignal) => Promise<PendingMembership[]> | PendingMembership[], env?: NodeJS.ProcessEnv, signal?: AbortSignal): Promise<T | undefined>;
+export declare function presentPendingAtBoundary<T>(identity: Owner, present: (context: string) => T | Promise<T>, lookup?: (identity: Owner, env?: NodeJS.ProcessEnv, signal?: AbortSignal) => Promise<PendingMembership[]> | PendingMembership[], env?: NodeJS.ProcessEnv, signal?: AbortSignal): Promise<T | undefined>;

package/dist/boundary-presentation.js

@@ -3,6 +3,7 @@ import { createHash } from 'node:crypto';
 import { withFileLock } from './file-lock.js';
 import { createArtifactPort } from './artifact.js';
 import { preparePendingPresentation } from './presentation-operations.js';
+import { presentPreparedBatch } from './delivery-effects.js';
 import { sessionInbox, projectBoundaryEligibility, pendingAtBoundary, pendingKey } from './inbox.js';
 import { attentionBodyIsClipped, renderAttentionPreview, renderSquareReminder } from './attention-presentation.js';
 export { pendingAtBoundary };
@@ -56,53 +57,45 @@ async function presentPendingAtBoundaryUnlocked(identity, present, lookup = sess
     const artifacts = new Map();
     const claims = [];
     try {
-        // Claim the entire candidate batch before its one external effect. No later item needs
-        // a new claim (and new eligibility decision) after its bytes have already been rendered.
-        for (const entry of renderBoundary(pending).complete) {
-            const { location, seat } = entry.membership;
-            let artifact = artifacts.get(location);
-            if (artifact === undefined) {
-                // This boundary owns the connection until all effect evidence/cleanup has settled.
-                // Request cancellation travels with pre-effect operations, not that lifetime.
-                artifact = createArtifactPort(location);
-                artifacts.set(location, artifact);
-            }
-            for (const index of entry.actIndexes) {
-                const claim = await preparePendingPresentation({ artifact, location, participant: seat.participant,
-                    activity: index, seat, markSeen: entry.markSeen, signal });
-                if (claim !== undefined)
-                    claims.push({ key: pendingKey(entry.membership, index), claim });
-            }
-        }
-        const eligible = new Set();
-        for (const { key, claim } of claims)
-            if (await claim.eligible())
-                eligible.add(key);
-        const fresh = renderBoundary(pending.map(membership => ({ ...membership,
-            notifications: membership.notifications.filter(note => eligible.has(pendingKey(membership, note.actIndex))),
-        })));
-        const included = new Set(fresh.complete.flatMap(entry => entry.actIndexes.map(index => pendingKey(entry.membership, index))));
-        if (included.size === 0 || signal?.aborted)
-            return undefined;
-        const rendered = claims.filter(({ key }) => included.has(key));
-        let result;
         try {
-            result = await present(fresh.context);
+            // Enumeration owns discovery/connections only; returned handles belong to the common runner.
+            for (const entry of renderBoundary(pending).complete) {
+                const { location, seat } = entry.membership;
+                let artifact = artifacts.get(location);
+                if (artifact === undefined) {
+                    // Keep connections alive through all signal-independent settlement/cleanup.
+                    artifact = createArtifactPort(location);
+                    artifacts.set(location, artifact);
+                }
+                for (const index of entry.actIndexes) {
+                    const claim = await preparePendingPresentation({ artifact, location, participant: seat.participant,
+                        activity: index, seat, markSeen: entry.markSeen, signal });
+                    if (claim !== undefined)
+                        claims.push({ key: pendingKey(entry.membership, index), claim });
+                }
+            }
         }
         catch (error) {
-            await Promise.all(rendered.map(({ claim }) => claim.release('failed', error instanceof Error ? error.message : String(error))));
+            // Transfer has not happened: enumeration must abandon any custody already acquired.
+            await Promise.all(claims.map(({ claim }) => claim.release()));
             throw error;
         }
-        // These are successful sink effects, not fresh delivery attempts. Settle the entire
-        // rendered set before closing any connection, even if one member's settlement fails.
-        const settlements = await Promise.allSettled(rendered.map(({ claim }) => claim.recordPresented()));
-        for (const settlement of settlements)
-            if (settlement.status === 'rejected')
-                throw settlement.reason;
-        return result;
+        const report = await presentPreparedBatch(claims.map(({ claim }) => claim), eligibleClaims => {
+            const eligible = new Set(claims.filter(({ claim }) => eligibleClaims.includes(claim)).map(({ key }) => key));
+            const fresh = renderBoundary(pending.map(membership => ({ ...membership,
+                notifications: membership.notifications.filter(note => eligible.has(pendingKey(membership, note.actIndex))),
+            })));
+            const included = new Set(fresh.complete.flatMap(entry => entry.actIndexes.map(index => pendingKey(entry.membership, index))));
+            return { payload: fresh.context, included: claims.filter(({ key }) => included.has(key)).map(({ claim }) => claim) };
+        }, present, { signal, classifyError: () => 'failed' });
+        if (report.observation.kind === 'threw')
+            throw report.observation.error;
+        for (const { result } of report.settlements)
+            if (result.persistence.status === 'error')
+                throw result.persistence.error;
+        return report.observation.kind === 'returned' ? report.observation.value : undefined;
     }
     finally {
-        await Promise.all(claims.map(({ claim }) => claim.release()));
         await Promise.all([...artifacts.values()].map(artifact => artifact.close()));
     }
 }

package/dist/catch-decisions.d.ts

@@ -1,23 +1,20 @@
-import { type ActivityId } from './square-core.js';
 import { type StoredAct } from './model.js';
 import type { ActivityIndex, DirectedFilter, SquareRead, SquareWrite } from './ports.js';
-import type { CatchOptions } from './square-facade.js';
+import type { CatchOptions, CatchReason, PerceivedActivity } from './square-facade.js';
 export interface CatchSelection {
     readonly participant: string;
-    readonly activities: readonly StoredAct[];
-    readonly consumedThrough: ActivityId | null;
+    readonly activities: readonly PerceivedActivity[];
     readonly remaining: number;
-    readonly sayNumbers: Readonly<Record<number, number>>;
     readonly standingCount: number;
-    readonly held: boolean;
+    readonly deliveryAvailable: boolean;
     readonly now: number;
     readonly ownActivityCount: number;
     readonly hardCap: number | null;
-    readonly terminalStatus: 'capped' | 'quorum' | undefined;
+    readonly terminalStatus: Extract<CatchReason, 'capped' | 'quorum'> | undefined;
     readonly hint?: string;
 }
 /** Capture a selected page (or an empty completion) without opening another resource. */
-export declare function observeCatchSelection(facts: SquareRead, participant: string, activities: readonly StoredAct[], filter: DirectedFilter, at: number): CatchSelection;
+export declare function observeCatchSelection(facts: SquareRead, participant: string, activities: readonly StoredAct[], filter: DirectedFilter, at: number, remaining?: number): CatchSelection;
 export declare const CATCH_DEFAULT_LIMIT = 10;
 export declare const CATCH_MAX_LIMIT = 100;
 export declare function catchLimit(value: number | undefined): number;

package/dist/catch-decisions.js

@@ -1,19 +1,21 @@
 import { formatActivityId, parseActivityId } from './square-core.js';
-import { readCursor, terminalStatusFor } from './runtime.js';
+import { terminalStatusFor } from './runtime.js';
 import { SquareError } from './model.js';
 import { resolveKnownName } from './decisions.js';
+import { toPerceivedActivity } from './views.js';
 import { catchHint } from './hints.js';
+import { consumeReceived, ReceiveError, selectReceivedHeads } from './receive.js';
+import { squareReceiveRead } from './square-receive.js';
 /** Capture a selected page (or an empty completion) without opening another resource. */
-export function observeCatchSelection(facts, participant, activities, filter, at) {
+export function observeCatchSelection(facts, participant, activities, filter, at, remaining) {
     if (typeof at !== 'number' || !Number.isFinite(at))
         throw new SquareError('invalid_args', 'Catch time must be a finite number.');
-    const cursor = readCursor(facts, participant);
     const counts = facts.participantCounts(), header = facts.header(), current = facts.participant(participant);
     return {
-        participant, activities, consumedThrough: cursor < 0 ? null : formatActivityId(cursor),
-        remaining: facts.directedCount(participant, filter),
-        sayNumbers: activities.length === 0 ? {} : facts.sayOrdinals(activities.map((item) => item.index)),
-        standingCount: counts.joined, held: facts.hold().active, now: at,
+        participant, activities: activities.map(activity => toPerceivedActivity(facts, activity, participant)),
+        remaining: remaining ?? facts.directedCount(participant, filter),
+        standingCount: counts.joined, now: at,
+        deliveryAvailable: facts.seat(participant)?.wakeAddress !== undefined,
         ownActivityCount: current.sayCount, hardCap: header.hardCap,
         terminalStatus: terminalStatusFor(current, header.hardCap, counts),
     };
@@ -27,19 +29,23 @@ export function catchLimit(value) {
     }
     return limit;
 }
-/** Select non-ID catch coordinates without hydrating bodies or recording receipts. */
-export function selectCatchPage(facts, requestedName, options) {
+function catchPageSelection(facts, requestedName, options) {
     const participant = resolveKnownName(facts, requestedName);
     const limit = catchLimit(options.limit);
-    const senders = options.from?.map((name) => resolveKnownName(facts, name));
+    const senders = options.from?.map(name => resolveKnownName(facts, name));
     const filter = { unseenOnly: true, ...(senders === undefined ? {} : { senders }), ...(options.mention === true ? { attentionOnly: true } : {}) };
-    return { participant, indexes: facts.directed(participant, filter, { edge: 'oldest', limit }).items.map((item) => item.index), filter };
+    return { participant, filter, selection: { kind: 'page', query: filter, limit } };
+}
+/** Select non-ID catch coordinates without hydrating bodies or recording receipts. */
+export function selectCatchPage(facts, requestedName, options) {
+    const { participant, filter, selection } = catchPageSelection(facts, requestedName, options);
+    return { participant, indexes: selectReceivedHeads(squareReceiveRead(facts), participant, selection).map(item => item.key), filter };
 }
 /** Selection, receipts and resulting cursor belong to one artifact write transaction. */
 export function decideCatch(facts, requestedName, options, at) {
     let viewer;
-    let delivered;
     let filter = { unseenOnly: true };
+    let selection;
     if (options.id !== undefined) {
         viewer = resolveKnownName(facts, requestedName);
         catchLimit(options.limit);
@@ -48,25 +54,39 @@ export function decideCatch(facts, requestedName, options, at) {
         const index = parseActivityId(options.id);
         if (index === undefined)
             throw new SquareError('invalid_args', 'Invalid catch id: expected an activity id like act/12.');
-        const activity = facts.activity(index);
-        if (activity === undefined || activity.kind !== 'say' || facts.directedAt(viewer, index) === undefined) {
-            throw new SquareError('invalid_args', `✕ ${formatActivityId(index)} isn't addressed to you`, {
-                reason: 'not_addressed', activityId: formatActivityId(index), activityExists: activity !== undefined,
-            });
-        }
-        delivered = [activity];
+        selection = { kind: 'exact', key: index, remainingQuery: filter };
     }
     else {
-        const page = selectCatchPage(facts, requestedName, options);
+        const page = catchPageSelection(facts, requestedName, options);
         viewer = page.participant;
         filter = page.filter;
-        delivered = facts.activities(page.indexes);
+        selection = page.selection;
+    }
+    let consumed;
+    try {
+        consumed = consumeReceived({
+            ...squareReceiveRead(facts),
+            insertReceipt: (ref, time) => facts.markSeen(ref.recipient, [ref.item], time) > 0,
+        }, viewer, selection, at);
+    }
+    catch (error) {
+        if ((error instanceof TypeError || error instanceof RangeError) && (typeof at !== 'number' || !Number.isFinite(at))) {
+            throw new SquareError('invalid_args', 'Invalid square artifact: row is malformed.');
+        }
+        if (!(error instanceof ReceiveError))
+            throw error;
+        if (error.code === 'missing_item')
+            throw new SquareError('invalid_args', 'Invalid square artifact: addressed activity is missing.');
+        const index = error.key;
+        throw new SquareError('invalid_args', `✕ ${formatActivityId(index)} isn't addressed to you`, {
+            reason: 'not_addressed', activityId: formatActivityId(index), activityExists: facts.activity(index) !== undefined,
+        });
     }
-    const marked = facts.markSeen(viewer, delivered.map((item) => item.index), at);
-    const selection = observeCatchSelection(facts, viewer, delivered, filter, at);
+    const delivered = consumed.items.map(item => item.data);
+    const observed = observeCatchSelection(facts, viewer, delivered, filter, at, consumed.remaining);
     // Receipts are the durable catch count: everything directed here minus what is still unseen.
     const caught = facts.directedCount(viewer, {}) - facts.directedCount(viewer, { unseenOnly: true });
     // An exact id catch is a targeted fetch and stays repeatable, so it carries no nudge.
-    const hint = options.id === undefined ? catchHint(caught - marked, caught) : undefined;
-    return hint === undefined ? selection : { ...selection, hint };
+    const hint = options.id === undefined ? catchHint(caught - consumed.newlyConsumed, caught) : undefined;
+    return hint === undefined ? observed : { ...observed, hint };
 }

package/dist/claude-delivery-status.js

@@ -1,4 +1,5 @@
 import { createArtifactPort } from './artifact.js';
+import { decodeHarnessOwner } from './owner.js';
 import { indexedSquareEntries } from './square-index.js';
 const holdReasons = new Set(['explicit-setting', 'managed-setting', 'repo-setting', 'invalid-setting', 'bypass-default', 'mode-unknown', 'mode-mismatch', 'no-mode-asserted']);
 const dropReasons = new Set(['expired', 'refused', 'dropped', 'discarded']);
@@ -13,12 +14,17 @@ export async function recordClaudeDeliveryStatus(input, env = process.env) {
         || (input.state === 'held' ? !holdReasons.has(input.reason ?? '')
             : input.state === 'dropped' ? !dropReasons.has(input.reason ?? '') : input.reason !== undefined))
         return false;
-    for (const entry of await indexedSquareEntries({ channel: 'claude-code', session: input.sessionId }, env)) {
-        const artifact = createArtifactPort(entry.location);
+    const paths = new Set((await indexedSquareEntries({}, env)).filter(entry => {
+        const coordinate = decodeHarnessOwner(entry.owner);
+        return coordinate?.channel === 'claude-code' && coordinate.session === input.sessionId;
+    }).map(entry => entry.location));
+    for (const location of paths) {
+        const artifact = createArtifactPort(location);
         try {
             const { value: match } = await artifact.read((facts) => facts.roster().flatMap((participant) => {
                 const seat = facts.seat(participant.name);
-                if (seat === undefined || seat.body.session !== input.sessionId || seat.body.channel !== 'claude-code')
+                if (seat === undefined || seat.attachment !== 'attached' || seat.wakeAddress?.kind !== 'claude-native'
+                    || seat.wakeAddress.address.sessionId !== input.sessionId)
                     return [];
                 const evidence = facts.deliveryEvidence(seat.participant, seat.generation).find((row) => row.correlation?.harness === 'claude' && row.correlation.messageId === input.messageId && row.claimToken !== undefined);
                 return evidence === undefined ? [] : [{ seat, evidence }];
@@ -26,7 +32,7 @@ export async function recordClaudeDeliveryStatus(input, env = process.env) {
             if (match.length === 0)
                 continue;
             const { seat, evidence } = match[0];
-            const ref = { participant: seat.participant, body: seat.body, generation: seat.generation };
+            const ref = { participant: seat.participant, owner: seat.owner, generation: seat.generation };
             return (await artifact.transactAs({ kind: 'participant', seat: ref }, (facts) => facts.observeNativeDelivery({ seat: ref, claimToken: evidence.claimToken, observation: {
                     eventId: input.eventId, messageId: input.messageId, state: input.state,
                     ...(input.reason === undefined ? {} : { reason: input.reason }), observedAt: input.observedAt,

package/dist/claude-delivery.js

@@ -2,9 +2,10 @@ import { stat } from 'node:fs/promises';
 import { createHash, randomUUID } from 'node:crypto';
 import { createArtifactPort } from './artifact.js';
 import { presentPending } from './presentation-operations.js';
-import { projectSessionCandidates, nativePendingPreview } from './inbox.js';
-import { sameBody } from './model.js';
+import { nativePendingPreview } from './inbox.js';
 import { parseActivityId } from './square-core.js';
+import { decodeHarnessOwner } from './owner.js';
+import { indexedSquareEntries } from './square-index.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;
@@ -22,8 +23,9 @@ 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() });
+    return nativePendingPreview(facts, { location: request.location, routeKind: 'claude-native', generation: request.seat.generation,
+        address: request.route.address,
+        participant: request.participant, actIndex: index, now: Date.now() });
 }
 async function preview(artifact, request) {
     return (await artifact.read((facts) => previewFacts(facts, request))).value;
@@ -31,7 +33,7 @@ async function preview(artifact, request) {
 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: 'failed', 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(env = process.env) {
@@ -69,13 +71,15 @@ async function dispatchClaude(request, timeoutMs, beforeSend, env = process.env)
         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);
+    const sessionId = request.route.address.sessionId;
+    if (sessionId === undefined)
+        return { outcome: 'not-capable', diagnostic: 'Claude native route has no session address.' };
+    return writeClaudeWake(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
+    if (seat === undefined || seat.attachment !== 'attached' || evidence === undefined || seat.generation !== evidence.generation
+        || seat.generation !== request.seat.generation || seat.owner !== request.seat.owner
         || evidence.activity !== request.activity || !['dispatching', 'unknown', 'accepted'].includes(evidence.outcome)
         || seat.wakeAddress?.kind !== 'claude-native' || !sameAddress(seat.wakeAddress.address, request.route.address))
         return undefined;
@@ -87,7 +91,11 @@ function currentPayload(facts, request) {
 }
 async function rowsForSession(sessionId, env, tokens) {
     const rows = [];
-    const paths = new Set((await projectSessionCandidates({ sessionId, channel: 'claude-code', env })).map(candidate => candidate.location));
+    const candidates = (await indexedSquareEntries({}, env)).filter(entry => {
+        const coordinate = decodeHarnessOwner(entry.owner);
+        return coordinate?.channel === 'claude-code' && coordinate.session === sessionId;
+    });
+    const paths = new Set(candidates.map(candidate => candidate.location));
     for (const location of paths) {
         const artifact = createArtifactPort(location);
         try {
@@ -101,7 +109,7 @@ async function rowsForSession(sessionId, env, tokens) {
                 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',
+                const route = { location, participant: seat.participant,
                     ...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 };

package/dist/claude-mod.js

@@ -7,11 +7,13 @@ import { processActNotificationsOnce } from './notifications.js';
 import { sweepPending } from './delivery-operations.js';
 import { beginClaudeMcpCall, endClaudeMcpCall } from './claude-mcp-context.js';
 import { asSeatRef } from './seats.js';
-import { projectSessionSeats, projectSessionCandidates } from './inbox.js';
-import { InternalSquareError, SquareError, sameBody } from './model.js';
+import { projectSessionSeats } from './inbox.js';
+import { restoreSessionSeats } from './session-lifecycle.js';
+import { harnessOwner } from './owner.js';
+import { InternalSquareError, SquareError } 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 };
+function claudeBinding({ location, seat }, sessionId) {
+    return { location, participant: seat.participant, session: sessionId, generation: seat.generation };
 }
 /** JSON stdin bridge. Identity is explicit per operation; process.env is never rewritten. */
 export async function runClaudeMod(inputText, env = process.env) {
@@ -33,29 +35,29 @@ export async function runClaudeMod(inputText, env = process.env) {
     }
     const scoped = operationEnv('claude', input.sessionId, env);
     const signal = AbortSignal.timeout(2500);
-    const body = { channel: 'claude-code', session: input.sessionId, ...(input.agentId === undefined ? {} : { agent: input.agentId }) };
+    const owner = harnessOwner({ 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);
+    const sessionSeats = async () => (await projectSessionSeats({ owner, env }, signal)).filter(member => member.seat.attachment === 'attached');
     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 member of await sessionSeats()) {
+            for (const member of await projectSessionSeats({ owner, env }, signal)) {
                 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));
+                captured.push(claudeBinding(member, input.sessionId));
             }
         for (const binding of captured) {
             if (binding.session !== input.sessionId)
                 continue;
-            const square = await Square.at({ path: binding.location, env: scoped, body,
-                participant: binding.participant });
+            const square = await Square.at({ path: binding.location, env: scoped });
             try {
-                const ended = await square.endOwnedSession(binding.participant, input.sessionId, binding.generation, body);
-                if (ended?.activity)
-                    retired.push({ ...binding, generation: binding.generation });
+                const detached = binding.generation === undefined ? null
+                    : await square.detach(binding.participant, { owner, generation: binding.generation });
+                if (detached)
+                    retired.push(binding);
             }
             finally {
                 await square.close();
@@ -67,41 +69,10 @@ export async function runClaudeMod(inputText, env = process.env) {
     }
     const recovery = new Set();
     const cancelledBindings = [...input.cancelledBindings ?? []];
-    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;
-                seen.add(key);
-                const square = await Square.at({ path: candidate.location, env: scoped, body, participant });
-                try {
-                    await square.join(participant);
-                }
-                finally {
-                    await square.close();
-                }
-            }
-        }
+    if (input.operation === 'start') {
+        await restoreSessionSeats(owner, scoped, supported ? {
+            kind: 'claude-native', address: { sessionId: input.sessionId, endpoint: input.endpoint, version: input.version, platform: 'darwin', loaded: 'true' },
+        } : undefined, signal);
     }
     if (input.operation === 'start' || input.operation === 'reconcile' || input.operation === 'cancel' || input.cancelAt !== undefined) {
         for (const member of await sessionSeats()) {
@@ -109,21 +80,21 @@ export async function runClaudeMod(inputText, env = process.env) {
                 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.location === location && item.participant === capturedSeat.participant && item.session === input.sessionId
                 && (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));
+                cancelledBindings.push(claudeBinding(member, input.sessionId));
             if (input.operation !== 'start' && input.operation !== 'reconcile' && !lateCancelledJoin && expected === undefined)
                 continue;
             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))
+                if (currentSeat === undefined || currentSeat.attachment !== 'attached' || currentSeat.generation !== capturedSeat.generation
+                    || currentSeat.owner !== capturedSeat.owner)
                     continue;
                 const seat = asSeatRef(currentSeat);
                 const existing = currentSeat.wakeAddress?.kind === 'claude-native' ? currentSeat.wakeAddress : undefined;
@@ -193,7 +164,7 @@ export async function runClaudeMod(inputText, env = process.env) {
                     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: members.map(claudeBinding), 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(member => claudeBinding(member, input.sessionId)), cancelledBindings })}\n`;
     }
     if (!['guard', 'admitted', 'stored'].includes(input.operation) || typeof input.text !== 'string')
         throw new Error('Unknown Claude bridge operation.');