@astrosheep/square 0.4.6 → 0.4.8

package/dist/sqlite-square.js

@@ -5,7 +5,7 @@ import { squareLocation } from './square-location.js';
 import crypto from 'node:crypto';
 import { setTimeout as sleep } from 'node:timers/promises';
 import { InternalSquareError, SquareError, isSquareError, nameKey, validateName } from './model.js';
-import { checkControl, failure, squareClock } from './operation-control.js';
+import { checkControl, failure } from './operation-control.js';
 import { validateMetadataMatch } from './delivery-deferral.js';
 import { flushSquarePosts, reconcileSquareDelivery, readSquareSessions, ensureInitialDeliverySession } from './square-posting.js';
 import { attentionChange, coreDone, coreListening, decideAct, decideJoin, resolveKnownName, validateDoneBody } from './decisions.js';
@@ -17,13 +17,11 @@ import { asSeatRef, participantAuthority, requireJoinName, requireOwner } from '
 import { recoveryObservation, entryPresentation, queryStatus, queryParticipants, perceivePresence, parseRequiredActivityId, toPublicActivity, toPerceivedActivity, publicActivities, selectHistory, NON_READ, HISTORY_MAX_LIMIT, HISTORY_DEFAULT_LIMIT } from './views.js';
 import { sessionInboxCounts } from './inbox.js';
 import { participantIdentity } from './participant-identity.js';
-import { joinRecoveryCommand } from './presentation.js';
 import { acquireWatchLease, ownsWatchLease, pulseWatchLease, releaseWatchLease } from './wakes.js';
 import { createArtifactPort, createSquare, diagnoseSquareFile, prepareSquareBuild } from './artifact.js';
 import { activityQueryFilter } from './activity-query.js';
 import { discoverSquares } from './list.js';
 import { streamSquare } from './stream.js';
-export { squareClock } from './operation-control.js';
 export { formatActivityId, parseActivityId, MAX_IDENTITY_SET_SIZE } from './square-core.js';
 export { PERCEIVE_DEFAULT_LIMIT, PERCEIVE_MAX_LIMIT } from './perceive-decisions.js';
 export { HISTORY_DEFAULT_LIMIT, HISTORY_MAX_LIMIT } from './views.js';
