@astrosheep/square 0.3.105 → 0.4.0

package/dist/message.js

@@ -0,0 +1,23 @@
+// Message coordinates belong to Channel alone; Agora activity ids are a separate coordinate.
+import crypto from 'node:crypto';
+export function formatMessageId(index) {
+    if (!Number.isSafeInteger(index) || index < 0)
+        throw new Error(`Invalid message index: ${index}`);
+    return `msg/${index}`;
+}
+export function parseMessageId(value) {
+    if (value === 'msg/0')
+        return 0;
+    if (typeof value !== 'string' || !/^msg\/[1-9]\d*$/.test(value))
+        return undefined;
+    const index = Number(value.slice(4));
+    return Number.isSafeInteger(index) ? index : undefined;
+}
+export function newEndpointGeneration() {
+    return `endpoint/${crypto.randomUUID()}`;
+}
+export function validateEndpointGeneration(value) {
+    if (typeof value !== 'string' || value.length === 0 || value.length > 512 || /[\u0000-\u001f\u007f-\u009f]/u.test(value))
+        throw new TypeError('Endpoint generation must be a non-empty opaque token without control characters.');
+    return value;
+}

package/dist/model.d.ts

@@ -1,33 +1,17 @@
 import type { Act, ActivityId } from './square-core.js';
-export { formatActivityId, parseActivityId } from './square-core.js';
+import type { EndpointGeneration } from './message.js';
+import type { Owner } from './neutral.js';
+import type { MessageMetadata as ActivityMetadata, WakeAddress } from './channel-values.js';
+export { WAKE_ROUTE_KINDS, MESSAGE_METADATA_MAX_BYTES as ACTIVITY_METADATA_MAX_BYTES, MESSAGE_METADATA_MAX_DEPTH as ACTIVITY_METADATA_MAX_DEPTH, validateMessageMetadata as validateActivityMetadata, messageMetadataHasContent as activityMetadataHasContent, isWakeRouteKind, sameName, NAME_GRAPHEME_SOURCE, validateName } from './channel-values.js';
+export type { WakeRouteKind, JsonValue, MessageMetadata as ActivityMetadata, WakeAddress, WakeRoute } from './channel-values.js';
+export { SquareErrorBase, SquareError, InternalSquareError, isSquareError, validateOwner, nameKey } from './neutral.js';
+export type { Owner, SquareErrorCode, InternalSquareErrorCode, SquareErrorFacts } from './neutral.js';
 export type { Act, ActivityId, Audience, Reach } from './square-core.js';
-export declare const WAKE_ROUTE_KINDS: readonly ["opencode-server", "codex-queue", "claude-native", "paseo", "http"];
-export type WakeRouteKind = typeof WAKE_ROUTE_KINDS[number];
-export type JsonValue = null | boolean | number | string | readonly JsonValue[] | {
-    readonly [key: string]: JsonValue;
-};
-export type ActivityMetadata = Readonly<Record<string, JsonValue>>;
-export interface ActivityDelivery {
-    readonly mode: 'direct';
-    readonly preview?: string;
-}
-export declare function validateActivityDelivery(value: unknown): ActivityDelivery | undefined;
-export declare const ACTIVITY_METADATA_MAX_BYTES: number;
-export declare const ACTIVITY_METADATA_MAX_DEPTH = 256;
-/** Validate the bounded, lossless JSON object carried by a say. */
-export declare function validateActivityMetadata(value: unknown): ActivityMetadata | undefined;
-export declare function activityMetadataHasContent(metadata: ActivityMetadata | undefined): boolean;
-/** Opaque custody identity. Harness coordinates are adapter-owned. */
-export type Owner = string;
-export interface WakeAddress {
-    readonly kind: WakeRouteKind;
-    readonly address: Readonly<Record<string, string>>;
-}
 /** Artifact-owned custody binding. Generation is the join activity that established it. */
 export interface Seat {
     readonly participant: string;
     readonly owner: Owner;
-    readonly generation: ActivityId;
+    readonly generation: EndpointGeneration;
     readonly attachment: 'attached' | 'detached';
     readonly wakeAddress?: WakeAddress;
 }
@@ -35,48 +19,6 @@ export interface SeatWatchLease {
     readonly generation: ActivityId;
     readonly lease: WatchLease;
 }
