@astrosheep/square 0.3.86 → 0.3.88

package/dist/model.js

@@ -1,6 +1,90 @@
 // 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'];
+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 sameBody(left, right) {
+    return left.channel === right.channel && left.session === right.session && left.agent === right.agent;
+}
+export function validateBody(body) {
+    if (!body || typeof body.channel !== 'string' || !body.channel || typeof body.session !== 'string' || !body.session
+        || (body.agent !== undefined && (typeof body.agent !== 'string' || !body.agent))) {
+        throw new SquareError('invalid_args', 'A participant write requires an explicit channel and session body.');
+    }
+}
 export function isWakeRouteKind(value) {
     return typeof value === 'string' && WAKE_ROUTE_KINDS.includes(value);
 }

package/dist/notifications.d.ts

@@ -1,19 +1,21 @@
-import { type WakeAdapter } from './delivery.js';
+import { type WakeRouteKind } from './model.js';
 import type { WakeTransportPort } from './ports.js';
 export type { PlannedNotification } from './delivery.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 {
-    adapters?: WakeAdapter[];
+    transports?: WakeTransports;
     env?: NodeJS.ProcessEnv;
     now?: () => number;
 }
-export declare function defaultWakeAdapters(env?: NodeJS.ProcessEnv): Promise<WakeAdapter[]>;
-export declare function createDefaultWakeTransport(hostLedger: import('./host-ledger.js').HostLedgerPort, clock: () => number, env?: NodeJS.ProcessEnv, suppliedAdapters?: readonly WakeAdapter[]): Promise<WakeTransportPort>;
-export declare function createWakeTransport(adapters: readonly WakeAdapter[], hostLedger: import('./host-ledger.js').HostLedgerPort, clock: () => number, nativePorts?: Readonly<Partial<Record<import('./model.js').WakeRouteKind, WakeTransportPort>>>): WakeTransportPort;
+/** 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<import("./ports.js").DeliveryResult>;
 /** 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, suppliedAdapters?: WakeAdapter[], deadline?: number, signal?: AbortSignal): Promise<void>;
+export declare function sweepPrivilegedPending(cwd: string, env?: NodeJS.ProcessEnv, suppliedTransports?: WakeTransports, deadline?: number, signal?: AbortSignal): Promise<void>;
 export interface SweepPendingNotificationsOptions {
     env?: NodeJS.ProcessEnv;
     now?: number;

package/dist/notifications.js

@@ -1,16 +1,9 @@
-import { hostLedgerRoot } from './host-ledger-root.js';
 import path from 'node:path';
 import fs from 'node:fs';
-import { SquareError } from './model.js';
-import { renderAttentionPreview, renderSquareReminder } from './attention-presentation.js';
-import { openSquare } from './open-square.js';
-import { closeOpenSquare } from './open-square.js';
+import { indexedSquareEntries } from './square-index.js';
+import { InternalSquareError, SquareError } from './model.js';
+import { createArtifactPort } from './artifact.js';
 import { deliverPending, sweepPending } from './delivery-operations.js';
-import { projectWakeEvidence } from './wake-eligibility.js';
-import { pendingHead } from './delivery.js';
-import { parseActivityId } from './square-core.js';
-import { canonicalPath } from './canonical-path.js';
-import { createHostLedgerPort } from './host-ledger-file-adapter.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);
@@ -19,161 +12,75 @@ export function wakeGraceMs(env = process.env) {
     }
     return value;
 }
-export async function defaultWakeAdapters(env = process.env) {
-    const adapters = [];
+/** 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 { CodexQueueAdapter } = await import('./codex-queue.js');
-        adapters.push(new CodexQueueAdapter({ env }));
+        const { CodexQueueTransport } = await import('./codex-queue.js');
+        transports['codex-queue'] = new CodexQueueTransport({ env });
     }
-    catch {
-        // Codex is unavailable only when this build omits its local adapter.
-    }
-    try {
-        const { PaseoAdapter } = await import('./paseo-delivery.js');
-        adapters.push(new PaseoAdapter());
-    }
-    catch {
-        // Paseo is an optional integration; a core-only install simply has no Paseo adapter.
+    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 */ }
     }