@@ -43,25 +41,25 @@ export class SqliteSquare {
     location;
     artifact;
     clock;
-    env;
-    deliveryLocation;
-    constructor(location, artifact, clock, env, deliveryLocation = location) {
+    canonicalLocation;
+    ledgerLocation;
+    constructor(location, artifact, clock, canonicalLocation = location, ledgerLocation) {
         this.location = location;
         this.artifact = artifact;
         this.clock = clock;
-        this.env = env;
-        this.deliveryLocation = deliveryLocation;
+        this.canonicalLocation = canonicalLocation;
+        this.ledgerLocation = ledgerLocation;
     }
-    reconcile(signal) { return reconcileSquareDelivery(this.artifact, this.deliveryLocation, this.env, this.clock, signal); }
+    reconcile(signal) { return reconcileSquareDelivery(this.artifact, this.canonicalLocation, this.clock, signal, this.ledgerLocation); }
     // Posting is retryable after commit; a delivery failure cannot make a landed write unsent.
-    async flush(signal) { await flushSquarePosts(this.artifact, this.deliveryLocation, this.env, this.clock, signal).catch(() => undefined); }
+    async flush(signal) { await flushSquarePosts(this.artifact, this.canonicalLocation, this.clock, signal, this.ledgerLocation).catch(() => undefined); }
     static async at(input, control) {
-        const env = { ...(input.env ?? process.env) }, location = squareLocation({ ...input, env });
-        const clock = squareClock(env, input.clock);
+        const location = squareLocation(input);
+        const clock = input.clock ?? Date.now;
         const artifact = createArtifactPort(location, undefined, control?.signal);
         try {
             await artifact.read(facts => facts.header(), control?.signal);
-            return new SqliteSquare(location, artifact, clock, env, await canonicalPath(location));
+            return new SqliteSquare(location, artifact, clock, await canonicalPath(location), input.ledgerLocation);
         }
         catch (error) {
             await artifact.close();
@@ -72,15 +70,15 @@ export class SqliteSquare {
     }
     static async build(input, control) {
         checkControl(control);
-        const env = { ...(input.env ?? process.env) }, location = squareLocation({ ...input, env });
+        const location = squareLocation(input);
         await createSquare(location, { hardCap: input.hardCap, throttlePerMinute: input.throttlePerMinute,
             template: input.template, force: input.force ?? false }, input.markdown, control?.signal);
         // Publication already committed; cancellation cannot erase the completed build.
-        return SqliteSquare.at({ ...input, path: location, env });
+        return SqliteSquare.at({ ...input, path: location });
     }
     static inMemory(input) {
-        const env = { ...(input.env ?? process.env) };
-        return new SqliteSquare(`memory://${crypto.randomUUID()}`, createArtifactPort(':memory:', prepareSquareBuild(input, input.markdown)), squareClock(env, input.clock), env);
+        const clock = input.clock ?? Date.now;
+        return new SqliteSquare(`memory://${crypto.randomUUID()}`, createArtifactPort(':memory:', prepareSquareBuild(input, input.markdown)), clock, undefined, input.ledgerLocation);
     }
     /** Join establishes membership and local producer custody in one transaction. */
     async joinSeat(name, options, control) {
@@ -133,7 +131,7 @@ export class SqliteSquare {
                             : seat?.attachment === 'detached' ? 'is away; resume the host session first'
                                 : 'needs a current participant seat; join first';
                 throw new SquareError('already_joined', `${participantIdentity(participant?.name ?? name)} ${reason}`, {
-                    reason: 'needs_seat', join: joinRecoveryCommand(this.location, participant?.name ?? name),
+                    reason: 'needs_seat',
                 });
             }
             return seat;
@@ -150,7 +148,7 @@ export class SqliteSquare {
     async withHostPresence(select, control) {
         const seats = (await this.artifact.read(facts => facts.roster().filter(person => person.joined)
             .flatMap(person => { const seat = facts.seat(person.name); return seat === undefined ? [] : [seat]; }), control?.signal)).value;
-        const sessions = await readSquareSessions(seats, this.env, control?.signal);
+        const sessions = await readSquareSessions(seats, control?.signal, this.ledgerLocation);
         const captured = new Map(seats.map(seat => [nameKey(seat.participant), seat]));
         return (await this.artifact.read(facts => {
             const seat = (name) => {
@@ -217,9 +215,9 @@ export class SqliteSquare {
                                 ...(options.reach === undefined ? {} : { reach: options.reach }), ...(options.noMention === undefined ? {} : { noMention: options.noMention }), ...(reply === undefined ? {} : { reply }) });
                             const decision = rejectUnsentActivity(() => {
                                 if (proposed.type === 'blocked')
-                                    throw new SquareError('behind', `${participantIdentity(name)} has pending activity`, { pending: proposed.activitySummaries.reduce((count, summary) => count + summary.count, 0) });
+                                    throw new SquareError('behind', `${participantIdentity(name)} has pending activity`, { activitySummaries: proposed.activitySummaries });
                                 if (proposed.type === 'capped')
-                                    throw new SquareError('capped', `${participantIdentity(name)} reached the activity cap`);
+                                    throw new SquareError('capped', `${participantIdentity(name)} reached the activity cap`, { spoken: facts.participant(name).sayCount, ...(facts.header().hardCap == null ? {} : { hardCap: facts.header().hardCap }) });
                                 if (proposed.type === 'throttled')
                                     throw new SquareError('throttled', `${name} is throttled`, { retryAfterMs: proposed.delayMs });
                                 if (proposed.type === 'bell_quota')
@@ -338,10 +336,10 @@ export class SqliteSquare {
                 validateName(name);
                 if (!Number.isFinite(idle) || idle < 0)
                     throw new SquareError('invalid_args', 'Perceive idle duration must be a non-negative number');
-                if (options.id !== undefined && ['idle', 'from', 'mention', 'limit', 'replace'].some(key => Object.hasOwn(options, key)))
-                    throw new SquareError('invalid_args', 'Perceive id cannot be combined with idle, from, mention, limit or replace');
-                if (Object.hasOwn(options, 'replace') && idle === 0)
-                    throw new SquareError('invalid_args', 'Perceive replacement requires a positive idle duration');
+                if (options.id !== undefined && ['idle', 'from', 'mention', 'limit', 'takeover'].some(key => Object.hasOwn(options, key)))
+                    throw new SquareError('invalid_args', 'Perceive id cannot be combined with idle, from, mention, limit or takeover');
+                if (Object.hasOwn(options, 'takeover') && idle === 0)
+                    throw new SquareError('invalid_args', 'Perceive takeover requires a positive idle duration');
                 perceiveLimit(options.limit);
                 const probe = (await square.artifact.read(facts => {
                     name = resolveKnownName(facts, this.name);
@@ -362,13 +360,13 @@ export class SqliteSquare {
                 }
                 const watch = {
                     ...(selection.from === undefined ? {} : { participants: [...selection.from] }), ...(options.mention ? { mention: name } : {}),
-                    ...(options.replace === undefined ? {} : { replace: options.replace }),
+                    ...(options.takeover === undefined ? {} : { takeover: options.takeover }),
                 };
                 const start = await acquireWatchLease(square.artifact, seat, square.clock(), crypto.randomUUID(), watch, control?.signal);
                 if (start.type === 'active')
                     return await complete(undefined, 'already-active');
                 leaseId = start.leaseId;
-                control?.onProgress?.({ kind: 'perceive-started', participant: name, idleMs: idle, replacementRequested: options.replace ?? false, replaced: start.replaced });
+                control?.onProgress?.({ kind: 'perceive-started', participant: name, idleMs: idle, replacementRequested: options.takeover ?? false, replaced: start.replaced });
                 const quietSince = square.clock();
                 let nextHeartbeat = start.heartbeatAt + WATCH_HEARTBEAT_MS;
                 while (true) {
@@ -483,7 +481,7 @@ export class SqliteSquare {
             const last = options.last ?? HISTORY_DEFAULT_LIMIT;
             if (!Number.isSafeInteger(last) || last < 1 || last > HISTORY_MAX_LIMIT)
                 throw new SquareError('invalid_args', 'Join history limit must be between 1 and 100');
-            if (!await ensureInitialDeliverySession(requireOwner(options.owner), this.env, options.wakeAddress, control?.signal))
+            if (!await ensureInitialDeliverySession(requireOwner(options.owner), options.wakeAddress, control?.signal, this.ledgerLocation))
                 throw new SquareError('already_joined', `${participantIdentity(name)} is away; resume the host session first`, { reason: 'needs_seat' });
             await this.reconcile(control?.signal);
             const committed = await this.joinSeat(name, options, control);
@@ -517,11 +515,10 @@ export class SqliteSquare {
             throw new SquareError('invalid_args', 'History order must be asc or desc.');
         if (query.since !== undefined && !Number.isFinite(query.since))
             throw new SquareError('invalid_args', 'History timestamp must be finite');
-        for (const count of [query.contextBefore, query.contextAfter])
-            if (count !== undefined && (!Number.isSafeInteger(count) || count < 0))
-                throw new SquareError('invalid_args', 'History context must be a non-negative safe integer');
+        if (query.context !== undefined && (!Number.isSafeInteger(query.context) || query.context < 0 || query.context > HISTORY_MAX_LIMIT))
+            throw new SquareError('invalid_args', `History context must be a non-negative integer no greater than ${HISTORY_MAX_LIMIT}`);
         const limit = query.limit === undefined ? (query.at?.length ? null : HISTORY_DEFAULT_LIMIT) : query.limit;
-        const contextual = !!query.at?.length || query.contextBefore !== undefined || query.contextAfter !== undefined;
+        const contextual = !!query.at?.length || query.context !== undefined;
         const kinds = contextual || query.since !== undefined ? [...NON_READ, 'read'] : NON_READ;
         return (await this.artifact.read(facts => {
             const selected = selectHistory(facts, query, limit, kinds, query.observe === true);

package/dist/square-api.d.ts

@@ -16,4 +16,4 @@ export declare function selectOwnSeat(square: Pick<SqliteSquare, 'participant' |
 }): Promise<Participant | undefined>;
 export { ACTIVITY_METADATA_MAX_BYTES } from './model.js';
 export { localUserOwner, harnessOwner, decodeHarnessOwner } from './owner.js';
-export { squareClock, formatActivityId, parseActivityId, MAX_IDENTITY_SET_SIZE, PERCEIVE_DEFAULT_LIMIT, PERCEIVE_MAX_LIMIT, HISTORY_DEFAULT_LIMIT, HISTORY_MAX_LIMIT, DEFAULT_LIST_DEPTH, MAX_LIST_DEPTH, DEFAULT_LIST_LIMIT, MAX_LIST_LIMIT, diagnoseSquare, discover, inbox } from './sqlite-square.js';
+export { formatActivityId, parseActivityId, MAX_IDENTITY_SET_SIZE, PERCEIVE_DEFAULT_LIMIT, PERCEIVE_MAX_LIMIT, HISTORY_DEFAULT_LIMIT, HISTORY_MAX_LIMIT, DEFAULT_LIST_DEPTH, MAX_LIST_DEPTH, DEFAULT_LIST_LIMIT, MAX_LIST_LIMIT, diagnoseSquare, discover, inbox } from './sqlite-square.js';

package/dist/square-api.js

@@ -24,4 +24,4 @@ export async function selectOwnSeat(square, owner, name, options) {
 }
 export { ACTIVITY_METADATA_MAX_BYTES } from './model.js';
 export { localUserOwner, harnessOwner, decodeHarnessOwner } from './owner.js';
-export { squareClock, formatActivityId, parseActivityId, MAX_IDENTITY_SET_SIZE, PERCEIVE_DEFAULT_LIMIT, PERCEIVE_MAX_LIMIT, HISTORY_DEFAULT_LIMIT, HISTORY_MAX_LIMIT, DEFAULT_LIST_DEPTH, MAX_LIST_DEPTH, DEFAULT_LIST_LIMIT, MAX_LIST_LIMIT, diagnoseSquare, discover, inbox } from './sqlite-square.js';
+export { formatActivityId, parseActivityId, MAX_IDENTITY_SET_SIZE, PERCEIVE_DEFAULT_LIMIT, PERCEIVE_MAX_LIMIT, HISTORY_DEFAULT_LIMIT, HISTORY_MAX_LIMIT, DEFAULT_LIST_DEPTH, MAX_LIST_DEPTH, DEFAULT_LIST_LIMIT, MAX_LIST_LIMIT, diagnoseSquare, discover, inbox } from './sqlite-square.js';

package/dist/square-facade.d.ts

@@ -2,7 +2,7 @@ import type { MetadataMatch } from './delivery-deferral.js';
 export type { MetadataMatch, MetadataScalar } from './delivery-deferral.js';
 import type { ActivityId, Perception, Reach } from './square-core.js';
 import type { Owner, HydratedAct, WakeAddress, ActivityMetadata, DirectedNotificationRoute } from './model.js';
-import type { OperationControl } from './neutral.js';
+import type { OperationControl, UnreadActivitySummary } from './neutral.js';
 export interface ActivitySearch {
     readonly text: string;
     readonly mode: 'literal' | 'regex';
@@ -16,7 +16,7 @@ export interface HeldSeat {
     readonly name: string;
     readonly generation: string;
 }
-export type { PerceiveWaitStart, OperationProgress, OperationControl, OperationFailureDetail, OperationError } from './neutral.js';
+export type { PerceiveWaitStart, OperationProgress, OperationControl, OperationFailureDetail, OperationError, UnreadActivitySummary, SquareErrorFacts } from './neutral.js';
 export type { ActivityId, Perception, Reach } from './square-core.js';
 export type { Owner, WakeAddress, ActivityMetadata, JsonValue, DirectedNotificationRoute } from './model.js';
 /** Indexed archive event, including read bookkeeping and a say's linked content. */
@@ -81,7 +81,7 @@ export interface PerceiveOptions extends ObservationOptions {
     readonly from?: readonly string[];
     readonly mention?: boolean;
     readonly limit?: number;
-    readonly replace?: boolean;
+    readonly takeover?: boolean;
 }
 export interface ActivityCursor {
     readonly id: ActivityId;
@@ -119,8 +119,7 @@ export interface HistoryQuery extends ActivityQuery, ObservationOptions {
     readonly order?: 'asc' | 'desc';
     readonly mention?: string;
     readonly since?: number;
-    readonly contextBefore?: number;
-    readonly contextAfter?: number;
+    readonly context?: number;
 }
 export interface HistoryResult {
     readonly activities: readonly Activity[];
@@ -128,11 +127,11 @@ export interface HistoryResult {
 }
 export interface OpenOptions {
     readonly clock?: () => number;
+    readonly ledgerLocation?: string;
 }
 export interface SquareLocation {
     readonly path?: string;
     readonly cwd?: string;
-    readonly env?: NodeJS.ProcessEnv;
 }
 export interface SquareAtInput extends SquareLocation, OpenOptions {
 }
@@ -255,14 +254,6 @@ export interface StreamOptions {
     readonly start?: StreamStart;
 }
 export type StreamRecord = Activity | PerceivedActivity;
-export interface UnreadActivitySummary {
-    readonly name: string;
-    readonly count: number;
-    readonly latestActivityAgeMs: number;
-    readonly preview: Extract<ArchiveRecord, {
-        kind: 'say';
-    }>;
-}
 export interface EntryPresentation {
     readonly joinedBefore: boolean;
     readonly scene: string;

package/dist/square-location.d.ts

@@ -1,7 +1,6 @@
 interface SquareLocation {
     readonly path?: string;
     readonly cwd?: string;
-    readonly env?: NodeJS.ProcessEnv;
 }
 export declare function squareLocation(input: SquareLocation): string;
 export {};

package/dist/square-posting.d.ts

@@ -4,10 +4,10 @@ import type { SquareArtifactPort } from './ports.js';
 /** Local producer custody and current host attachment are different observations. */
 export declare function deliverySessionsForSeats(ledger: DeliveryLedger, seats: readonly Seat[], signal?: AbortSignal): Promise<ReadonlyMap<string, DeliverySession | undefined>>;
 /** Read-only host observations for status; callers fence them against the captured World seats. */
-export declare function readSquareSessions(seats: readonly Seat[], env: NodeJS.ProcessEnv, signal?: AbortSignal): Promise<ReadonlyMap<string, DeliverySession | undefined>>;
+export declare function readSquareSessions(seats: readonly Seat[], signal?: AbortSignal, ledgerLocation?: string): Promise<ReadonlyMap<string, DeliverySession | undefined>>;
 /** A first producer join may register an absent owner, never resume or revive one. */
-export declare function ensureInitialDeliverySession(owner: Seat['owner'], env: NodeJS.ProcessEnv, route?: DeliveryRoute, signal?: AbortSignal): Promise<boolean>;
+export declare function ensureInitialDeliverySession(owner: Seat['owner'], route?: DeliveryRoute, signal?: AbortSignal, ledgerLocation?: string): Promise<boolean>;
 /** Called only by privileged mutations. Sandbox lease/ACK/selection never enters here. */
-export declare function reconcileSquareDelivery(artifact: SquareArtifactPort, location: string, env: NodeJS.ProcessEnv, clock: () => number, signal?: AbortSignal): Promise<void>;
+export declare function reconcileSquareDelivery(artifact: SquareArtifactPort, location: string, clock: () => number, signal?: AbortSignal, ledgerLocation?: string): Promise<void>;
 /** One export path for Square activities and Square-owned notices. No transaction spans I/O. */
-export declare function flushSquarePosts(artifact: SquareArtifactPort, location: string, env: NodeJS.ProcessEnv, clock: () => number, signal?: AbortSignal): Promise<void>;
+export declare function flushSquarePosts(artifact: SquareArtifactPort, location: string, clock: () => number, signal?: AbortSignal, ledgerLocation?: string): Promise<void>;

package/dist/square-posting.js

@@ -1,5 +1,5 @@
 import { randomUUID } from 'node:crypto';
-import { DeliveryLedger, deliveryLedgerLocation } from './delivery-ledger.js';
+import { DeliveryLedger } from './delivery-ledger.js';
 import { dispatchPostedCard } from './notifications.js';
 import { retainDeliveryLedger } from './delivery-lifetime.js';
 import { projectNotification, displayAttentionPath } from './attention-presentation.js';
@@ -7,9 +7,7 @@ import { coreDone } from './decisions.js';
 import { activityMetadataHasContent } from './model.js';
 import { formatActivityId } from './square-core.js';
 import { squarePostKey } from './square-post.js';
-const openLedger = (env, signal) => DeliveryLedger.open({
-    location: deliveryLedgerLocation(env), signal,
-});
+const openLedger = (ledgerLocation, signal) => DeliveryLedger.open({ location: ledgerLocation, signal });
 function renderPost(location, post) {
     if (post.kind === 'notice')
         return { text: post.body ?? '', full: true };
@@ -24,10 +22,10 @@ export async function deliverySessionsForSeats(ledger, seats, signal) {
     return new Map(await Promise.all(owners.map(async (owner) => [owner, await ledger.session(owner, signal)])));
 }
 /** Read-only host observations for status; callers fence them against the captured World seats. */
-export async function readSquareSessions(seats, env, signal) {
+export async function readSquareSessions(seats, signal, ledgerLocation) {
     if (!seats.length)
         return new Map();
-    const ledger = await openLedger(env, signal);
+    const ledger = await openLedger(ledgerLocation, signal);
     try {
         return await deliverySessionsForSeats(ledger, seats, signal);
     }
@@ -36,8 +34,8 @@ export async function readSquareSessions(seats, env, signal) {
     }
 }
 /** A first producer join may register an absent owner, never resume or revive one. */
-export async function ensureInitialDeliverySession(owner, env, route, signal) {
-    const ledger = await openLedger(env, signal);
+export async function ensureInitialDeliverySession(owner, route, signal, ledgerLocation) {
+    const ledger = await openLedger(ledgerLocation, signal);
     try {
         const current = await ledger.session(owner, signal);
         if (!current) {
@@ -55,12 +53,12 @@ export async function ensureInitialDeliverySession(owner, env, route, signal) {
     }
 }
 /** Called only by privileged mutations. Sandbox lease/ACK/selection never enters here. */
-export async function reconcileSquareDelivery(artifact, location, env, clock, signal) {
+export async function reconcileSquareDelivery(artifact, location, clock, signal, ledgerLocation) {
     const snapshot = (await artifact.read(facts => ({ seats: facts.roster().filter(person => person.joined)
             .flatMap(person => { const seat = facts.seat(person.name); return seat ? [seat] : []; }), posts: facts.postedPosts() }), signal)).value;
     if (!snapshot.seats.length && !snapshot.posts.length)
         return;
-    const ledger = await openLedger(env, signal);
+    const ledger = await openLedger(ledgerLocation, signal);
     try {
         const sessions = await deliverySessionsForSeats(ledger, snapshot.seats, signal);
         for (const seat of snapshot.seats) {
@@ -107,7 +105,7 @@ async function suppressWithdrawn(artifact, ledger, location, signal) {
         await ledger.suppress({ owner: post.owner, key: squarePostKey(location, post), scope: 'exact' }, signal);
 }
 /** One export path for Square activities and Square-owned notices. No transaction spans I/O. */
-export async function flushSquarePosts(artifact, location, env, clock, signal) {
+export async function flushSquarePosts(artifact, location, clock, signal, ledgerLocation) {
     signal ??= AbortSignal.timeout(5000);
     // Delivery enrichment cannot turn a committed producer mutation into a retry of that mutation.
     let lifetime;
@@ -115,14 +113,14 @@ export async function flushSquarePosts(artifact, location, env, clock, signal) {
         const snapshot = (await artifact.read(facts => ({ pending: facts.pendingPosts(), posted: facts.postedPosts() }), signal)).value;
         if (!snapshot.pending.length && !snapshot.posted.length)
             return;
-        const ledger = await openLedger(env, signal);
+        const ledger = await openLedger(ledgerLocation, signal);
         lifetime = retainDeliveryLedger(ledger);
         for (const post of snapshot.pending) {
             const session = await ledger.session(post.owner, signal);
             if (session?.state !== 'attached')
                 continue;
             const rendered = renderPost(location, post), token = randomUUID();
-            const owned = (await artifact.transactAs({ kind: 'producer' }, facts => facts.acquirePost({ ...post, full: rendered.full }, token, process.pid, clock(), Date.now()), signal)).value;
+            const owned = (await artifact.transactAs({ kind: 'producer' }, facts => facts.acquirePost({ ...post, full: rendered.full }, token, process.pid, clock()), signal)).value;
             if (!owned)
                 continue;
             let posted = false, knownUnsent = true;
@@ -130,13 +128,13 @@ export async function flushSquarePosts(artifact, location, env, clock, signal) {
                 // This check is not custody across the await; the ledger independently fences delivery.
                 const current = await ledger.session(post.owner, signal);
                 if (current?.state !== 'attached' || current.generation !== session.generation
-                    || !(await artifact.read(facts => facts.ownsPost(token, Date.now()), signal)).value)
+                    || !(await artifact.read(facts => facts.ownsPost(token), signal)).value)
                     continue;
                 knownUnsent = false;
                 const result = await ledger.post({ owner: post.owner, key: squarePostKey(location, post), text: rendered.text,
                     ...(post.kind === 'activity' ? { details: { kind: 'presentation', origin: displayAttentionPath(location),
                             ref: formatActivityId(post.index), author: post.from, body: post.body ?? '',
-                            ...(post.route === 'bell' ? { badge: '🔔' } : {}) } } : {}),
+                            at: post.at, reach: post.route } } : {}),
                 }, signal);
                 posted = ['posted', 'duplicate', 'suppressed'].includes(result.status);
                 knownUnsent = !posted;
@@ -161,7 +159,7 @@ export async function flushSquarePosts(artifact, location, env, clock, signal) {
             for (const post of posts.filter(post => post.owner === owner)) {
                 const key = squarePostKey(location, post);
                 if (pendingKeys.has(key))
-                    await dispatchPostedCard(ledger, owner, key, lifetime.track, env, signal);
+                    await dispatchPostedCard(ledger, post.owner, key, result => lifetime?.track(result), signal);
             }
         }
     }

package/dist/square-tools.d.ts

@@ -6,23 +6,11 @@ export interface ToolIdentity {
     readonly wakeAddress?: WakeAddress;
 }
 type JsonObject = Record<string, unknown>;
-export declare class SquareExpressDrafts {
-    private readonly drafts;
-    private purgeExpired;
-    resolve(args: JsonObject, owner?: Owner): {
-        args: JsonObject;
-        token?: string;
-    };
-    consume(token?: string): void;
-    retain(args: JsonObject, owner: Owner | undefined, token: string | undefined, failure: JsonObject, expressAttempted: boolean): string | undefined;
-}
 interface ToolBinding {
     identity: ToolIdentity;
+    readonly now?: () => number;
     open(location: string | undefined, control: OperationControl): Promise<Square>;
-    discover(options: DiscoveryOptions, control: OperationControl): Promise<{
-        result: DiscoveryResult;
-        now: number;
-    }>;
+    discover(options: DiscoveryOptions, control: OperationControl): Promise<DiscoveryResult>;
 }
 export declare function createSquareToolRunner(): (tool: ToolDefinition, args: JsonObject, control: OperationControl, bind: () => Promise<ToolBinding> | ToolBinding) => Promise<{
     text: string;
@@ -33,7 +21,7 @@ interface SingleSquareToolDefinition {
     description: string;
     inputSchema: z.ZodObject<z.ZodRawShape>;
     /** Human text identical to what the CLI prints; domain receipts stay inside the adapter. */
-    run(square: Square, args: JsonObject, control: OperationControl, identity: ToolIdentity): Promise<string>;
+    run(square: Square, args: JsonObject, control: OperationControl, identity: ToolIdentity, now?: () => number): Promise<string>;
 }
 interface DiscoveryToolDefinition {
     name: 'list';
@@ -46,10 +34,9 @@ export declare function squareToolsEnabled(env?: NodeJS.ProcessEnv): boolean;
 export declare const SQUARE_TOOL_INSTRUCTIONS = "List nearby squares and your joined names with list. Pass location for a single square. Join once. Then express to speak, and perceive to take in what reached you. History looks back without taking anything in.";
 export declare const SQUARE_TOOLS: readonly ToolDefinition[];
 export declare function squareToolFailure(error: unknown, signal?: AbortSignal): JsonObject;
-/** Readable failure text with the same recovery commands the CLI offers, never raw JSON. */
+/** Readable failure text with tool-native recovery actions, never raw JSON. */
 export declare function squareToolFailureText(failure: JsonObject, context?: {
     location?: string;
     participant?: string;
-    draft?: string;
 }): string;
 export {};