@astrosheep/square 0.4.7 → 0.4.8

package/dist/plugins/paseo/shared/card-format.js

@@ -0,0 +1,38 @@
+export function reachLabel(reach) {
+    return reach === "mention" ? "@you" : reach === "attention" ? undefined : reach;
+}
+/** Calendar days, rather than elapsed hours, keep yesterday correct across DST. */
+export function timeLabel(at, now = Date.now(), compact = false) {
+    const date = new Date(at), today = new Date(now);
+    const day = (value) => `${value.getFullYear()}-${value.getMonth()}-${value.getDate()}`;
+    const clock = `${String(date.getHours()).padStart(2, "0")}:${String(date.getMinutes()).padStart(2, "0")}`;
+    if (day(date) === day(today))
+        return clock;
+    const yesterday = new Date(today);
+    yesterday.setDate(today.getDate() - 1);
+    if (day(date) === day(yesterday))
+        return `${compact ? "yest" : "yesterday"} ${clock}`;
+    const shortDate = compact
+        ? `${String(date.getMonth() + 1).padStart(2, "0")}/${String(date.getDate()).padStart(2, "0")}`
+        : date.toLocaleDateString("en-US", { month: "short", day: "numeric" });
+    return `${shortDate} ${clock}`;
+}
+/** Only adjacent references from the same origin can form a range. */
+export function cardReferences(items, originLabel = origin => origin) {
+    const multipleOrigins = new Set(items.map(item => item.origin)).size > 1;
+    const runs = [];
+    for (const item of items) {
+        if (item.ref === undefined)
+            continue;
+        const match = /^act\/(\d+)$/.exec(item.ref);
+        const index = match ? Number(match[1]) : undefined;
+        const previous = runs.at(-1);
+        if (index !== undefined && previous?.origin === item.origin && previous.last !== undefined && previous.last + 1 === index) {
+            previous.last = index;
+        }
+        else
+            runs.push({ origin: item.origin, ref: item.ref, first: index, last: index });
+    }
+    return runs.map(run => `${multipleOrigins ? `${originLabel(run.origin)} ` : ""}${run.first !== run.last
+        ? `act/${run.first}–${run.last}` : run.ref}`).join(", ");
+}

package/dist/plugins/paseo/shared/card-presentation.d.ts

@@ -4,7 +4,9 @@ export type CardPresentation = {
     readonly origin: string;
     readonly author?: string;
     readonly ref?: string;
-    readonly badge?: string;
+    /** Absent on cards produced before landing time and reach were recorded. */
+    readonly at?: number;
+    readonly reach?: 'mention' | 'reply' | 'attention' | 'bell';
     readonly body: string;
 };
 export declare function isCardPresentation(value: unknown): value is CardPresentation;

package/dist/plugins/paseo/shared/card-presentation.js

@@ -3,5 +3,7 @@ export function isCardPresentation(value) {
         return false;
     const item = value;
     return item.kind === 'presentation' && typeof item.origin === 'string' && typeof item.body === 'string'
-        && ['author', 'ref', 'badge'].every(key => item[key] === undefined || typeof item[key] === 'string');
+        && (item.at === undefined || (typeof item.at === 'number' && Number.isFinite(item.at)))
+        && (item.reach === undefined || ['mention', 'reply', 'attention', 'bell'].includes(item.reach))
+        && ['author', 'ref'].every(key => item[key] === undefined || typeof item[key] === 'string');
 }

package/dist/presentation.d.ts

@@ -17,26 +17,10 @@ interface ParticipantOutputOptions {
     name: string;
     participantCount?: number;
 }
-interface ActivityLimitOptions extends ParticipantOutputOptions {
-    count?: number;
-    hardCap?: number;
-    draftPath?: string;
-}
-interface ActivityBlockedOptions extends ParticipantOutputOptions {
-    retryCommand: string;
-    activitySummaries: readonly UnreadActivitySummary[];
-    draftPath?: string;
-}
 interface ExpressWaitingOptions {
     reason: 'throttled';
     delayMs?: number;
 }
-interface ExpressNoWaitOptions extends ParticipantOutputOptions {
-    reason: 'throttled';
-    retryCommand: string;
-    delayMs?: number;
-    draftPath?: string;
-}
 interface WatchStatusOptions extends ParticipantOutputOptions {
     status: WatchStatus;
     idleMs?: number;
@@ -92,7 +76,7 @@ export declare function renderAmbientEvent(event: HydratedAct | Activity, viewer
     mention?: string;
     perception?: Perception;
 }): string;
