@astrosheep/square 0.3.105 → 0.4.0

package/dist/channel.d.ts

@@ -1,9 +1,18 @@
-import { type HarnessSessionChannel } from './participant-identity.js';
-import type { SquareResourceOwner, WakeTransportPort } from './ports.js';
-import type { ActivityId, ChannelSendInput, ChannelSendResult, DeliveryDeferral, HeldSeat, MetadataMatch, OperationControl, Owner, Participant, WakeAddress, PendingOptions, PendingResult, AckResult } from './square-facade.js';
+import type { WakeAddress } from './channel-values.js';
+import type { Owner, OperationControl } from './neutral.js';
+import type { HarnessSessionChannel } from './participant-identity.js';
+import type { WakeTransportPort } from './channel-transport.js';
+import type { MetadataMatch, DeliveryDeferral } from './channel-metadata.js';
+import type { MessageId } from './message.js';
+import type { AckResult, ChannelEndpointHold, ChannelEndpointSummary, ChannelHistoryQuery, ChannelHistoryResult, ChannelPendingOptions, ChannelPendingResult, ChannelReceiveResult, ChannelSendInput, ChannelSendResult } from './channel-facade.js';
 export { harnessOwner, decodeHarnessOwner, localUserOwner } from './owner.js';
-export type { ActivityDelivery, ActivityMetadata, ActivityQuery, ActivitySearch, ActivityCursor, ChannelTruncate, PerceivedActivity, PendingOptions, PendingResult, AckResult } from './square-facade.js';
-export type { ActivityId, ChannelSendInput, ChannelSendResult, DeliveryDeferral, HeldSeat, MetadataMatch, OperationControl, Owner, WakeAddress, SquareResourceOwner, WakeTransportPort, HarnessSessionChannel };
+export type { MessageMetadata, WakeAddress } from './channel-values.js';
+export type { MessageId } from './message.js';
+export type { MessageCursor, MessageQuery, MessageSearch, ChannelTruncate, ChannelSendInput, ChannelSendResult, ChannelMessage, ChannelPendingOptions, ChannelPendingResult, ChannelReceiveResult, ChannelHistoryQuery, ChannelHistoryResult, AckResult, ChannelEndpointSummary, ChannelEndpointHold } from './channel-facade.js';
+export type { MetadataMatch, DeliveryDeferral } from './channel-metadata.js';
+export type { Owner, OperationControl } from './neutral.js';
+export type { WakeTransportPort } from './channel-transport.js';
+export type { HarnessSessionChannel } from './participant-identity.js';
 export interface ResolvedHarnessSession {
     readonly channel: HarnessSessionChannel;
     readonly sessionId: string;
@@ -18,7 +27,6 @@ export interface ChannelOpenInput {
     readonly env?: NodeJS.ProcessEnv;
     readonly clock?: () => number;
     readonly wakeTransport?: WakeTransportPort | false;
-    readonly resources?: SquareResourceOwner;
 }
 export interface ChannelCreateInput extends ChannelOpenInput {
     readonly force?: boolean;
@@ -30,16 +38,16 @@ type EndpointOptions = {
 };
 type EndpointIdentity = {
     readonly owner: Owner;
-    readonly generation: ActivityId;
+    readonly generation: string;
 };
-/** A scoped direct-messaging vocabulary over the shared Square resource. */
+/** A trusted handle to one independent message channel. */
 export declare class Channel {
-    private readonly square;
+    #private;
     private constructor();
-    get location(): string;
     static open(input: ChannelOpenInput, control?: OperationControl): Promise<Channel>;
     static create(input: ChannelCreateInput, control?: OperationControl): Promise<Channel>;
-    static inMemory(input?: Omit<ChannelCreateInput, 'path' | 'resources' | 'force'>): Channel;
+    static inMemory(input?: Omit<ChannelCreateInput, 'path' | 'force'>): Channel;
+    get location(): string;
     attach(name: string, options: EndpointOptions & {
         readonly takeover?: boolean;
     }, control?: OperationControl): Promise<ChannelEndpoint>;
@@ -47,23 +55,24 @@ export declare class Channel {
     endpoint(name: string, options: {
         readonly owner: Owner;
     }): Promise<ChannelEndpoint>;
-    endpointsOf(owner: Owner): Promise<readonly HeldSeat[]>;
+    endpointsOf(owner: Owner): Promise<readonly ChannelEndpointHold[]>;
+    listEndpoints(control?: OperationControl): Promise<readonly ChannelEndpointSummary[]>;
     detach(name: string, identity: EndpointIdentity): Promise<true | null>;
+    cancelDeliveries(name: string, identity: EndpointIdentity, control?: OperationControl): Promise<boolean>;
     remove(name: string, identity: EndpointIdentity): Promise<boolean>;
-    cancelDeliveries(name: string, identity: EndpointIdentity): Promise<boolean>;
     send(input: ChannelSendInput, control?: OperationControl): Promise<ChannelSendResult>;
+    history(query?: ChannelHistoryQuery, control?: OperationControl): Promise<ChannelHistoryResult>;
     close(): Promise<void>;
 }
-/** Captures one recipient generation through its existing Participant handle. */
+/** Fenced to one attached endpoint generation. */
 export declare class ChannelEndpoint {
-    private readonly channel;
-    private readonly participant;
-    constructor(channel: Channel, participant: Participant);
+    #private;
+    private constructor();
     get name(): string;
-    get generation(): ActivityId;
-    pending(options?: PendingOptions, control?: OperationControl): Promise<PendingResult>;
-    ack(ids: readonly ActivityId[], control?: OperationControl): Promise<AckResult>;
-    leave(control?: OperationControl): Promise<void>;
+    get generation(): string;
+    pending(options?: ChannelPendingOptions, control?: OperationControl): Promise<ChannelPendingResult>;
+    ack(ids: readonly MessageId[], control?: OperationControl): Promise<AckResult>;
+    receive(options?: ChannelPendingOptions, control?: OperationControl): Promise<ChannelReceiveResult>;
     deferDelivery(input: Readonly<{
         match: MetadataMatch;
         durationMs: number;
@@ -71,4 +80,5 @@ export declare class ChannelEndpoint {
     renewDeliveryDeferral(id: string, durationMs: number, control?: OperationControl): Promise<DeliveryDeferral | null>;
     releaseDeliveryDeferral(id: string, control?: OperationControl): Promise<boolean>;
     send(input: Omit<ChannelSendInput, 'from'>, control?: OperationControl): Promise<ChannelSendResult>;
+    leave(control?: OperationControl): Promise<void>;
 }

package/dist/channel.js

@@ -1,92 +1,60 @@
-import { codexWakeAddress } from './codex-address.js';
-import { SquareError } from './model.js';
-import { harnessOwner } from './owner.js';
-import { harnessSessionSources } from './participant-identity.js';
-import { Square } from './square-api.js';
-import { squareLocation } from './square-location.js';
+import { Channel as ChannelCore, resolveHarnessSession as resolveSession } from './channel-internal.js';
 export { harnessOwner, decodeHarnessOwner, localUserOwner } from './owner.js';
 export function resolveHarnessSession(env = process.env) {
-    for (const { variable, channel } of harnessSessionSources) {
-        const sessionId = env[variable]?.trim();
-        if (!sessionId)
-            continue;
-        const agentId = channel === 'claude-code' && env.CLAUDE_CODE_CHILD_SESSION?.trim() === '1'
-            ? env.CLAUDE_CODE_AGENT_ID?.trim() || undefined : undefined;
-        const wakeAddress = channel === 'codex' ? codexWakeAddress(sessionId, env)
-            : channel === 'paseo' ? { kind: 'paseo', address: { agentId: sessionId } } : undefined;
-        return { channel, sessionId, ...(agentId === undefined ? {} : { agentId }),
-            owner: harnessOwner({ channel, session: sessionId, ...(agentId === undefined ? {} : { agent: agentId }) }),
-            ...(wakeAddress === undefined ? {} : { wakeAddress }) };
-    }
-    return undefined;
-}
-function explicitLocation(input) {
-    if (typeof input?.path !== 'string' || input.path.trim() === '')
-        throw new SquareError('invalid_args', 'Channel path is required.');
-    return squareLocation(input);
+    return resolveSession(env);
 }
-/** A scoped direct-messaging vocabulary over the shared Square resource. */
+const endpointKey = Symbol('ChannelEndpoint');
+let wrapEndpoint;
+/** A trusted handle to one independent message channel. */
 export class Channel {
-    square;
-    constructor(square) {
-        this.square = square;
-    }
-    get location() { return this.square.location; }
+    #core;
+    constructor(core) { this.#core = core; }
     static async open(input, control) {
-        const path = explicitLocation(input);
-        return new Channel(await Square.at({ ...input, path }, control));
+        return new Channel(await ChannelCore.open(input, control));
     }
     static async create(input, control) {
-        const path = explicitLocation(input);
-        return new Channel(await Square.build({ ...input, path, hardCap: null, markdown: input.description ?? '# Channel\n' }, control));
+        return new Channel(await ChannelCore.create(input, control));
     }
     static inMemory(input = {}) {
-        return new Channel(Square.inMemory({ ...input, hardCap: null, markdown: input.description ?? '# Channel\n' }));
+        return new Channel(ChannelCore.inMemory(input));
     }
+    get location() { return this.#core.location; }
     async attach(name, options, control) {
-        return new ChannelEndpoint(this, (await this.square.join(name, options, control)).participant);
+        return wrapEndpoint(await this.#core.attach(name, options, control));
     }
     async reattach(name, options, control) {
-        const participant = await this.square.reattach(name, options, control);
-        return participant === null ? null : new ChannelEndpoint(this, participant);
+        const endpoint = await this.#core.reattach(name, options, control);
+        return endpoint === null ? null : wrapEndpoint(endpoint);
     }
     async endpoint(name, options) {
-        return new ChannelEndpoint(this, await this.square.participant(name, options));
-    }
-    endpointsOf(owner) { return this.square.seatsOf(owner); }
-    detach(name, identity) { return this.square.detach(name, identity); }
-    async remove(name, identity) { return await this.square.endHeld(name, identity) !== null; }
-    cancelDeliveries(name, identity) { return this.square.cancelDeliveries(name, identity); }
-    send(input, control) { return this.square.send(input, control); }
-    close() { return this.square.close(); }
+        return wrapEndpoint(await this.#core.endpoint(name, options));
+    }
+    endpointsOf(owner) { return this.#core.endpointsOf(owner); }
+    listEndpoints(control) { return this.#core.listEndpoints(control); }
+    detach(name, identity) { return this.#core.detach(name, identity); }
+    cancelDeliveries(name, identity, control) { return this.#core.cancelDeliveries(name, identity, control); }
+    remove(name, identity) { return this.#core.remove(name, identity); }
+    send(input, control) { return this.#core.send(input, control); }
+    history(query, control) { return this.#core.history(query, control); }
+    close() { return this.#core.close(); }
 }
-/** Captures one recipient generation through its existing Participant handle. */
+/** Fenced to one attached endpoint generation. */
 export class ChannelEndpoint {
-    channel;
-    participant;
-    constructor(channel, participant) {
-        this.channel = channel;
-        this.participant = participant;
-    }
-    get name() { return this.participant.name; }
-    get generation() { return this.participant.generation; }
-    pending(options, control) {
-        return this.participant.pending(options, control);
-    }
-    ack(ids, control) {
-        return this.participant.ack(ids, control);
-    }
-    async leave(control) { await this.participant.done(undefined, {}, control); }
-    deferDelivery(input, control) {
-        return this.participant.deferDelivery(input, control);
-    }
-    renewDeliveryDeferral(id, durationMs, control) {
-        return this.participant.renewDeliveryDeferral(id, durationMs, control);
-    }
-    releaseDeliveryDeferral(id, control) {
-        return this.participant.releaseDeliveryDeferral(id, control);
-    }
-    send(input, control) {
-        return this.channel.send({ ...input, from: this.name }, control);
-    }
+    #core;
+    constructor(core, key) {
+        if (key !== endpointKey)
+            throw new TypeError('Channel endpoints are obtained from a Channel.');
+        this.#core = core;
+    }
+    static { wrapEndpoint = core => new ChannelEndpoint(core, endpointKey); }
+    get name() { return this.#core.name; }
+    get generation() { return this.#core.generation; }
+    pending(options, control) { return this.#core.pending(options, control); }
+    ack(ids, control) { return this.#core.ack(ids, control); }
+    receive(options, control) { return this.#core.receive(options, control); }
+    deferDelivery(input, control) { return this.#core.deferDelivery(input, control); }
+    renewDeliveryDeferral(id, durationMs, control) { return this.#core.renewDeliveryDeferral(id, durationMs, control); }
+    releaseDeliveryDeferral(id, control) { return this.#core.releaseDeliveryDeferral(id, control); }
+    send(input, control) { return this.#core.send(input, control); }
+    leave(control) { return this.#core.leave(control); }
 }

package/dist/claude-delivery-status.js

@@ -33,7 +33,7 @@ export async function recordClaudeDeliveryStatus(input, env = process.env) {
                 continue;
             const { seat, evidence } = match[0];
             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: {
+            return (await artifact.transactAs({ kind: 'participant', seat: ref }, (facts) => facts.channel.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,
                 } }))).value;

package/dist/claude-delivery.d.ts

@@ -1,7 +1,4 @@
-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(env?: NodeJS.ProcessEnv): WakeTransportPort;
+export { createClaudeWakeTransport, nativeTokens, nativePayload } from './claude-transport.js';
 /** Recognize the whole frame first; one inactive token vetoes it before any evidence/receipt write. */
 export declare function observeClaudeDelivery(sessionId: string, text: string, operation: 'guard' | 'admitted' | 'stored', env?: NodeJS.ProcessEnv): Promise<{
     recognized: boolean;
@@ -11,5 +8,5 @@ export type ClaudeBinding = {
     readonly location: string;
     readonly participant: string;
     readonly session: string;
-    readonly generation?: import('./square-core.js').ActivityId;
+    readonly generation?: string;
 };

package/dist/claude-delivery.js

@@ -1,87 +1,11 @@
-import { stat } from 'node:fs/promises';
-import { createHash, randomUUID } from 'node:crypto';
 import { createArtifactPort } from './artifact.js';
 import { presentPending } from './presentation-operations.js';
-import { nativePendingPreview } from './inbox.js';
-import { parseActivityId } from './square-core.js';
+import { nativePendingHead } from './delivery.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;
-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; }
-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', 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;
-}
-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', 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) {
-    return {
-        async probe(route) {
-            if (!nativeSupported(route))
-                return { outcome: 'not-capable', diagnostic: 'Claude native inbox unavailable: a loaded interactive Square mod is 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, timeoutMs, beforeSend, env),
-    };
-}
-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.' };
-    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 || 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))
-        return undefined;
-    const native = previewFacts(facts, request);
-    if (native === undefined)
-        return undefined;
-    const payload = nativePayload(request.claimToken, native.payload);
-    return evidence.correlation?.payloadHash === hashPayload(payload) ? payload : undefined;
-}
+import { parseMessageId } from './message.js';
+export { createClaudeWakeTransport, nativeTokens, nativePayload } from './claude-transport.js';
+import { nativeTokens, hashPayload } from './claude-transport.js';
 async function rowsForSession(sessionId, env, tokens) {
     const rows = [];
     const candidates = (await indexedSquareEntries({}, env)).filter(entry => {
@@ -97,16 +21,9 @@ async function rowsForSession(sessionId, env, tokens) {
                 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,
-                    ...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) }];
+                const seat = facts.seat(evidence.participant);
+                return [{ artifact, evidence, location, index: parseMessageId(evidence.message),
+                        ...(seat === undefined ? {} : { seat: { participant: evidence.participant, owner: seat.owner, generation: evidence.generation } }) }];
             }));
             rows.push(...found.value);
             if (found.value.length === 0)
@@ -118,6 +35,28 @@ async function rowsForSession(sessionId, env, tokens) {
     }
     return rows;
 }
+/** The token, participant, activity and captured generation must still be the exact wake. */
+function sameCapturedEvidence(facts, row) {
+    const token = row.evidence.claimToken;
+    const evidence = token === undefined ? undefined : facts.deliveryByToken(token);
+    return token !== undefined && evidence !== undefined && row.seat !== undefined && row.seat.participant === row.evidence.participant
+        && row.seat.generation === row.evidence.generation && evidence.kind === 'wake' && evidence.claimToken === token
+        && evidence.participant === row.evidence.participant && evidence.message === row.evidence.message
+        && evidence.generation === row.evidence.generation
+        && evidence.correlation?.harness === 'claude' && evidence.correlation.token === token
+        && evidence.correlation.payloadHash === row.evidence.correlation?.payloadHash
+        && ['dispatching', 'unknown', 'accepted'].includes(evidence.outcome);
+}
+function capturedInput(row, now) {
+    if (row.seat === undefined || row.index === undefined || row.evidence.route === undefined)
+        return undefined;
+    return { location: row.location, participant: row.evidence.participant, generation: row.seat.generation,
+        owner: row.seat.owner, index: row.index, route: row.evidence.route, now };
+}
+function currentRow(facts, row, now) {
+    const input = capturedInput(row, now);
+    return input !== undefined && sameCapturedEvidence(facts, row) && nativePendingHead(facts, input) !== undefined;
+}
 /** 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 tokens = nativeTokens(text);
@@ -127,25 +66,39 @@ export async function observeClaudeDelivery(sessionId, text, operation, env = pr
     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);
-        }))
+        // Every recognized token is vetted before any row can write: actual bytes against the
+        // stored correlation hash, then independent current eligibility.
+        const contentCurrent = rows.every(row => {
+            const token = row.evidence.claimToken, hash = row.evidence.correlation?.payloadHash;
+            if (token === undefined || hash === undefined || row.seat === undefined || row.index === undefined
+                || !['dispatching', 'unknown', 'accepted'].includes(row.evidence.outcome))
+                return false;
+            const matching = frames.filter(frame => frame[2] === token);
+            return matching.length === tokens.filter(candidate => candidate === token).length
+                && matching.every(frame => hashPayload(frame[1]) === hash);
+        });
+        if (!recognized || !contentCurrent)
             return { recognized, current: false };
+        const now = Date.now();
+        for (const row of rows) {
+            if (!(await row.artifact.read(facts => currentRow(facts, row, now))).value)
+                return { recognized, current: false };
+        }
         for (const row of rows) {
             if (operation === 'guard')
                 continue;
-            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 }));
+            const seat = row.seat;
+            const current = (facts) => currentRow(facts, row, Date.now());
+            const admitted = await row.artifact.transactAs({ kind: 'participant', seat }, facts => current(facts) && facts.channel.completeDelivery({ seat, message: row.evidence.message,
+                claimToken: row.evidence.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,
-                    // Claude's stored event consumes even Agora previews; retain that contract for both modes.
-                    participant: request.participant, activity: request.activity, seat: request.seat, observationOf: request.claimToken, markSeen: true, sink: { present() { } },
-                    current: facts => currentPayload(facts, request) === payload });
+            if (operation === 'stored') {
+                await presentPending({ artifact: row.artifact, location: row.location,
+                    // Persisted coverage decides consumption; the current renderer never guesses.
+                    participant: row.evidence.participant, message: row.evidence.message, seat, observationOf: row.evidence.claimToken,
+                    markSeen: row.evidence.coverage !== 'clipped', sink: { present() { } }, current });
+            }
         }
         return { recognized, current: true };
     }

package/dist/claude-mod.js

@@ -1,5 +1,5 @@
 import { operationEnv } from './participant-identity.js';
-import { createArtifactPort } from './artifact.js';
+import { channelArtifact, createArtifactPort } from './artifact.js';
 import { recordClaudeDeliveryStatus } from './claude-delivery-status.js';
 import { Square } from './square-api.js';
 import { observeClaudeDelivery } from './claude-delivery.js';
@@ -104,9 +104,9 @@ export async function runClaudeMod(inputText, env = process.env) {
                         let beforeIndex;
                         for (;;) {
                             const page = facts.activityHeads({ beforeIndex }, { edge: 'newest', limit: 100 });
-                            const last = [...page.items].reverse().find((activity) => activity.at <= cutoff);
+                            const last = page.items.find((activity) => activity.at <= cutoff && activity.messageIndex !== undefined);
                             if (last !== undefined)
-                                return last.index;
+                                return last.messageIndex;
                             if (!page.hasMore)
                                 return -1;
                             beforeIndex = page.items[0].index;
@@ -148,7 +148,7 @@ export async function runClaudeMod(inputText, env = process.env) {
                 const artifact = createArtifactPort(location, undefined, signal);
                 let indices;
                 try {
-                    indices = await sweepPending({ artifact, location, now: Date.now(), graceMs: 0, limit: 8 });
+                    indices = await sweepPending({ artifact: channelArtifact(artifact), location, now: Date.now(), graceMs: 0, limit: 8 });
                 }
                 catch (error) {
                     if (error instanceof InternalSquareError && error.code === 'not_found')

package/dist/claude-transport.d.ts

@@ -0,0 +1,5 @@
+import type { WakeTransportPort } from './channel-transport.js';
+export declare function nativeTokens(text: string): string[];
+export declare function nativePayload(token: string, preview: string): string;
+export declare function hashPayload(payload: string): string;
+export declare function createClaudeWakeTransport(env?: NodeJS.ProcessEnv): WakeTransportPort;

package/dist/claude-transport.js

@@ -0,0 +1,58 @@
+import { stat } from 'node:fs/promises';
+import { createHash, randomUUID } from 'node:crypto';
+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; }
+export function hashPayload(payload) { return createHash('sha256').update(payload).digest('hex'); }
+async function preview(request) {
+    return request.presentation;
+}
+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', 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) {
+    return {
+        async probe(route) {
+            if (!nativeSupported(route))
+                return { outcome: 'not-capable', diagnostic: 'Claude native inbox unavailable: a loaded interactive Square mod is 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, timeoutMs, beforeSend, env),
+    };
+}
+async function dispatchClaude(request, timeoutMs, beforeSend, env = process.env) {
+    void env;
+    const signal = AbortSignal.timeout(timeoutMs);
+    if (!nativeSupported(request.route) || 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);
+    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.channel.prepare({ correlation, coverage: prepared.coverage,
+        ...(prepared.description === undefined ? {} : { description: prepared.description }) }))
+        return { outcome: 'not-capable', diagnostic: 'Claude delivery claim is no longer current.' };
+    const fresh = await preview(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.' };
+    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);
+}

package/dist/cli/context.d.ts

@@ -1,5 +1,5 @@
 import { type Owner } from '../square-api.js';
-import { type HardCap } from '../model.js';
+import { type HardCap, type WakeAddress } from '../model.js';
 import { Square } from '../square-api.js';
 import type { OperationControl } from '../square-facade.js';
 export interface CommandContext {
@@ -46,7 +46,7 @@ export declare function squareInput(context: CommandContext): {
 };
 export declare function commandIdentity(env: NodeJS.ProcessEnv, explicit?: Owner): {
     owner: Owner;
-    wakeAddress?: import('../model.js').WakeAddress;
+    wakeAddress?: WakeAddress;
 };
 /** Adapter lifetime only; each callback uses the actual public resource API. */
 export declare function withSquare<T>(context: CommandContext, run: (square: Square) => Promise<T>, control?: OperationControl): Promise<T>;

package/dist/cli/context.js

@@ -103,7 +103,6 @@ const LOCATION_REQUIRED_COMMANDS = new Set([
     'status',
     'participants',
     'doctor',
-    'migrate',
 ]);
 export async function parseGlobalArgs(rawArgs) {
     const args = [...rawArgs];

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

@@ -3,9 +3,5 @@ interface DoctorResult {
     output: string;
     exitCode?: number;
 }
-interface MigrateResult {
-    output: string;
-}
-export declare const migrateCommand: CommandSpec<undefined, MigrateResult>;
 export declare const doctorCommand: CommandSpec<undefined, DoctorResult>;
 export {};

package/dist/cli/maintenance-commands.js

@@ -1,30 +1,6 @@
-import { diagnoseSquare, migrateSquare } from '../square-api.js';
-import { commandPrefix, renderDoctorClean, renderDoctorUnfixable, withPathOutput } from '../presentation.js';
+import { diagnoseSquare } from '../square-api.js';
+import { renderDoctorClean, renderDoctorUnfixable, withPathOutput } from '../presentation.js';
 import { requireSquarePath, squareInput, usage } from './context.js';
-export const migrateCommand = {
-    parse(argv, context) {
-        if (argv.length > 0)
-            usage(context.command);
-        return undefined;
-    },
-    async execute(_intent, context) {
-        const squarePath = requireSquarePath(context);
-        const outcome = await migrateSquare(squareInput(context));
-        const body = outcome.status === 'migrated'
-            ? [
-                '✓ migrated to current row storage',
-                ...(outcome.counts === undefined ? [] : [
-                    `  · ${outcome.counts.activities} activities · ${outcome.counts.receipts} receipts · ${outcome.counts.leases} leases · ${outcome.counts.routes} routes`,
-                    `  · ${outcome.counts.recoveredSeats} recovered seats · ${outcome.counts.unownedStanding} unowned standing · ${outcome.counts.sharedBodySeats} shared-body seats · ${outcome.counts.skippedEvidence} skipped evidence`,
-                ]),
-            ].join('\n')
-            : '· already current format — nothing changed';
-        return { output: withPathOutput(squarePath, body, { participantCount: outcome.standing }) };
-    },
-    present(result) {
-        process.stdout.write(result.output);
-    },
-};
 export const doctorCommand = {
     parse(argv, context) {
         if (argv.length > 0)
@@ -34,9 +10,6 @@ export const doctorCommand = {
     async execute(_intent, context) {
         const squarePath = requireSquarePath(context);
         const diagnosis = await diagnoseSquare(squareInput(context));
-        if (diagnosis.migrationRequired !== undefined) {
-            return { output: withPathOutput(squarePath, `${diagnosis.migrationRequired}\n${commandPrefix(squarePath)} migrate\n`), exitCode: 2 };
-        }
         if (diagnosis.unfixable !== undefined || diagnosis.standingCount === undefined) {
             return {
                 output: withPathOutput(squarePath, renderDoctorUnfixable(diagnosis.unfixable ?? 'the artifact could not be decoded')),