-    return adapters;
-}
-export async function createDefaultWakeTransport(hostLedger, clock, env = process.env, suppliedAdapters) {
-    const adapters = suppliedAdapters ?? await defaultWakeAdapters(env);
     const { createClaudeWakeTransport } = await import('./claude-delivery.js');
-    return createWakeTransport(suppliedAdapters === undefined && env.SQUARE_DISABLE_PASEO_WAKE === '1' ? adapters.filter((adapter) => adapter.kind !== 'paseo') : adapters, hostLedger, clock, { 'claude-native': createClaudeWakeTransport(hostLedger, env) });
-}
-async function observeWakeRequest(request, hostLedger, now) {
-    let square;
-    try {
-        const location = await canonicalPath(request.location);
-        square = await openSquare(location, { hostLedger });
-        const { value: facts } = await square.artifact.read((facts) => {
-            const index = parseActivityId(request.activity);
-            const head = index === undefined ? undefined : pendingHead(facts, request.participant, index);
-            return { routes: facts.routes(), pending: head === undefined ? [] : [head] };
-        });
-        const eligibility = await projectWakeEvidence({ ...facts, hostLedger, location, now });
-        return { ...eligibility.currentness({ ...request, location }), observationAvailable: true };
-    }
-    catch {
-        return { current: false, activityPending: false, sessionBound: false, routePublished: false,
-            selectedOwner: false, cancelled: false, presented: false, observationAvailable: false };
-    }
-    finally {
-        if (square !== undefined)
-            await closeOpenSquare(square);
-    }
+    transports['claude-native'] = createClaudeWakeTransport(env);
+    return createWakeTransport(transports);
 }