-export declare function renderActivityBlocked(opts: ActivityBlockedOptions): string;
+export declare function renderUnreadSummary(activitySummaries: readonly UnreadActivitySummary[]): string[];
 /** An indeterminate or already-committed send only points to inspection, never resend. */
 export declare function renderActivityUncertain(opts: ParticipantOutputOptions & {
     draftPath: string;
@@ -100,10 +84,8 @@ export declare function renderActivityUncertain(opts: ParticipantOutputOptions &
     detail?: string;
 }): string;
 export declare function renderExpressWaiting(opts: ExpressWaitingOptions): string;
-export declare function renderExpressNoWait(opts: ExpressNoWaitOptions): string;
 export declare function renderPresenceAnchor(names: readonly string[]): string;
-export declare function renderGrepActivitiesView(visible: readonly HydratedAct[], totalMatches: number, noTruncate: boolean | undefined, squarePath: string, pattern: string, fixed?: boolean, perception?: (act: HydratedAct) => Perception, surface?: PresentationSurface): string;
-export declare function renderActivityLimit(opts: ActivityLimitOptions): string;
+export declare function renderGrepActivitiesView(visible: readonly HydratedAct[], totalMatches: number, full: boolean | undefined, squarePath: string, pattern: string, fixed?: boolean, perception?: (act: HydratedAct) => Perception, surface?: PresentationSurface): string;
 export declare function renderWatchAlreadyActive(opts: ParticipantOutputOptions): string;
 export declare function renderWatchForceTakeover(_opts: ParticipantOutputOptions): string;
 export declare function renderWatchReplaceMissing(_opts: ParticipantOutputOptions): string;

package/dist/presentation.js

@@ -214,17 +214,14 @@ export function renderAmbientEvent(event, viewer, opts = {}) {
 function draftSavedLines(draftPath) {
     return draftPath === undefined ? [] : [style('dim', `· draft kept: ${draftPath}`)];
 }
-function withDraftInput(command, draftPath) {
-    return draftPath === undefined ? command : `${command} < ${quoteShell(draftPath)}`;
-}
-function renderUnreadSummary(activitySummaries) {
+export function renderUnreadSummary(activitySummaries) {
     const visibleSummaries = activitySummaries.slice(0, MAX_IDENTITY_SET_SIZE);
     const remainingSummaries = activitySummaries.length - visibleSummaries.length;
     return [
         ...visibleSummaries.map((item) => {
             const compact = (item.preview.body ?? '').replace(/\s+/g, ' ').trim();
             const bodyPreview = compact === ''
-                ? { text: item.preview.metadata === undefined ? '(empty)' : '(structured activity)', remaining: 0 }
+                ? { text: item.preview.structured ? '(structured activity)' : '(empty)', remaining: 0 }
                 : truncateChars(compact, UNREAD_PREVIEW_CHARS);
             const bodyText = bodyPreview.remaining === 0 ? bodyPreview.text : `${bodyPreview.text}${style('dim', `… (+${bodyPreview.remaining} chars)`)}`;
             return style('dim', `  · ${participantIdentity(item.name)} spoke — ${formatAge(item.latestActivityAgeMs)} ago · "${bodyText}"`);
@@ -232,17 +229,6 @@ function renderUnreadSummary(activitySummaries) {
         ...(remainingSummaries === 0 ? [] : [style('dim', `  · ${remainingSummaries} more participants have unread activity`)]),
     ];
 }
-export function renderActivityBlocked(opts) {
-    const readNowCommand = `${participantCommandPrefix(opts.squarePath, opts.name, opts.owner)} perceive`;
-    return withPathOutput(opts.squarePath, [
-        `${style('blocked', '✕')} your activity hasn't landed — someone spoke while you were away`,
-        ...renderUnreadSummary(opts.activitySummaries),
-        ...draftSavedLines(opts.draftPath),
-        `${readNowCommand}`,
-        '  · take it in, then retry:',
-        withDraftInput(opts.retryCommand, opts.draftPath),
-    ].join('\n'), { participantCount: opts.participantCount });
-}
 /** An indeterminate or already-committed send only points to inspection, never resend. */
 export function renderActivityUncertain(opts) {
     return formatRefusal(opts.squarePath, [
@@ -252,7 +238,7 @@ export function renderActivityUncertain(opts) {
         ...(opts.detail === undefined ? [] : [`  · ${truncateExternalDiagnostic(opts.detail)}`]),
         ...draftSavedLines(opts.draftPath),
         '  · the draft is a saved copy; sending it again could repeat your activity',
-        `${commandPrefix(opts.squarePath)} history${opts.landedId === undefined ? ' --limit 10' : ` --at ${opts.landedId}`} --no-truncate`,
+        `${commandPrefix(opts.squarePath)} history${opts.landedId === undefined ? ' --limit 10' : ` --at ${opts.landedId}`} --full`,
     ], opts);
 }
 export function renderExpressWaiting(opts) {
@@ -262,16 +248,6 @@ export function renderExpressWaiting(opts) {
         '  · --no-wait saves a draft and returns now',
     ].join('\n');
 }
-export function renderExpressNoWait(opts) {
-    const retryCommand = opts.retryCommand;
-    const lines = [
-        `${style('blocked', '✕')} the square is packed — shoulder to shoulder`,
-        `  · a lull opens in ${formatDuration(opts.delayMs)}`,
-        ...draftSavedLines(opts.draftPath),
-        `${withDraftInput(retryCommand, opts.draftPath)}`,
-    ];
-    return withPathOutput(opts.squarePath, lines.join('\n'), { participantCount: opts.participantCount });
-}
 export function renderPresenceAnchor(names) {
     const visibleNames = names.slice(0, MAX_IDENTITY_SET_SIZE);
     const participants = visibleNames.map((name) => participantIdentity(name)).join(', ');
@@ -280,7 +256,7 @@ export function renderPresenceAnchor(names) {
     return style('dim', names.length === 1 ? `→ ${participants} was here` : `→ ${participants}${suffix} were here`);
 }
 const GREP_PREVIEW_CHARS = 160;
-export function renderGrepActivitiesView(visible, totalMatches, noTruncate, squarePath, pattern, fixed = false, perception, surface = 'cli') {
+export function renderGrepActivitiesView(visible, totalMatches, full, squarePath, pattern, fixed = false, perception, surface = 'cli') {
     const publicVisible = visible.filter((act) => act.kind === 'say' || act.kind === 'done');
     if (totalMatches === 0)
         return `○ no activity matched ${quoteShell(pattern)}`;
@@ -294,7 +270,7 @@ export function renderGrepActivitiesView(visible, totalMatches, noTruncate, squa
             chunks.push(header);
             continue;
         }
-        if (noTruncate === true) {
+        if (full === true) {
             const body = rawBody.split('\n').map((line) => `  ${line}`).join('\n');
             chunks.push(`${header}\n${body}`);
             continue;
@@ -316,34 +292,23 @@ export function renderGrepActivitiesView(visible, totalMatches, noTruncate, squa
     }
     if (publicVisible.length === 1) {
         chunks.push(surface === 'tool'
-            ? formatToolAction('history', { location: displayPath(squarePath), at: [formatActivityId(publicVisible[0].index)], context: 2, ...(truncated ? { noTruncate: true } : {}) })
-            : `${commandPrefix(squarePath)} history --at ${formatActivityId(publicVisible[0].index)} -C 2${truncated ? ' --no-truncate' : ''}`);
+            ? formatToolAction('history', { location: displayPath(squarePath), at: [formatActivityId(publicVisible[0].index)], context: 2, ...(truncated ? { full: true } : {}) })
+            : `${commandPrefix(squarePath)} history --at ${formatActivityId(publicVisible[0].index)} -C 2${truncated ? ' --full' : ''}`);
     }
     else if (truncated && publicVisible.length > 1) {
         chunks.push(surface === 'tool'
-            ? formatToolAction('history', { location: displayPath(squarePath), at: [formatActivityId(publicVisible[0].index)], context: 2, noTruncate: true })
-            : `${commandPrefix(squarePath)} history --at ${formatActivityId(publicVisible[0].index)} -C 2 --no-truncate`);
+            ? formatToolAction('history', { location: displayPath(squarePath), at: [formatActivityId(publicVisible[0].index)], context: 2, full: true })
+            : `${commandPrefix(squarePath)} history --at ${formatActivityId(publicVisible[0].index)} -C 2 --full`);
     }
     return chunks.join('\n\n');
 }
-export function renderActivityLimit(opts) {
-    // The cap wording lives inside the count: the speaker is simply spent.
-    const spoken = opts.count !== undefined && opts.hardCap !== undefined ? ` — ${opts.count}/${opts.hardCap} spoken` : '';
-    const doneCommand = `${participantCommandPrefix(opts.squarePath, opts.name, opts.owner)} done`;
-    return withPathOutput(opts.squarePath, [
-        `${style('blocked', '✕')} you’ve reached your speaking cap${spoken}`,
-        ...draftSavedLines(opts.draftPath),
-        '  · your draft stays unsent; done only steps out',
-        doneCommand,
-    ].join('\n'), { participantCount: opts.participantCount });
-}
 export function renderWatchAlreadyActive(opts) {
     return [
         `${style('blocked', '✕')} you are already perceiving`,
         `  · an active perceive is already running for ${participantIdentity(opts.name)}`,
         `  · ${opts.surface === 'tool' ? 'takeover' : '--takeover'} lets a new perceive take over`,
         opts.surface === 'tool'
-            ? formatToolAction('perceive', { location: displayPath(opts.squarePath), as: opts.name, idle: 1800000, takeover: true })
+            ? formatToolAction('perceive', { location: displayPath(opts.squarePath), as: opts.name, idle: '30m', takeover: true })
             : `${participantCommandPrefix(opts.squarePath, opts.name, opts.owner)} perceive --idle 30m --takeover`,
     ].join('\n');
 }
@@ -375,7 +340,7 @@ export function renderWatchStatus(opts) {
                     ? style('dim', `○ dust settles on the flagstones — ${formatDuration(idleMs)} of quiet`)
                     : style('dim', '○ only footsteps in the square — nothing new for you');
             // The quiet report never repeats the perceive just run.
-            const hints = [opts.surface === 'tool' ? formatToolAction('perceive', { location: displayPath(opts.squarePath), as: opts.name, idle: 1800000 }) : `${prefix} perceive --idle 30m`];
+            const hints = [opts.surface === 'tool' ? formatToolAction('perceive', { location: displayPath(opts.squarePath), as: opts.name, idle: '30m' }) : `${prefix} perceive --idle 30m`];
             return [
                 quiet,
                 ...(opts.showPerceiveHint === false ? [] : hints),

package/dist/sqlite-square.js

@@ -215,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')
@@ -515,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-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. */
@@ -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[];
@@ -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-posting.js

@@ -134,7 +134,7 @@ export async function flushSquarePosts(artifact, location, clock, signal, ledger
                 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;

package/dist/square-tools.d.ts

@@ -6,16 +6,6 @@ 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;
@@ -48,6 +38,5 @@ export declare function squareToolFailure(error: unknown, signal?: AbortSignal):
 export declare function squareToolFailureText(failure: JsonObject, context?: {
     location?: string;
     participant?: string;
-    draft?: string;
 }): string;
 export {};

package/dist/square-tools.js

@@ -1,95 +1,32 @@
-import crypto from 'node:crypto';
 import { z } from 'zod/v4';
 import { isSquareError, SquareError } from './model.js';
-import { requireOwner, requireJoinName, selectOwnSeat, HISTORY_MAX_LIMIT, PERCEIVE_DEFAULT_LIMIT, DEFAULT_LIST_DEPTH, DEFAULT_LIST_LIMIT, MAX_LIST_DEPTH, MAX_LIST_LIMIT } from './square-api.js';
-import { parseTimeOrRelative } from './time.js';
+import { requireOwner, requireJoinName, selectOwnSeat, HISTORY_MAX_LIMIT, PERCEIVE_MAX_LIMIT, PERCEIVE_DEFAULT_LIMIT, DEFAULT_LIST_DEPTH, DEFAULT_LIST_LIMIT, MAX_LIST_DEPTH, MAX_LIST_LIMIT } from './square-api.js';
+import { parseDurationMs, parseTimeOrRelative } from './time.js';
 import { renderPerceiveOutcome, renderExpression, renderFailureLines, renderHistoryResult, renderJoinResult, renderLifecycleResult, renderListenerChange, renderStatusResult, renderSquareList, } from './operation-presentation.js';
-/** Process-local recovery: FIFO 64, fixed two-hour TTL, consumed only by a successful express. */
-const EXPRESS_DRAFT_TTL_MS = 2 * 60 * 60 * 1000;
-const EXPRESS_DRAFT_LIMIT = 64;
-export class SquareExpressDrafts {
-    drafts = new Map();
-    purgeExpired() {
-        const now = Date.now();
-        for (const [token, draft] of this.drafts)
-            if (draft.expiresAt <= now)
-                this.drafts.delete(token);
-    }
-    resolve(args, owner) {
-        if (args.draft === undefined)
-            return { args };
-        this.purgeExpired();
-        if (typeof args.draft !== 'string' || Object.keys(args).length !== 1)
-            throw new SquareError('invalid_args', 'An express draft token cannot be combined with other arguments.');
-        const draft = this.drafts.get(args.draft);
-        if (draft === undefined || draft.owner !== owner)
-            throw new SquareError('invalid_args', 'Unknown, expired, or inaccessible express draft.');
-        return { args: draft.args, token: args.draft };
-    }
-    consume(token) {
-        if (token !== undefined)
-            this.drafts.delete(token);
-    }
-    retain(args, owner, token, failure, expressAttempted) {
-        const effect = failure.operation?.expressEffect;
-        // After an attempt, only an admission or argument refusal proves that retrying cannot duplicate an activity.
-        const unsent = !expressAttempted || effect === 'unsent' || (effect === undefined && failure.code === 'invalid_args');
-        if (!unsent || effect === 'landed' || effect === 'unknown' || typeof args.body !== 'string' || args.draft !== undefined
-            || typeof args.location !== 'string' || !args.location.trim())
-            return undefined;
-        this.purgeExpired();
-        if (token !== undefined && this.drafts.has(token))
-            return token;
-        const created = `dr_${crypto.randomBytes(16).toString('base64url')}`;
-        this.drafts.set(created, { owner, args, expiresAt: Date.now() + EXPRESS_DRAFT_TTL_MS });
-        if (this.drafts.size > EXPRESS_DRAFT_LIMIT)
-            this.drafts.delete(this.drafts.keys().next().value);
-        return created;
-    }
-}
 export function createSquareToolRunner() {
-    const drafts = new SquareExpressDrafts();
     return async (tool, args, control, bind) => {
-        let toolArgs = args;
-        let owner;
-        let token;
-        let attempted = false;
         let square;
         try {
             const binding = await bind();
-            owner = binding.identity.owner;
             if ('runDiscovery' in tool)
-                return { text: await tool.runDiscovery(toolArgs, control, binding) };
-            if (tool.name === 'express') {
-                const resolved = drafts.resolve(toolArgs, owner);
-                toolArgs = resolved.args;
-                token = resolved.token;
-            }
-            square = await binding.open(toolArgs.location, control);
-            let text;
+                return { text: await tool.runDiscovery(args, control, binding) };
+            square = await binding.open(args.location, control);
             try {
-                attempted = tool.name === 'express';
-                text = await tool.run(square, toolArgs, control, binding.identity, binding.now);
-                drafts.consume(token);
+                return { text: await tool.run(square, args, control, binding.identity, binding.now) };
             }
             finally {
                 await square.close();
             }
-            return { text };
         }
         catch (error) {
-            const failure = squareToolFailure(error, control.signal);
-            const draft = tool.name === 'express' ? drafts.retain(toolArgs, owner, token, failure, attempted) : undefined;
-            return { isError: true, text: squareToolFailureText(failure, {
-                    location: square?.location ?? toolArgs.location,
-                    participant: typeof toolArgs.as === 'string' ? toolArgs.as : undefined,
-                    draft,
+            return { isError: true, text: squareToolFailureText(squareToolFailure(error, control.signal), {
+                    location: square?.location ?? args.location,
+                    participant: typeof args.as === 'string' ? args.as : undefined,
                 }) };
         }
     };
 }
-const location = z.string().describe('Which square: a .square file path. Relative paths start from the working directory.');
-const expressLocation = z.string().optional().describe('Which square: a .square file path. Relative paths start from the working directory. Required unless retrying with a draft token.');
+const location = z.string().describe('Path to the .square file, relative to the working directory.');
 const participant = z.string().optional().describe('Your name in the square. Leave it out if you hold exactly one name here.');
 const activityId = z.string().regex(/^act\/(0|[1-9][0-9]*)$/);
 const stringArray = z.array(z.string());
@@ -98,7 +35,7 @@ function rendering(render) {
     return (result, args) => render(result, args);
 }
 function tool(name, description, shape, run, render) {
-    const inputSchema = z.object({ ...shape, location: name === 'express' ? expressLocation : location }).strict();
+    const inputSchema = z.object({ ...shape, location }).strict();
     return { name, description, inputSchema,
         run: async (square, args, control, identity, now) => {
             const { location: _location, ...operationArgs } = inputSchema.parse(args);
@@ -115,21 +52,15 @@ export function squareToolsEnabled(env = process.env) {
     throw new SquareError('invalid_args', 'Invalid SQUARE_TOOLS: expected 0, 1, true, false, or none.');
 }
 export 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.';
-function historyToolQuery({ grep, fixed, before, after, since, context, contextBefore, contextAfter, noTruncate: _noTruncate, ...query }, now = Date.now()) {
-    if (grep !== undefined && fixed !== undefined)
-        throw new SquareError('invalid_args', 'Use grep or fixed, not both.');
+function historyToolQuery({ search, regex, before, after, since, full: _full, ...query }, now = Date.now()) {
     if (before !== undefined && after !== undefined)
         throw new SquareError('invalid_args', 'Use before or after, not both.');
     const sinceMs = since === undefined ? undefined : parseTimeOrRelative(since, now);
     if (sinceMs !== undefined && !Number.isFinite(sinceMs))
         throw new SquareError('invalid_args', `Invalid since timestamp: ${since}`);
-    const resolvedBefore = contextBefore ?? context;
-    const resolvedAfter = contextAfter ?? context;
     return { ...query,
         ...(sinceMs === undefined ? {} : { since: sinceMs }),
-        ...(resolvedBefore === undefined ? {} : { contextBefore: resolvedBefore }),
-        ...(resolvedAfter === undefined ? {} : { contextAfter: resolvedAfter }),
-        search: grep !== undefined ? { text: grep, mode: 'regex' } : fixed === undefined ? undefined : { text: fixed, mode: 'literal' },
+        search: search === undefined ? undefined : { text: search, mode: regex ? 'regex' : 'literal' },
         cursor: after !== undefined ? { id: after, direction: 'after' } : before === undefined ? undefined : { id: before, direction: 'before' },
     };
 }
@@ -150,66 +81,57 @@ export const SQUARE_TOOLS = [
         },
     },
     tool('join', 'Step into the square under your name. Do this once before you speak or perceive. You arrive seeing what was said most recently.', {
-        as: z.string().optional().describe('Your name in the square. Give it explicitly when joining.'),
+        as: z.string().describe('Your name in the square.'),
         takeover: z.boolean().optional().describe('Claim this name even though another session holds it now. That session loses it.'),
-        last: z.number().int().min(1).max(HISTORY_MAX_LIMIT).optional().describe('How many recent public activities to show on arrival (default 10, up to 100).'),
+        last: z.number().int().min(1).max(HISTORY_MAX_LIMIT).optional().describe('How many recent public activities to show on arrival (default 10).'),
     }, (square, { as, takeover, last }, control, identity) => square.join(requireJoinName(as), { ...identity, owner: requireOwner(identity.owner), takeover, last, observe: true }, control), rendering((result) => renderJoinResult(result, undefined, 'tool'))),
     tool('express', 'Speak or act in the square. Plain words, half-formed ideas and *actions* all belong here. Mention or reply to someone to be heard by them; ring the bell to be heard by everyone. Said to no one in particular, your words reach those who listen to you.', {
         as: participant,
-        body: z.string().optional().describe('What you say or do. Markdown works; *asterisks* mark an action. Required unless retrying with a draft token.'),
-        draft: z.string().optional().describe('Retry a failed express kept in this process. Pass only the token; the original body and options are restored.'),
+        body: z.string().describe('What you say or do. Markdown works; *asterisks* mark an action.'),
         mentions: stringArray.optional().describe('Who you are speaking to. An @name in the body that matches someone here counts too.'),
-        reach: z.enum(['bell']).optional().describe('"bell" calls everyone in the square. Cannot be used with mentions.'),
+        bell: z.boolean().optional().describe('Call everyone in the square. Not with mentions.'),
         reply: activityId.optional().describe('The activity you are answering, like act/12. Its author hears you if still here.'),
         noMention: z.boolean().optional().describe('Leave @names in the body as plain text. Mentions and reply still reach people.'),
         force: z.boolean().optional().describe('Speak now, even if something reached you that you have not perceived yet.'),
         noWait: z.boolean().optional().describe('If you are speaking too fast, return at once instead of waiting.'),
-    }, async (square, { body, draft, as, ...options }, control, identity) => {
-        if (draft !== undefined)
-            throw new SquareError('invalid_args', 'Unknown or expired express draft.');
-        if (body === undefined)
-            throw new SquareError('invalid_args', 'Express needs a body or a draft token.');
-        return (await selectOwnSeat(square, identity.owner, as)).express(body, { ...options, observe: true }, control);
-    }, rendering((result) => renderExpression(result.observation?.location ?? '', result, undefined, 'tool'))),
+    }, async (square, { body, bell, as, ...options }, control, identity) => (await selectOwnSeat(square, identity.owner, as)).express(body, { ...options, ...(bell ? { reach: 'bell' } : {}), observe: true }, control), rendering((result) => renderExpression(result.observation?.location ?? '', result, undefined, 'tool'))),
     tool('perceive', 'Take in what reached you since you last looked: mentions, replies, bells, and words from those you listen to. What you perceive no longer waits for you; history lets you look back.', {
         as: participant,
-        id: activityId.optional().describe('Take in this activity in full, like act/12, even if you perceived it before. Do not combine with idle, from, mention, limit or takeover.'),
-        idle: z.number().finite().min(0).optional().describe('When nothing is waiting, wait until something arrives or until it has been quiet this many milliseconds. Leave it out to return at once.'),
+        id: activityId.optional().describe('Open this one activity in full, like act/12. Use it alone.'),
+        idle: z.string().optional().describe('When nothing is waiting, wait for activity or this much quiet, like "30s". Leave it out to return at once.'),
         from: stringArray.optional().describe('Only what these participants said.'),
         mention: z.boolean().optional().describe('Only what was addressed to you, and bells.'),
-        limit: z.number().int().min(1).optional().describe('At most this many at once (default 10, up to 100). The rest keeps waiting.'),
+        limit: z.number().int().min(1).max(PERCEIVE_MAX_LIMIT).optional().describe('At most this many at once (default 10). The rest keeps waiting.'),
         takeover: z.boolean().optional().describe('Take over from another active idle perceive for this participant.'),
-    }, async (square, { as, ...options }, control, identity) => (await selectOwnSeat(square, identity.owner, as)).perceive({ ...options, observe: true }, control), rendering((result, args) => {
+    }, async (square, { as, idle, ...args }, control, identity) => {
+        const options = { ...args, ...(idle === undefined ? {} : { idle: parseDurationMs(idle, 'idle') }) };
+        return { ...(await (await selectOwnSeat(square, identity.owner, as)).perceive({ ...options, observe: true }, control)), options };
+    }, rendering((result) => {
         // The CLI always spells the default cap in its continuation, so the tool does too.
-        const options = args;
+        const options = result.options;
         const renderOptions = options.id === undefined ? { ...options, limit: options.limit ?? PERCEIVE_DEFAULT_LIMIT } : options;
         return renderPerceiveOutcome(result.observation?.location ?? '', result, renderOptions, undefined, 'tool').stdout;
     })),
     tool('history', 'Look back at what was said. Reading here takes nothing in: whatever waits for perceive keeps waiting. Page with before or after.', {
-        limit: z.number().int().min(1).optional().describe('How many per page (default 10, up to 100).'),
+        limit: z.number().int().min(1).max(HISTORY_MAX_LIMIT).optional().describe('How many per page (default 10).'),
         order: z.enum(['asc', 'desc']).optional().describe('"asc" for oldest first (default), "desc" for newest first.'),
         before: activityId.optional().describe('The page just before this activity, like act/12.'),
         after: activityId.optional().describe('The page just after this activity, like act/12.'),
         at: z.array(activityId).min(1).optional().describe('Center on these activity ids, like ["act/12"].'),
-        context: z.number().int().min(0).optional().describe('Activities of context before and after each "at" activity.'),
-        contextBefore: z.number().int().min(0).optional().describe('Activities of context before each "at" activity.'),
-        contextAfter: z.number().int().min(0).optional().describe('Activities of context after each "at" activity.'),
+        context: z.number().int().min(0).max(HISTORY_MAX_LIMIT).optional().describe('Activities of context before and after each "at" activity.'),
         since: z.string().optional().describe('Only activities after this ISO timestamp or relative duration (like "10m").'),
-        grep: z.string().optional().describe('Only activities matching this regular expression in their names, ids or words. Use grep or fixed, not both.'),
-        fixed: z.string().optional().describe('Only activities containing this exact text.'),
+        search: z.string().optional().describe('Only activities containing this text in their names, ids or words.'),
+        regex: z.boolean().optional().describe('Treat search as a regular expression.'),
         from: stringArray.optional().describe('Only what these participants said.'),
         mention: z.string().optional().describe('Only what was addressed to this participant.'),
-        noTruncate: z.boolean().optional().describe('Show full activity bodies even when multiple activities are returned.'),
+        full: z.boolean().optional().describe('Show full activity bodies even when multiple activities are returned.'),
     }, async (square, args, control, _identity, now) => {
         const query = historyToolQuery(args, now?.());
         return { ...(await square.history({ ...query, observe: true }, control)), query };
-    }, rendering((result, args) => renderHistoryResult(result.observation?.location ?? '', result, { query: result.query, noTruncate: args.noTruncate === true, surface: 'tool' }))),
+    }, rendering((result, args) => renderHistoryResult(result.observation?.location ?? '', result, { query: result.query, full: args.full === true, surface: 'tool' }))),
     tool('attention', 'Turn toward someone or away from them, from now on. Listen: hear everything they say, even to others. Unlisten: stop listening without clearing an ignore; mentions and replies still reach you unless ignored. Ignore: hear nothing from them but bells. What was already said stays as it was.', {
         as: participant, action: z.enum(['listen', 'unlisten', 'ignore']).describe('"listen", "unlisten" or "ignore". Listening again ends an ignore.'), target,
-    }, async (square, { as, action, target }, control, identity) => {
-        const self = await selectOwnSeat(square, identity.owner, as);
-        return self[action](target, { observe: true }, control);
-    }, rendering((result, args) => renderListenerChange(result.observation?.location ?? '', args.action, result))),
+    }, async (square, { as, action, target }, control, identity) => (await selectOwnSeat(square, identity.owner, as))[action](target, { observe: true }, control), rendering((result, args) => renderListenerChange(result.observation?.location ?? '', args.action, result))),
     tool('done', 'Step out of the square. Everyone sees you leave, and you stop listening to anyone. Leaving carries no words, so say goodbye with express first. Stay instead if someone may still need you; you can join again later.', { as: participant }, async (square, { as }, control, identity) => (await selectOwnSeat(square, identity.owner, as)).done(undefined, { observe: true }, control), rendering((result) => renderLifecycleResult(result.observation?.location ?? '', result))),
     tool('status', 'Look around the square: who is here, the latest activity, and who you listen to.', {
         as: z.string().optional().describe('Whose listening to show. Leave it out if you hold exactly one name here.'),
@@ -231,13 +153,5 @@ export function squareToolFailure(error, signal) {
 }
 /** Readable failure text with tool-native recovery actions, never raw JSON. */
 export function squareToolFailureText(failure, context = {}) {
-    const report = failure;
-    const lines = renderFailureLines(report, { squarePath: context.location, name: context.participant, surface: 'tool' });
-    if (context.draft !== undefined) {
-        lines.push(`· draft kept in memory: ${context.draft}`);
-        lines.push(report.code === 'behind'
-            ? '· perceive the pending activity, then retry express with only:'
-            : '· correct the problem above, then retry express with only:', `{ "draft": "${context.draft}" }`);
-    }
-    return lines.join('\n');
+    return renderFailureLines(failure, { squarePath: context.location, name: context.participant, surface: 'tool' }).join('\n');
 }

package/dist/square-values.d.ts

@@ -1,4 +1,4 @@
-export declare const WAKE_ROUTE_KINDS: readonly ["opencode-server", "codex-queue", "claude-native", "paseo", "http"];
+export declare const WAKE_ROUTE_KINDS: readonly ["opencode-server", "codex-queue", "paseo", "http"];
 export type WakeRouteKind = typeof WAKE_ROUTE_KINDS[number];
 export type JsonValue = null | boolean | number | string | readonly JsonValue[] | {
     readonly [key: string]: JsonValue;

package/dist/square-values.js

@@ -1,5 +1,5 @@
 import { SquareError, nameKey } from './neutral.js';
-export const WAKE_ROUTE_KINDS = ['opencode-server', 'codex-queue', 'claude-native', 'paseo', 'http'];
+export const WAKE_ROUTE_KINDS = ['opencode-server', 'codex-queue', 'paseo', 'http'];
 export const MESSAGE_METADATA_MAX_BYTES = 16 * 1024;
 export const MESSAGE_METADATA_MAX_DEPTH = 256;
 /** Validate the bounded, lossless JSON object carried by a message. */

package/dist/time.d.ts

@@ -1,3 +1,4 @@
+export declare function parseDurationMs(value: string, label: string): number;
 export declare function formatTimestamp(at: number): string;
 export declare function formatDuration(ms: number | undefined): string;
 export declare function formatRelativeTime(at: number, now?: number): string;