-export declare function validateOwner(owner: Owner): Owner;
-export declare function isWakeRouteKind(value: unknown): value is WakeRouteKind;
-export interface WakeRoute {
-    /** Ownership generation, when the receiver publishes a fenced route. */
-    epoch?: number;
-    location: string;
-    participant: string;
-    kind: WakeRouteKind;
-    address: Record<string, string>;
-    updatedAt: number;
-}
-export type SquareErrorCode = 'invalid_name' | 'invalid_args' | 'unknown_participant' | 'not_joined' | 'already_joined' | 'already_done' | 'capped' | 'throttled' | 'bell_quota' | 'behind' | 'io' | 'unavailable';
-export type InternalSquareErrorCode = SquareErrorCode | 'not_found' | 'cap_reached' | 'conflict' | 'pending_peer';
-export interface SquareErrorFacts {
-    /** Copyable recovery for a missing, detached or foreign seat. */
-    join?: string;
-    /** Express admission rejected before any activity was committed. */
-    activityUnsent?: true;
-    /** Refusal reason, including absent participants, conflicting reach, and inaccessible activities. */
-    reason?: 'never_joined' | 'not_standing' | 'bell_mention_conflict' | 'not_addressed' | 'migration_required' | 'invalid_reply' | 'invalid_done_body' | 'needs_seat';
-    /** The activity id a `catch --id` refusal named. */
-    activityId?: string;
-    /** The host ledger requiring offline migration, rather than the selected artifact. */
-    ledgerRoot?: string;
-    /** Requested recipient spellings, without parsing presentation copy. */
-    targets?: readonly string[];
-    /** Whether the artifact holds that activity at all; an unknown id needs an ordinary page. */
-    activityExists?: boolean;
-    pending?: number;
-    retryAfterMs?: number;
-}
-declare class SquareErrorBase<Code extends string> extends Error {
-    code: Code;
-    facts?: SquareErrorFacts | undefined;
-    operation?: import('./square-facade.js').OperationFailureDetail;
-    constructor(code: Code, message: string, facts?: SquareErrorFacts | undefined);
-}
-export declare class SquareError extends SquareErrorBase<SquareErrorCode> {
-}
-export declare class InternalSquareError extends SquareErrorBase<InternalSquareErrorCode> {
-}
-export declare function isSquareError(error: unknown): error is SquareError | InternalSquareError;
 export type HardCap = number | null;
 export interface BuildOptions {
     force: boolean;
@@ -84,9 +26,29 @@ export interface BuildOptions {
     template?: string;
     throttlePerMinute?: number;
 }
-export type StoredAct = Act & {
+/** An upper publication draft: content and social facts before any index exists. */
+export type ActDraft = Act & {
+    at: number;
+};
+/** Persisted say: identity and social facts only. Its content lives in the linked Channel message. */
+export type SayRelation = Omit<Extract<Act, {
+    kind: 'say';
+}>, 'body' | 'metadata'> & {
     index: number;
     at: number;
+    messageIndex: number;
+};
+/** A landed upper activity. A say is a relation; it carries no content of its own. */
+export type StoredAct = Extract<Act, {
+    kind: 'join' | 'done' | 'read' | 'listen' | 'ignore' | 'unlisten';
+}> & {
+    index: number;
+    at: number;
+} | SayRelation;
+/** Explicit upper projection: a stored say resolved against its authoritative message. */
+export type HydratedAct = Exclude<StoredAct, SayRelation> | SayRelation & {
+    body?: string;
+    metadata?: ActivityMetadata;
 };
 export type ObservationState = 'seen';
 export interface ActivityObservation {
@@ -105,13 +67,20 @@ export interface WatchLease {
 }
 export type DirectedNotificationRoute = import('./attention.js').AudienceRoute;
 export interface InboxNotification {
-    actIndex: number;
+    /** Lower message coordinate. */
+    messageIndex: number;
+    /** Upper Agora activity sharing this message, when one exists. */
+    actIndex?: number;
     actor: string;
     at: number;
-    route: DirectedNotificationRoute;
+    route?: DirectedNotificationRoute;
     body: string;
-    readonly delivery?: ActivityDelivery;
+    readonly preview?: string;
+    readonly description?: string;
+    readonly coverage?: 'full' | 'clipped';
 }
+/** The one stored-content-to-notification field mapping used by inbox and native previews. */
+export declare function notificationFacts(item: HydratedAct, route: DirectedNotificationRoute): InboxNotification;
 export interface LocatedSeat {
     readonly location: string;
     readonly seat: Seat;
@@ -127,16 +96,11 @@ export interface WatchOptions {
     mention?: string;
     replace?: boolean;
 }
-export type PublicAct = Extract<StoredAct, {
+export type PublicAct = Extract<HydratedAct, {
     kind: 'say' | 'done';
 }>;
-export type RoomChangeAct = Extract<StoredAct, {
+export type RoomChangeAct = Extract<HydratedAct, {
     kind: 'join' | 'done' | 'listen' | 'ignore' | 'unlisten';
 }>;
 export declare function formatHardCap(hardCap: HardCap): string;
 export declare function parseParticipantList(value: string): string[];
-export declare function nameKey(name: string): string;
-export declare function sameName(a: string, b: string): boolean;
-/** One name grapheme: Unicode letters, digits, marks, hyphens, or underscores (no isolated variation selectors), or a complete RGI emoji. Shared by name validation and body @mention scanning. */
-export declare const NAME_GRAPHEME_SOURCE: string;
-export declare function validateName(name: string): void;

package/dist/model.js

@@ -1,126 +1,11 @@
 // Shared model and constants for Square.
-export { formatActivityId, parseActivityId } from './square-core.js';
-export const WAKE_ROUTE_KINDS = ['opencode-server', 'codex-queue', 'claude-native', 'paseo', 'http'];
-export function validateActivityDelivery(value) {
-    if (value === undefined)
-        return undefined;
-    if (value !== null && typeof value === 'object'
-        && [Object.prototype, null].includes(Object.getPrototypeOf(value))
-        && Object.getOwnPropertySymbols(value).length === 0) {
-        const keys = Object.getOwnPropertyNames(value);
-        const mode = Object.getOwnPropertyDescriptor(value, 'mode');
-        const preview = Object.getOwnPropertyDescriptor(value, 'preview');
-        if (mode?.enumerable && 'value' in mode && mode.value === 'direct') {
-            if (keys.length === 1)
-                return { mode: 'direct' };
-            if (keys.length === 2 && preview?.enumerable && 'value' in preview
-                && typeof preview.value === 'string' && preview.value.trim() !== '')
-                return { mode: 'direct', preview: preview.value };
-        }
-    }
-    throw new SquareError('invalid_args', "Activity delivery must be { mode: 'direct', preview?: string }.");
-}
-export const ACTIVITY_METADATA_MAX_BYTES = 16 * 1024;
-export const ACTIVITY_METADATA_MAX_DEPTH = 256;
-/** Validate the bounded, lossless JSON object carried by a say. */
-export function validateActivityMetadata(value) {
-    if (value === undefined)
-        return undefined;
-    if (value === null || typeof value !== 'object' || Array.isArray(value))
-        throw new SquareError('invalid_args', 'Activity metadata must be a non-null JSON object.');
-    const visiting = new Set();
-    const stack = [{ value, depth: 0 }];
-    while (stack.length > 0) {
-        const frame = stack.pop();
-        if (frame.exit !== undefined) {
-            visiting.delete(frame.exit);
-            continue;
-        }
-        const item = frame.value;
-        if (item === null || typeof item === 'boolean' || typeof item === 'string')
-            continue;
-        if (typeof item === 'number') {
-            if (!Number.isFinite(item))
-                throw new SquareError('invalid_args', 'Activity metadata must contain only finite JSON values.');
-            continue;
-        }
-        if (typeof item !== 'object')
-            throw new SquareError('invalid_args', 'Activity metadata must contain only JSON values.');
-        if (frame.depth > ACTIVITY_METADATA_MAX_DEPTH)
-            throw new SquareError('invalid_args', `Activity metadata nesting cannot exceed ${ACTIVITY_METADATA_MAX_DEPTH} levels.`);
-        if (visiting.has(item))
-            throw new SquareError('invalid_args', 'Activity metadata cannot contain a cycle.');
-        visiting.add(item);
-        stack.push({ value: item, depth: frame.depth, exit: item });
-        if (Array.isArray(item)) {
-            if (Object.getOwnPropertySymbols(item).length > 0 || Object.keys(item).length !== item.length)
-                throw new SquareError('invalid_args', 'Activity metadata arrays must be dense JSON arrays.');
-            const names = Object.getOwnPropertyNames(item);
-            if (names.some(name => name !== 'length' && (!/^(0|[1-9]\d*)$/.test(name) || Number(name) >= item.length)))
-                throw new SquareError('invalid_args', 'Activity metadata arrays must contain only indexed values.');
-            for (const key of Object.keys(item).reverse()) {
-                const descriptor = Object.getOwnPropertyDescriptor(item, key);
-                if (descriptor === undefined || !('value' in descriptor))
-                    throw new SquareError('invalid_args', 'Activity metadata cannot contain accessors.');
-                stack.push({ value: descriptor.value, depth: frame.depth + 1 });
-            }
-            continue;
-        }
-        const prototype = Object.getPrototypeOf(item);
-        if (prototype !== Object.prototype && prototype !== null)
-            throw new SquareError('invalid_args', 'Activity metadata must contain only plain JSON objects.');
-        if (Object.getOwnPropertySymbols(item).length > 0)
-            throw new SquareError('invalid_args', 'Activity metadata cannot contain symbol keys.');
-        const names = Object.getOwnPropertyNames(item);
-        if (names.some(name => !Object.prototype.propertyIsEnumerable.call(item, name)))
-            throw new SquareError('invalid_args', 'Activity metadata cannot contain non-enumerable properties.');
-        for (const name of names.reverse()) {
-            const descriptor = Object.getOwnPropertyDescriptor(item, name);
-            if (!('value' in descriptor))
-                throw new SquareError('invalid_args', 'Activity metadata cannot contain accessors.');
-            stack.push({ value: descriptor.value, depth: frame.depth + 1 });
-        }
-    }
-    let serialized;
-    try {
-        serialized = JSON.stringify(value);
-    }
-    catch {
-        throw new SquareError('invalid_args', 'Activity metadata must contain only lossless JSON values.');
-    }
-    if (serialized === undefined || Buffer.byteLength(serialized, 'utf8') > ACTIVITY_METADATA_MAX_BYTES)
-        throw new SquareError('invalid_args', `Activity metadata cannot exceed ${ACTIVITY_METADATA_MAX_BYTES} UTF-8 bytes.`);
-    return value;
-}
-export function activityMetadataHasContent(metadata) {
-    return metadata !== undefined && Object.keys(metadata).length > 0;
-}
-export function validateOwner(owner) {
-    if (typeof owner !== 'string' || !owner || Buffer.byteLength(owner, 'utf8') > 512 || /[\u0000-\u001f\u007f-\u009f]/u.test(owner)) {
-        throw new SquareError('invalid_args', 'A participant write requires a non-empty owner without control characters (at most 512 UTF-8 bytes).');
-    }
-    return owner;
-}
-export function isWakeRouteKind(value) {
-    return typeof value === 'string' && WAKE_ROUTE_KINDS.includes(value);
-}
-class SquareErrorBase extends Error {
-    code;
-    facts;
-    operation;
-    constructor(code, message, facts) {
-        super(message);
-        this.code = code;
-        this.facts = facts;
-        this.name = 'SquareError';
-    }
-}
-export class SquareError extends SquareErrorBase {
-}
-export class InternalSquareError extends SquareErrorBase {
-}
-export function isSquareError(error) {
-    return error instanceof SquareError || error instanceof InternalSquareError;
+export { WAKE_ROUTE_KINDS, MESSAGE_METADATA_MAX_BYTES as ACTIVITY_METADATA_MAX_BYTES, MESSAGE_METADATA_MAX_DEPTH as ACTIVITY_METADATA_MAX_DEPTH, validateMessageMetadata as validateActivityMetadata, messageMetadataHasContent as activityMetadataHasContent, isWakeRouteKind, sameName, NAME_GRAPHEME_SOURCE, validateName } from './channel-values.js';
+export { SquareErrorBase, SquareError, InternalSquareError, isSquareError, validateOwner, nameKey } from './neutral.js';
+/** The one stored-content-to-notification field mapping used by inbox and native previews. */
+export function notificationFacts(item, route) {
+    if (item.kind !== 'say' || item.messageIndex === undefined)
+        throw new Error(`Activity ${item.index} is not conversation content.`);
+    return { messageIndex: item.messageIndex, actIndex: item.index, actor: item.actor, at: item.at, route, body: item.body ?? '(structured activity)' };
 }
 export function formatHardCap(hardCap) {
     return hardCap === null ? '-1' : String(hardCap);
@@ -131,20 +16,3 @@ export function parseParticipantList(value) {
         .map((name) => name.trim())
         .filter(Boolean);
 }
-export function nameKey(name) {
-    return name.toLocaleLowerCase();
-}
-export function sameName(a, b) {
-    return nameKey(a) === nameKey(b);
-}
-const TEXT_NAME_GRAPHEME_SOURCE = String.raw `[[\p{L}\p{N}\p{M}_\x2D]--[\p{Variation_Selector}]]`;
-/** One name grapheme: Unicode letters, digits, marks, hyphens, or underscores (no isolated variation selectors), or a complete RGI emoji. Shared by name validation and body @mention scanning. */
-export const NAME_GRAPHEME_SOURCE = String.raw `${TEXT_NAME_GRAPHEME_SOURCE}|\p{RGI_Emoji}`;
-// Ordinary Unicode names need not trigger the full RGI emoji matcher’s cold compilation.
-const TEXT_NAME_PATTERN = new RegExp(`^(?:${TEXT_NAME_GRAPHEME_SOURCE})+(?:/(?:${TEXT_NAME_GRAPHEME_SOURCE})+)*$`, 'v');
-const NAME_PATTERN = new RegExp(`^(?:${NAME_GRAPHEME_SOURCE})+(?:/(?:${NAME_GRAPHEME_SOURCE})+)*$`, 'v');
-export function validateName(name) {
-    if (!name || (!TEXT_NAME_PATTERN.test(name) && !NAME_PATTERN.test(name))) {
-        throw new SquareError('invalid_name', 'Invalid name: names must contain non-empty slash-separated segments using Unicode letters, digits, marks, hyphens, underscores, or complete RGI emoji graphemes.');
-    }
-}

package/dist/neutral.d.ts

@@ -0,0 +1,72 @@
+/** Shared identity, error and paging types used below both Channel and Agora. */
+export type Owner = string;
+export type SquareErrorCode = 'invalid_name' | 'invalid_args' | 'unknown_participant' | 'not_joined' | 'already_joined' | 'already_done' | 'capped' | 'throttled' | 'bell_quota' | 'behind' | 'io' | 'unavailable';
+export type InternalSquareErrorCode = SquareErrorCode | 'not_found' | 'cap_reached' | 'conflict' | 'pending_peer';
+export interface SquareErrorFacts {
+    /** Copyable recovery for a missing, detached or foreign seat. */
+    join?: string;
+    /** Express admission rejected before any activity was committed. */
+    activityUnsent?: true;
+    /** Refusal reason, including absent participants, conflicting reach, and inaccessible activities. */
+    reason?: 'never_joined' | 'not_standing' | 'bell_mention_conflict' | 'not_addressed' | 'invalid_reply' | 'invalid_done_body' | 'needs_seat';
+    /** The activity id a `catch --id` refusal named. */
+    activityId?: string;
+    /** Requested recipient spellings, without parsing presentation copy. */
+    targets?: readonly string[];
+    /** Whether the artifact holds that activity at all; an unknown id needs an ordinary page. */
+    activityExists?: boolean;
+    pending?: number;
+    retryAfterMs?: number;
+}
+export interface CatchWaitStart {
+    readonly idleMs: number;
+    readonly replacementRequested: boolean;
+    readonly replaced: boolean;
+}
+export type OperationProgress = {
+    readonly kind: 'waiting';
+    readonly reason: 'throttled';
+    readonly delayMs?: number;
+} | ({
+    readonly kind: 'catch-started';
+    readonly participant: string;
+} & CatchWaitStart);
+export interface OperationControl {
+    readonly signal?: AbortSignal;
+    readonly onProgress?: (progress: OperationProgress) => void;
+}
+export interface OperationFailureDetail {
+    readonly operation: 'express' | 'join' | 'catch' | 'history' | 'other';
+    readonly subject?: 'caller' | 'filter' | 'recipient';
+    readonly participant?: string;
+    readonly expressEffect?: 'unsent' | 'landed' | 'unknown';
+    readonly landedId?: string;
+    readonly historyBounds?: {
+        readonly maxLimit: number;
+        readonly totalMatches: number;
+    };
+}
+export interface OperationError extends Error {
+    readonly operation?: OperationFailureDetail;
+}
+export declare class SquareErrorBase<Code extends string> extends Error {
+    code: Code;
+    facts?: SquareErrorFacts | undefined;
+    operation?: OperationFailureDetail;
+    constructor(code: Code, message: string, facts?: SquareErrorFacts | undefined);
+}
+export declare class SquareError extends SquareErrorBase<SquareErrorCode> {
+}
+export declare class InternalSquareError extends SquareErrorBase<InternalSquareErrorCode> {
+}
+export declare function isSquareError(error: unknown): error is SquareError | InternalSquareError;
+export declare function validateOwner(owner: Owner): Owner;
+export declare function nameKey(name: string): string;
+export interface IndexPage {
+    readonly edge: 'oldest' | 'newest';
+    readonly limit: number;
+}
+export interface FactPage<T> {
+    readonly items: readonly T[];
+    readonly hasMore: boolean;
+}

package/dist/neutral.js

@@ -0,0 +1,27 @@
+export class SquareErrorBase extends Error {
+    code;
+    facts;
+    operation;
+    constructor(code, message, facts) {
+        super(message);
+        this.code = code;
+        this.facts = facts;
+        this.name = 'SquareError';
+    }
+}
+export class SquareError extends SquareErrorBase {
+}
+export class InternalSquareError extends SquareErrorBase {
+}
+export function isSquareError(error) {
+    return error instanceof SquareError || error instanceof InternalSquareError;
+}
+export function validateOwner(owner) {
+    if (typeof owner !== 'string' || !owner || Buffer.byteLength(owner, 'utf8') > 512 || /[\u0000-\u001f\u007f-\u009f]/u.test(owner)) {
+        throw new SquareError('invalid_args', 'A participant write requires a non-empty owner without control characters (at most 512 UTF-8 bytes).');
+    }
+    return owner;
+}
+export function nameKey(name) {
+    return name.toLocaleLowerCase();
+}

package/dist/notifications.d.ts

@@ -1,17 +1,12 @@
-import { type WakeRouteKind } from './model.js';
-import type { WakeTransportPort } from './ports.js';
+import { type WakeTransports } from './wake-transports.js';
+export { createDefaultWakeTransport, createWakeTransport, type WakeTransports } from './wake-transports.js';
 export declare const PRIVILEGED_HOOK_BUDGET_MS = 3000;
 export declare function wakeGraceMs(env?: NodeJS.ProcessEnv): number;
-export type WakeTransports = Readonly<Partial<Record<WakeRouteKind, WakeTransportPort>>>;
 interface ProcessNotificationOptions {
     transports?: WakeTransports;
     env?: NodeJS.ProcessEnv;
     now?: () => number;
 }
-/** Concrete transports use wall time; semantic state time belongs to Square operations. */
-export declare function createDefaultWakeTransport(env?: NodeJS.ProcessEnv, suppliedTransports?: WakeTransports): Promise<WakeTransportPort>;
-/** Route selection only: all implementations receive the same request and final gate. */
-export declare function createWakeTransport(transports: WakeTransports): WakeTransportPort;
 export declare function processActNotificationsOnce(squarePath: string, actIndex: number, opts?: ProcessNotificationOptions): Promise<void>;
 /** Privileged hook fallback: sweep indexed squares plus the current cwd's local squares within one boundary budget. */
 export declare function sweepPrivilegedPending(cwd: string, env?: NodeJS.ProcessEnv, suppliedTransports?: WakeTransports, deadline?: number, signal?: AbortSignal): Promise<void>;
@@ -23,4 +18,3 @@ export interface SweepPendingNotificationsOptions {
 }
 /** Select old pending attention at a bounded action boundary for an explicit executor. */
 export declare function sweepPendingNotifications(squarePath: string, opts?: SweepPendingNotificationsOptions): Promise<number[]>;
-export {};

package/dist/notifications.js

@@ -1,10 +1,14 @@
+import { createDefaultWakeTransport } from './wake-transports.js';
+export { createDefaultWakeTransport, createWakeTransport } from './wake-transports.js';
+import { squareWakeProjection } from './wake-preview.js';
 import path from 'node:path';
 import { canonicalPath } from './canonical-path.js';
 import fs from 'node:fs';
 import { indexedSquareEntries } from './square-index.js';
 import { InternalSquareError, SquareError } from './model.js';
-import { createArtifactPort } from './artifact.js';
+import { channelArtifact, createArtifactPort } from './artifact.js';
 import { deliverPending, sweepPending } from './delivery-operations.js';
+import { formatMessageId } from './message.js';
 export const PRIVILEGED_HOOK_BUDGET_MS = 3000;
 export function wakeGraceMs(env = process.env) {
     const value = Number.parseInt(env.SQUARE_NOTIFY_DELIVERY_WAIT_MS ?? '5000', 10);
@@ -13,48 +17,6 @@ export function wakeGraceMs(env = process.env) {
     }
     return value;
 }
-/** Concrete transports use wall time; semantic state time belongs to Square operations. */
-export async function createDefaultWakeTransport(env = process.env, suppliedTransports) {
-    if (suppliedTransports !== undefined)
-        return createWakeTransport(suppliedTransports);
-    const transports = {};
-    try {
-        const { CodexQueueTransport } = await import('./codex-queue.js');
-        transports['codex-queue'] = new CodexQueueTransport({ env });
-    }
-    catch { /* core-only builds may omit Codex */ }
-    if (env.SQUARE_DISABLE_PASEO_WAKE !== '1') {
-        try {
-            const { PaseoWakeTransport } = await import('./paseo-delivery.js');
-            transports.paseo = new PaseoWakeTransport();
-        }
-        catch { /* Paseo is optional */ }
-    }
-    const { createClaudeWakeTransport } = await import('./claude-delivery.js');
-    transports['claude-native'] = createClaudeWakeTransport(env);
-    const { HttpWakeTransport } = await import('./http-delivery.js');
-    transports.http = new HttpWakeTransport({ env });
-    return createWakeTransport(transports);
-}
-/** Route selection only: all implementations receive the same request and final gate. */
-export function createWakeTransport(transports) {
-    const missing = (kind) => ({ outcome: 'not-capable', diagnostic: `no transport for ${kind}` });
-    return {
-        async probe(route) {
-            const transport = transports[route.kind];
-            if (transport === undefined)
-                return missing(route.kind);
-            try {
-                return await transport.probe?.(route) ?? true;
-            }
-            catch (error) {
-                return { outcome: 'not-capable', diagnostic: error instanceof Error ? error.message : String(error) };
-            }
-        },
-        attempt: (request, timeoutMs, beforeSend) => transports[request.route.kind]?.attempt(request, timeoutMs, beforeSend)
-            ?? Promise.resolve(missing(request.route.kind)),
-    };
-}
 export async function processActNotificationsOnce(squarePath, actIndex, opts = {}) {
     const env = opts.env ?? process.env;
     const now = opts.now ?? Date.now;
@@ -64,7 +26,10 @@ export async function processActNotificationsOnce(squarePath, actIndex, opts = {
         await artifact.read(facts => facts.header());
         const transport = await createDefaultWakeTransport(env, opts.transports);
         try {
-            await deliverPending({ artifact, transport, location: squarePath, activity: actIndex, timeoutMs: Number(env.SQUARE_NOTIFY_DELIVERY_WAIT_MS ?? 5000), now: now() });
+            const message = (await artifact.read(facts => { const activity = facts.activity(actIndex); return activity?.kind === 'say' ? activity.messageIndex : undefined; })).value;
+            if (message === undefined)
+                return;
+            await deliverPending({ artifact: channelArtifact(artifact), preparePresentation: squareWakeProjection(artifact), transport, location: squarePath, message: formatMessageId(message), timeoutMs: Number(env.SQUARE_NOTIFY_DELIVERY_WAIT_MS ?? 5000), now: now() });
         }
         catch { /* Delivery failure does not undo the activity. */ }
     }
@@ -106,14 +71,14 @@ export async function sweepPrivilegedPending(cwd, env = process.env, suppliedTra
                     break;
                 const limit = Number.parseInt(env.SQUARE_NOTIFY_SWEEP_LIMIT ?? '8', 10);
                 const graceMs = 0;
-                const selected = await sweepPending({ artifact, location: squarePath, now: Date.now(), graceMs, limit: Number.isFinite(limit) && limit > 0 ? limit : 8 }).catch(() => []);
-                for (const actIndex of selected) {
+                const selected = await sweepPending({ artifact: channelArtifact(artifact), location: squarePath, now: Date.now(), graceMs, limit: Number.isFinite(limit) && limit > 0 ? limit : 8 }).catch(() => []);
+                for (const messageIndex of selected) {
                     const remaining = remainingMs();
                     if (remaining === 0 || signal?.aborted)
                         break;
                     const configured = Number(env.SQUARE_NOTIFY_DELIVERY_WAIT_MS ?? 5000);
                     const timeoutMs = Math.max(1, Math.min(Number.isFinite(configured) && configured > 0 ? configured : 5000, remaining));
-                    await deliverPending({ artifact, transport, location: squarePath, activity: actIndex, timeoutMs, now: Date.now() }).catch(() => undefined);
+                    await deliverPending({ artifact: channelArtifact(artifact), preparePresentation: squareWakeProjection(artifact), transport, location: squarePath, message: formatMessageId(messageIndex), timeoutMs, now: Date.now() }).catch(() => undefined);
                 }
             }
             finally {
@@ -134,7 +99,7 @@ export async function sweepPendingNotifications(squarePath, opts = {}) {
     let selected;
     try {
         await artifact.read(facts => facts.header());
-        selected = await sweepPending({ artifact, location: squarePath, now, graceMs: wakeGraceMs(env), limit });
+        selected = await sweepPending({ artifact: channelArtifact(artifact), location: squarePath, now, graceMs: wakeGraceMs(env), limit });
     }
     catch (error) {
         if (error instanceof InternalSquareError && error.code === 'not_found')
@@ -145,8 +110,8 @@ export async function sweepPendingNotifications(squarePath, opts = {}) {
         await artifact.close();
     }
     if (opts.dispatchCandidate !== undefined) {
-        for (const actIndex of selected)
-            await opts.dispatchCandidate(actIndex);
+        for (const messageIndex of selected)
+            await opts.dispatchCandidate(messageIndex);
     }
     return selected;
 }

package/dist/operation-presentation.d.ts

@@ -30,9 +30,8 @@ export interface FailureReport {
     readonly code: string;
     readonly message: string;
     readonly facts?: {
-        readonly reason?: 'never_joined' | 'not_standing' | 'bell_mention_conflict' | 'not_addressed' | 'migration_required' | 'invalid_reply' | 'invalid_done_body' | 'needs_seat';
+        readonly reason?: 'never_joined' | 'not_standing' | 'bell_mention_conflict' | 'not_addressed' | 'invalid_reply' | 'invalid_done_body' | 'needs_seat';
         readonly activityId?: string;
-        readonly ledgerRoot?: string;
         readonly activityExists?: boolean;
     };
     readonly operation?: OperationFailureDetail;

package/dist/operation-presentation.js

@@ -335,13 +335,7 @@ export function renderFailureLines(failure, options = {}) {
     const reason = facts?.reason;
     const marked = reason === 'never_joined' || reason === 'not_standing';
     const lines = marked ? failure.message.split('\n').map((line) => `✕ ${line}`) : [failure.message];
-    if (reason === 'migration_required') {
-        if (facts?.ledgerRoot !== undefined)
-            lines.push('square ledger migrate', 'square ledger verify');
-        else if (squarePath !== undefined)
-            lines.push(`${commandPrefix(squarePath)} migrate`);
-    }
-    else if (squarePath !== undefined && name !== undefined && reason === 'needs_seat') {
+    if (reason === 'needs_seat' && squarePath !== undefined && name !== undefined) {
         lines.splice(0, 1, `✕ ${failure.message}`);
         lines.push(joinRecoveryCommand(squarePath, name, owner));
     }

package/dist/owner.d.ts

@@ -1,5 +1,5 @@
-import { type Owner } from './model.js';
-export type { Owner } from './model.js';
+import { type Owner } from './neutral.js';
+export type { Owner } from './neutral.js';
 export interface HarnessCoordinate {
     readonly channel: string;
     readonly session: string;

package/dist/owner.js

@@ -1,5 +1,5 @@
 import os from 'node:os';
-import { validateOwner } from './model.js';
+import { validateOwner } from './neutral.js';
 export function harnessOwner(coordinate) {
     const channel = nonempty(coordinate.channel, 'channel');
     const session = nonempty(coordinate.session, 'session');

package/dist/paseo-delivery.d.ts

@@ -1,4 +1,4 @@
-import type { WakeRequest, WakeOutcome, WakeTransportPort } from './ports.js';
+import type { WakeRequest, WakeOutcome, WakeTransportPort } from './channel-transport.js';
 import { discoverPaseoAgents, waitForPaseoWakeBoundary } from './paseo-state.js';
 import { sendPaseoWake } from './wake-sink.js';
 export interface PaseoWakeTransportOptions {