-export function createWakeTransport(adapters, hostLedger, clock, nativePorts = {}) {
+/** 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 {
-        probe: async (route) => {
-            const native = nativePorts[route.kind];
-            if (native !== undefined)
-                return native.probe?.(route) ?? true;
-            const adapter = adapters.find((candidate) => candidate.kind === route.kind);
-            if (adapter === undefined)
-                return { outcome: 'not-capable', diagnostic: `no adapter for ${route.kind}` };
-            const probe = adapter.probe;
-            if (probe === undefined)
-                return true;
+        async probe(route) {
+            const transport = transports[route.kind];
+            if (transport === undefined)
+                return missing(route.kind);
             try {
-                return await probe.call(adapter, route.address);
+                return await transport.probe?.(route) ?? true;
             }
             catch (error) {
                 return { outcome: 'not-capable', diagnostic: error instanceof Error ? error.message : String(error) };
             }
         },
-        attempt: async (request, timeoutMs, beforeSend) => {
-            let revalidation;
-            const finalGate = beforeSend ?? (async () => {
-                revalidation = await observeWakeRequest(request, hostLedger, clock());
-                return revalidation.current;
-            });
-            const native = nativePorts[request.route.kind];
-            if (native !== undefined)
-                return native.attempt(request, timeoutMs, finalGate);
-            const adapter = adapters.find((candidate) => candidate.kind === request.route.kind);
-            if (adapter === undefined)
-                return { outcome: 'not-capable', diagnostic: `no adapter for ${request.route.kind}` };
-            try {
-                const location = await canonicalPath(request.location);
-                const square = await openSquare(location, { hostLedger }).catch(() => undefined);
-                if (square === undefined)
-                    return { outcome: 'not-capable', diagnostic: `Square is unavailable at ${location}` };
-                let payload;
-                try {
-                    const index = parseActivityId(request.activity);
-                    payload = (await square.artifact.read((facts) => {
-                        const head = index === undefined ? undefined : pendingHead(facts, request.participant, index);
-                        const item = index === undefined ? undefined : facts.activity(index);
-                        if (!head || item?.kind !== 'say')
-                            return undefined;
-                        return renderSquareReminder([renderAttentionPreview({
-                                squarePath: location, recipient: request.participant, actIndex: item.index,
-                                actor: item.actor, route: head.route, body: item.body,
-                            })]);
-                    })).value;
-                }
-                finally {
-                    await closeOpenSquare(square);
-                }
-                if (payload === undefined)
-                    return { outcome: 'not-capable', diagnostic: 'No pending Square activity to preview.' };
-                const result = await adapter.dispatch(request.route.address, payload, finalGate, timeoutMs, request);
-                if (result.outcome !== 'gate-rejected')
-                    return result;
-                if (revalidation !== undefined && !revalidation.current) {
-                    return {
-                        outcome: 'failed',
-                        signature: 'pre_send_revalidation_failed',
-                        message: revalidation.observationAvailable
-                            ? 'Wake was not sent because current attention, session binding, or route no longer matches.'
-                            : 'Wake was not sent because current Square delivery state could not be verified.',
-                        diagnostic: revalidation,
-                        unavailable: true,
-                    };
-                }
-                return { outcome: 'unknown', diagnostic: 'wake dispatch cancelled' };
-            }
-            catch (error) {
-                return { outcome: 'unknown', 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;
-    const ledgerRoot = hostLedgerRoot(env);
-    const hostLedger = createHostLedgerPort({
-        rootPath: ledgerRoot,
-    });
-    const square = await openSquare(squarePath, { clock: now, hostLedger, env });
+    const artifact = createArtifactPort(squarePath);
     try {
-        const transport = await createDefaultWakeTransport(hostLedger, now, env, opts.adapters);
+        await artifact.read(facts => facts.header());
+        const transport = await createDefaultWakeTransport(env, opts.transports);
         try {
-            return await deliverPending({ artifact: square.artifact, hostLedger, transport, location: squarePath, activity: actIndex, timeoutMs: Number(env.SQUARE_NOTIFY_DELIVERY_WAIT_MS ?? 5000), now: now() });
+            return await deliverPending({ artifact, transport, location: squarePath, activity: actIndex, timeoutMs: Number(env.SQUARE_NOTIFY_DELIVERY_WAIT_MS ?? 5000), now: now() });
         }
         catch {
             return { attempted: 0, accepted: 0, failed: 0, unknown: 0, notCapable: 1 };
         }
     }
+    catch (error) {
+        if (error instanceof InternalSquareError && error.code === 'not_found')
+            throw new SquareError('unavailable', `Square is unavailable at ${squarePath}`);
+        throw error;
+    }
     finally {
-        await closeOpenSquare(square);
+        await artifact.close();
     }
 }
 /** Privileged hook fallback: sweep indexed squares plus the current cwd's local squares within one boundary budget. */
-export async function sweepPrivilegedPending(cwd, env = process.env, suppliedAdapters, deadline = Date.now() + PRIVILEGED_HOOK_BUDGET_MS, signal) {
+export async function sweepPrivilegedPending(cwd, env = process.env, suppliedTransports, deadline = Date.now() + PRIVILEGED_HOOK_BUDGET_MS, signal) {
     const remainingMs = () => Math.max(0, deadline - Date.now());
     if (remainingMs() === 0 || signal?.aborted)
         return;
-    const root = hostLedgerRoot(env);
-    const hostLedger = createHostLedgerPort({ rootPath: root });
-    let indexed = [];
-    try {
-        indexed = await hostLedger.listPresence({ now: Date.now() });
-    }
-    catch { /* capability is best effort */ }
+    const indexed = await indexedSquareEntries({}, env).catch(() => []);
     const paths = new Set(indexed.map((binding) => binding.location));
     try {
         for (const entry of await fs.promises.readdir(path.join(cwd, '.square'))) {
@@ -184,29 +91,30 @@ export async function sweepPrivilegedPending(cwd, env = process.env, suppliedAda
     catch { /* no local square directory */ }
     if (remainingMs() === 0 || signal?.aborted)
         return;
-    const transport = await createDefaultWakeTransport(hostLedger, Date.now, env, suppliedAdapters);
+    const transport = await createDefaultWakeTransport(env, suppliedTransports);
     for (const squarePath of paths) {
         if (remainingMs() === 0 || signal?.aborted)
             break;
         try {
-            const square = await openSquare(squarePath, { hostLedger, env, signal });
+            const artifact = createArtifactPort(squarePath, undefined, signal);
             try {
+                await artifact.read(facts => facts.header(), signal);
                 if (remainingMs() === 0 || signal?.aborted)
                     break;
                 const limit = Number.parseInt(env.SQUARE_NOTIFY_SWEEP_LIMIT ?? '8', 10);
                 const graceMs = 0;
-                const selected = await sweepPending({ artifact: square.artifact, hostLedger, location: squarePath, now: Date.now(), graceMs, limit: Number.isFinite(limit) && limit > 0 ? limit : 8 }).catch(() => []);
+                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 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: square.artifact, hostLedger, transport, location: squarePath, activity: actIndex, timeoutMs, now: Date.now() }).catch(() => undefined);
+                    await deliverPending({ artifact, transport, location: squarePath, activity: actIndex, timeoutMs, now: Date.now() }).catch(() => undefined);
                 }
             }
             finally {
-                await closeOpenSquare(square);
+                await artifact.close();
             }
         }
         catch { /* stale index entries are ignored by the hook */ }
@@ -219,14 +127,19 @@ export async function sweepPendingNotifications(squarePath, opts = {}) {
         return [];
     const now = opts.now ?? Date.now();
     const limit = opts.limit ?? 8;
-    const hostLedger = createHostLedgerPort({ rootPath: hostLedgerRoot(env) });
-    const square = await openSquare(squarePath, { clock: () => now, hostLedger, env });
+    const artifact = createArtifactPort(squarePath);
     let selected;
     try {
-        selected = await sweepPending({ artifact: square.artifact, hostLedger, location: squarePath, now, graceMs: wakeGraceMs(env), limit });
+        await artifact.read(facts => facts.header());
+        selected = await sweepPending({ artifact, location: squarePath, now, graceMs: wakeGraceMs(env), limit });
+    }
+    catch (error) {
+        if (error instanceof InternalSquareError && error.code === 'not_found')
+            throw new SquareError('unavailable', `Square is unavailable at ${squarePath}`);
+        throw error;
     }
     finally {
-        await closeOpenSquare(square);
+        await artifact.close();
     }
     if (opts.dispatchCandidate !== undefined) {
         for (const actIndex of selected)

package/dist/operation-presentation.js

@@ -58,13 +58,12 @@ export function renderExpression(squarePath, data) {
         ? `● you ring the bell — everyone turns · ${activity.id}${style('dim', capCount)}`
         : `● ${activity.mentions.length > 0
             ? `you walk over to ${activity.mentions.map((target) => participantIdentity(target)).join(', ')}`
-            : isGestureOnly(activity.body ?? '') ? 'your gesture lands' : 'your words land'} — ${activity.id}${style('dim', capCount)}`;
+            : activity.metadata !== undefined && (activity.body ?? '').trim() === '' ? 'structured activity lands' : isGestureOnly(activity.body ?? '') ? 'your gesture lands' : 'your words land'} — ${activity.id}${style('dim', capCount)}`;
     const replyNotice = data.replyAuthorNotHere === undefined ? ''
         : `\n○ ${participantIdentity(data.replyAuthorNotHere)} isn't in the square right now — the reply landed without reaching them`;
     const unmatchedNotice = data.unmatchedMentions?.length
         ? `\n  · ${data.unmatchedMentions.map((token) => `@${token} isn't standing here`).join('; ')} — ${activity.mentions.length === 0 && activity.reply === undefined ? 'activity landed bare' : 'left as literal text'}` : '';
-    return withPathOutput(projection.location ?? squarePath, (projection.reentry === undefined ? '' : '● you stepped back into the square\n')
-        + confirmation + (data.hint ? `\n${style('dim', `· ${data.hint}`)}` : '') + replyNotice + unmatchedNotice + pending, { participantCount: projection.standingCount, held: projection.held });
+    return withPathOutput(projection.location ?? squarePath, confirmation + (data.hint ? `\n${style('dim', `· ${data.hint}`)}` : '') + replyNotice + unmatchedNotice + pending, { participantCount: projection.standingCount, held: projection.held });
 }
 function continuationCommand(squarePath, name, options) {
     const args = ['--now'];
@@ -136,7 +135,7 @@ function renderHistoryProjection(projection, visible, noTruncate, squarePath) {
     }
     if (chunks.length === 0)
         return '○ no activity matches this history query';
-    if (preview !== undefined && shown.some((activity) => activity.kind === 'say' && activity.body.length > preview)) {
+    if (preview !== undefined && shown.some((activity) => activity.kind === 'say' && (activity.body?.length ?? 0) > preview)) {
         chunks.push(`${commandPrefix(squarePath)} history --at ${shown.map((activity) => formatActivityId(activity.index)).join(',')} --no-truncate`);
     }
     if (anchored.length > 0)
@@ -294,6 +293,10 @@ export function renderStatusResult(squarePath, data) {
     const output = [
         style('dim', counts),
         ...(hold === undefined ? [] : ['', hold]), '', style('dim', 'around the square'), ...people, '', style('dim', 'latest'), ...latest,
+        ...(data.listening === undefined ? [] : [
+            '', style('dim', 'you listen to'),
+            ...(data.listening.length === 0 ? ['  ○ not turned toward anyone'] : data.listening.map((name) => `  · ${participantIdentity(name)}`)),
+        ]),
     ].join('\n');
     return withPathOutput(squarePath, output, { participantCount: presentation.standingCount, held: presentation.held });
 }

package/dist/participant-identity.d.ts

@@ -23,6 +23,3 @@ export declare function firstHarnessSession(env?: NodeJS.ProcessEnv): {
     readonly sessionId: string;
     readonly channel: HarnessSessionChannel;
 } | undefined;
-export declare function automaticParticipant(provider: AutomaticProvider, sessionId: string, env: NodeJS.ProcessEnv): string;
-/** Compute the current harness participant without reading a Square or registry artifact. */
-export declare function squareAssignedParticipantName(env?: NodeJS.ProcessEnv): string | undefined;

package/dist/participant-identity.js

@@ -1,5 +1,3 @@
-import { createHash } from 'node:crypto';
-import { validateName } from './model.js';
 export function participantIdentity(name) {
     return `@${name}`;
 }
@@ -38,32 +36,3 @@ export function firstHarnessSession(env = process.env) {
     }
     return undefined;
 }
-export function automaticParticipant(provider, sessionId, env) {
-    const configured = env.SQUARE_PARTICIPANT_NAME?.trim();
-    if (configured) {
-        validateName(configured);
-        return configured;
-    }
-    const digest = createHash('sha256').update(sessionId, 'utf8').digest('hex').slice(0, 12);
-    return `${provider}-${digest}`;
-}
-/** Compute the current harness participant without reading a Square or registry artifact. */
-export function squareAssignedParticipantName(env = process.env) {
-    const configured = env.SQUARE_PARTICIPANT_NAME?.trim();
-    if (configured) {
-        validateName(configured);
-        return configured;
-    }
-    // Every native provider contributes its own name without deduping session ids first: equal ids
-    // in different providers are different coordinates and must stay ambiguous.
-    const names = new Set();
-    for (const source of harnessSessionSources) {
-        if (source.provider === undefined)
-            continue;
-        const sessionId = env[source.variable]?.trim();
-        if (!sessionId)
-            continue;
-        names.add(automaticParticipant(source.provider, sessionId, env));
-    }
-    return names.size === 1 ? [...names][0] : undefined;
-}

package/dist/paseo-delivery.d.ts

@@ -1,14 +1,13 @@
-import { type WakeAdapter, type WakeAdapterResult, type WakeDispatchContext } from './delivery.js';
+import type { WakeRequest, WakeOutcome, WakeTransportPort } from './ports.js';
 import { discoverPaseoAgents, waitForPaseoWakeBoundary } from './paseo-state.js';
 import { sendPaseoWake } from './wake-sink.js';
-export interface PaseoAdapterOptions {
+export interface PaseoWakeTransportOptions {
     discover?: typeof discoverPaseoAgents;
     waitForBoundary?: typeof waitForPaseoWakeBoundary;
     sendWake?: typeof sendPaseoWake;
 }
-export declare class PaseoAdapter implements WakeAdapter {
+export declare class PaseoWakeTransport implements WakeTransportPort {
     private readonly opts;
-    readonly kind: "paseo";
-    constructor(opts?: PaseoAdapterOptions);
-    dispatch(address: Readonly<Record<string, string>>, payload: string, beforeSend: () => Promise<boolean>, timeoutMs?: number, context?: WakeDispatchContext): Promise<WakeAdapterResult>;
+    constructor(opts?: PaseoWakeTransportOptions);
+    attempt(request: WakeRequest, timeoutMs: number, beforeSend: () => Promise<boolean>): Promise<WakeOutcome>;
 }

package/dist/paseo-delivery.js

@@ -1,3 +1,4 @@
+import { wakePreview } from './delivery.js';
 import { DeliveryError } from './packages/agent-delivery/src/index.js';
 import { resolvePaseoDaemon } from './packages/agent-delivery/src/paseo-native.js';
 import { discoverPaseoAgents, waitForPaseoWakeBoundary } from './paseo-state.js';
@@ -14,13 +15,13 @@ function diagnostic(phase, address, code) {
         passwordPresent: Boolean(process.env.PASEO_PASSWORD),
     };
 }
-export class PaseoAdapter {
+export class PaseoWakeTransport {
     opts;
-    kind = 'paseo';
     constructor(opts = {}) {
         this.opts = opts;
     }
-    async dispatch(address, payload, beforeSend, timeoutMs = 5000, context) {
+    async attempt(request, timeoutMs, beforeSend) {
+        const address = request.route.address;
         const deadline = Date.now() + timeoutMs;
         const remainingMs = () => Math.max(0, deadline - Date.now());
         const budgetUnavailable = () => ({
@@ -41,6 +42,10 @@ export class PaseoAdapter {
                 diagnostic: diagnostic('selection', address, 'invalid_address'),
             };
         }
+        const payload = request.artifact === undefined ? undefined
+            : (await request.artifact.read((facts) => wakePreview(facts, request))).value;
+        if (payload === undefined)
+            return { outcome: 'not-capable', diagnostic: 'No pending Square activity to preview.' };
         let remaining = remainingMs();
         if (remaining === 0)
             return budgetUnavailable();
@@ -84,7 +89,7 @@ export class PaseoAdapter {
             };
         }
         if (!(await beforeSend()))
-            return { outcome: 'gate-rejected' };
+            return { outcome: 'not-capable' };
         remaining = remainingMs();
         if (remaining === 0)
             return budgetUnavailable();
@@ -92,10 +97,10 @@ export class PaseoAdapter {
             await (this.opts.sendWake ?? sendPaseoWake)({
                 agentId,
                 prompt: payload,
-                location: context?.location ?? '',
-                participant: context?.participant ?? '',
-                activity: context?.activity ?? '',
-                ...(context?.attemptN === undefined ? {} : { attemptN: context.attemptN }),
+                location: request.location,
+                participant: request.participant,
+                activity: request.activity,
+                ...(request.attemptN === undefined ? {} : { attemptN: request.attemptN }),
             }, { timeoutMs: remaining });
             return { outcome: 'accepted' };
         }

package/dist/paseo.d.ts

@@ -1,5 +1,5 @@
 /** Optional Paseo integration. Importing this entry requires the Paseo peer dependencies. */
-export { PaseoAdapter } from './paseo-delivery.js';
+export { PaseoWakeTransport } from './paseo-delivery.js';
 export { paseoWakeMessageId, sendPaseoWake } from './wake-sink.js';
 export type { PaseoWakeRequest } from './wake-sink.js';
 export { discoverPaseoAgents, waitForPaseoWakeBoundary } from './paseo-state.js';

package/dist/paseo.js

@@ -1,4 +1,4 @@
 /** Optional Paseo integration. Importing this entry requires the Paseo peer dependencies. */
-export { PaseoAdapter } from './paseo-delivery.js';
+export { PaseoWakeTransport } from './paseo-delivery.js';
 export { paseoWakeMessageId, sendPaseoWake } from './wake-sink.js';
 export { discoverPaseoAgents, waitForPaseoWakeBoundary } from './paseo-state.js';

package/dist/plugins/opencode/delivery.d.ts

@@ -7,8 +7,13 @@ export interface OpenCodeContextMessage {
         readonly text?: string;
     }[];
 }
-/** Only the matching prepared primary context authorizes presentation, never admission. */
+export declare function indexedOpenCodeSessions(env: NodeJS.ProcessEnv): Promise<readonly string[]>;
+export declare function discoverOpenCodeSeats(sessionId: string, env: NodeJS.ProcessEnv, signal?: AbortSignal): Promise<import("../../model.js").LocatedSeat[]>;
+/** The exact prepared native message can authorize artifact-backed presentation once. */
 export declare function observeOpenCodeContext(sessionId: string, messages: readonly OpenCodeContextMessage[], env: NodeJS.ProcessEnv, signal: AbortSignal): Promise<void>;
-/** One existing observer and the existing dispatch owner; no second queue or evidence store. */
+/** The native receiver owns no claims outside the artifact; HOME is used only for discovery. */
 export declare function receiveOpenCodePending(target: OpenCodeNativeSession, env: NodeJS.ProcessEnv, signal: AbortSignal): Promise<void>;
-export declare function publishOpenCodeRoutes(sessionId: string, env: NodeJS.ProcessEnv, signal: AbortSignal): Promise<boolean>;
+/** Publish the native address into current artifact seats; the legacy route projection is not read. */
+export declare function publishOpenCodeAddress(sessionId: string, env: NodeJS.ProcessEnv, signal: AbortSignal): Promise<boolean>;
+export declare function cancelOpenCodeDeliveries(sessionId: string, env: NodeJS.ProcessEnv, signal: AbortSignal): Promise<void>;
+export declare function endOpenCodeSession(sessionId: string, env: NodeJS.ProcessEnv, signal: AbortSignal): Promise<void>;