@astrosheep/square 0.3.32 → 0.3.33

package/claude-plugin/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "square",
-  "version": "0.3.32",
+  "version": "0.3.33",
   "description": "Native Claude Code turn-boundary delivery for Square participants",
   "author": {
     "name": "Square"

package/codex-plugin/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "square",
-  "version": "0.3.32",
+  "version": "0.3.33",
   "description": "Shared Square activity with reliable participant attention at Codex boundaries.",
   "author": {
     "name": "Square"

package/dist/claude-hook.js

@@ -1,7 +1,7 @@
 import { presentPendingAtBoundary } from './boundary-presentation.js';
 import { sessionInbox } from './inbox.js';
 import { automaticSessionEnd, automaticSessionStart } from './automatic-session.js';
-import { sweepPrivilegedPending } from './notifications.js';
+import { PRIVILEGED_HOOK_BUDGET_MS, sweepPrivilegedPending } from './notifications.js';
 export async function runClaudeHookAsync(inputText, env = process.env) {
     let input;
     try {
@@ -36,12 +36,13 @@ export async function runClaudeHookAsync(inputText, env = process.env) {
     return runClaudeHook(inputText, env);
 }
 export async function claudeHookResponse(input, lookup = sessionInbox, env = process.env, deliveryAdapters) {
+    const sweepDeadline = Date.now() + PRIVILEGED_HOOK_BUDGET_MS;
     if (typeof input.session_id !== 'string' || input.session_id === '')
         return undefined;
     if (input.hook_event_name !== 'PostToolBatch')
         return undefined;
     const response = await presentPendingAtBoundary(input.session_id, (context) => ({ hookSpecificOutput: { hookEventName: 'PostToolBatch', additionalContext: context } }), lookup, env);
-    await sweepPrivilegedPending(typeof input.cwd === 'string' ? input.cwd : process.cwd(), env, deliveryAdapters).catch(() => undefined);
+    await sweepPrivilegedPending(typeof input.cwd === 'string' ? input.cwd : process.cwd(), env, deliveryAdapters, sweepDeadline).catch(() => undefined);
     return response;
 }
 export async function runClaudeHook(inputText, env = process.env) {

package/dist/codex-hook.js

@@ -2,12 +2,13 @@ import { presentPendingAtBoundary } from './boundary-presentation.js';
 import { sessionInbox } from './inbox.js';
 import { automaticSessionEnd, automaticSessionStart } from './automatic-session.js';
 import { clearCodexBoundary, recordCodexBoundary } from './codex-boundary-state.js';
-import { sweepPrivilegedPending } from './notifications.js';
+import { PRIVILEGED_HOOK_BUDGET_MS, sweepPrivilegedPending } from './notifications.js';
 const CODEX_HOOK_EVENTS = {
     PostToolUse: 'PostToolUse',
     Stop: 'Stop',
 };
 export async function codexHookResponse(input, lookup = sessionInbox, env = process.env, deliveryAdapters) {
+    const sweepDeadline = Date.now() + PRIVILEGED_HOOK_BUDGET_MS;
     if (typeof input.session_id !== 'string' || input.session_id === '')
         return undefined;
     if (typeof input.hook_event_name !== 'string')
@@ -19,7 +20,7 @@ export async function codexHookResponse(input, lookup = sessionInbox, env = proc
     const response = await presentPendingAtBoundary(input.session_id, (context) => hookEventName === 'Stop'
         ? { systemMessage: context }
         : { hookSpecificOutput: { hookEventName: 'PostToolUse', additionalContext: context } }, lookup, env);
-    await sweepPrivilegedPending(typeof input.cwd === 'string' ? input.cwd : process.cwd(), env, deliveryAdapters).catch(() => undefined);
+    await sweepPrivilegedPending(typeof input.cwd === 'string' ? input.cwd : process.cwd(), env, deliveryAdapters, sweepDeadline).catch(() => undefined);
     return response;
 }
 export async function runCodexHook(inputText, env = process.env) {

package/dist/codex-queue.d.ts

@@ -22,6 +22,6 @@ export declare class CodexQueueAdapter implements WakeAdapter {
     private readonly opts;
     readonly kind: "codex-queue";
     constructor(opts?: CodexQueueAdapterOptions);
-    dispatch(address: Readonly<Record<string, string>>, payload: string, beforeSend: () => Promise<boolean>): Promise<WakeDispatchResult>;
+    dispatch(address: Readonly<Record<string, string>>, payload: string, beforeSend: () => Promise<boolean>, timeoutMs?: number): Promise<WakeDispatchResult>;
 }
 export type { WakeRoute };

package/dist/codex-queue.js

@@ -33,7 +33,9 @@ export class CodexQueueAdapter {
     constructor(opts = {}) {
         this.opts = opts;
     }
-    async dispatch(address, payload, beforeSend) {
+    async dispatch(address, payload, beforeSend, timeoutMs = 5000) {
+        const deadline = Date.now() + timeoutMs;
+        const remainingMs = () => Math.max(0, deadline - Date.now());
         const threadId = address.threadId?.trim();
         if (!threadId) {
             return { outcome: 'unavailable', signature: 'invalid_address', message: 'Codex route has no thread id.', routeStale: true };
@@ -57,8 +59,12 @@ export class CodexQueueAdapter {
                 retainRoute: true,
             };
         }
+        const remaining = remainingMs();
+        if (remaining === 0) {
+            return { outcome: 'unavailable', signature: 'dispatch_budget_exhausted', message: 'The wake dispatch budget elapsed before queueing.', retainRoute: true };
+        }
         try {
-            (this.opts.sendQueue ?? sendCodexQueue)({ threadId, message: payload }, { env });
+            (this.opts.sendQueue ?? sendCodexQueue)({ threadId, message: payload }, { env, timeoutMs: remaining });
             return { outcome: 'accepted' };
         }
         catch (error) {

package/dist/delivery-operations.js

@@ -4,6 +4,19 @@ import { nameKey } from './model.js';
 import { deriveDeliveryModel } from './delivery.js';
 import { isWakeRouteAttemptable } from './square-projections.js';
 import { retireWakeRouteFromArtifact } from './routes.js';
+async function attemptWakeWithin(transport, request, timeoutMs) {
+    let timer;
+    const timeout = new Promise((resolve) => {
+        timer = setTimeout(() => resolve({ outcome: 'unknown', diagnostic: 'transport timeout' }), timeoutMs);
+    });
+    try {
+        return await Promise.race([transport.attempt(request, timeoutMs), timeout]);
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    }
+}
 export async function observeSquare(input) {
     const snapshot = await input.artifact.read();
     const delivery = deriveDeliveryModel(snapshot.state);
@@ -128,7 +141,7 @@ export async function deliverPending(input) {
                     continue;
                 }
                 try {
-                    outcome = await Promise.race([input.transport.attempt(request, leaseMs), new Promise((resolve) => setTimeout(() => resolve({ outcome: 'unknown', diagnostic: 'transport timeout' }), leaseMs))]);
+                    outcome = await attemptWakeWithin(input.transport, request, leaseMs);
                 }
                 catch (error) {
                     outcome = { outcome: 'unknown', diagnostic: error instanceof Error ? error.message : String(error) };

package/dist/delivery.d.ts

@@ -41,7 +41,7 @@ export type WakeDispatchResult = {
 };
 export interface WakeAdapter {
     readonly kind: WakeRouteKind;
-    dispatch(address: Readonly<Record<string, string>>, payload: string, beforeSend: () => Promise<boolean>): Promise<WakeDispatchResult>;
+    dispatch(address: Readonly<Record<string, string>>, payload: string, beforeSend: () => Promise<boolean>, timeoutMs?: number): Promise<WakeDispatchResult>;
 }
 export interface RoutedNotification {
     actor: string;

package/dist/notifications.d.ts

@@ -6,6 +6,7 @@ import type { WakeTransportPort } from './ports.js';
 export type { PlannedNotification } from './delivery.js';
 export { planActNotifications, matchesMentionTarget };
 export { notificationMessageId } from './delivery.js';
+export declare const PRIVILEGED_HOOK_BUDGET_MS = 3000;
 export declare function wakeGraceMs(env?: NodeJS.ProcessEnv): number;
 export declare function hasDeliveredNotification(squarePath: string, name: string, ref: number | ActivityId): Promise<boolean>;
 export declare function hasAttentionNotification(squarePath: string, name: string, ref: number | ActivityId, env?: NodeJS.ProcessEnv): Promise<boolean>;
@@ -21,8 +22,8 @@ export declare function defaultWakeAdapters(): Promise<WakeAdapter[]>;
 export declare function createDefaultWakeTransport(hostLedger: import('./host-ledger.js').HostLedgerPort, clock: () => number, env?: NodeJS.ProcessEnv): Promise<WakeTransportPort>;
 export declare function createWakeTransport(adapters: readonly WakeAdapter[], hostLedger: import('./host-ledger.js').HostLedgerPort, clock: () => number): 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. */
-export declare function sweepPrivilegedPending(cwd: string, env?: NodeJS.ProcessEnv, suppliedAdapters?: WakeAdapter[]): Promise<void>;
+/** Privileged hook fallback: sweep indexed squares plus the current cwd's local squares within one boundary budget. */
+export declare function sweepPrivilegedPending(cwd: string, env?: NodeJS.ProcessEnv, suppliedAdapters?: WakeAdapter[], deadline?: number): Promise<void>;
 export interface SweepPendingNotificationsOptions {
     env?: NodeJS.ProcessEnv;
     now?: number;

package/dist/notifications.js

@@ -14,6 +14,7 @@ import { projectPresentationEvidence } from './square-projections.js';
 import { createHostLedgerPort } from './host-ledger-file-adapter.js';
 export { planActNotifications, matchesMentionTarget };
 export { notificationMessageId } from './delivery.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);
     if (!Number.isFinite(value) || value <= 0) {
@@ -116,12 +117,12 @@ export function createWakeTransport(adapters, hostLedger, clock) {
                 return { outcome: 'not-capable', diagnostic: error instanceof Error ? error.message : String(error) };
             }
         },
-        attempt: async (request, _timeoutMs) => {
+        attempt: async (request, timeoutMs) => {
             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 result = await adapter.dispatch(request.route.address, renderWakePayload(request), async () => true);
+                const result = await adapter.dispatch(request.route.address, renderWakePayload(request), async () => true, timeoutMs);
                 if (result.outcome === 'accepted')
                     return { outcome: 'accepted' };
                 if (result.outcome === 'failed')
@@ -161,8 +162,11 @@ export async function processActNotificationsOnce(squarePath, actIndex, opts = {
         await closeOpenSquare(square);
     }
 }
-/** Privileged hook fallback: sweep indexed squares plus the current cwd's local squares. */
-export async function sweepPrivilegedPending(cwd, env = process.env, suppliedAdapters) {
+/** 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) {
+    const remainingMs = () => Math.max(0, deadline - Date.now());
+    if (remainingMs() === 0)
+        return;
     const root = env.SQUARE_REGISTRY === undefined ? undefined : path.dirname(env.SQUARE_REGISTRY);
     const hostLedger = createHostLedgerPort({ userPath: env.SQUARE_HOST_LEDGER_USER ?? root, localPath: env.SQUARE_HOST_LEDGER_LOCAL ?? root, readableScopes: ['user'], writableScope: 'user' });
     let indexed = [];
@@ -178,19 +182,30 @@ export async function sweepPrivilegedPending(cwd, env = process.env, suppliedAda
         }
     }
     catch { /* no local square directory */ }
+    if (remainingMs() === 0)
+        return;
     const adapters = suppliedAdapters ?? await defaultWakeAdapters();
     for (const squarePath of paths) {
+        if (remainingMs() === 0)
+            break;
         try {
             const square = await openSquare(squarePath, { hostLedger, env });
             try {
-                const snapshot = await square.artifact.read();
                 await hostLedger.reconcileBinding({ artifact: square.artifact, scopes: ['user'], now: Date.now() }).catch(() => undefined);
+                if (remainingMs() === 0)
+                    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 transport = createWakeTransport(adapters, hostLedger, Date.now);
-                for (const actIndex of selected)
-                    await deliverPending({ artifact: square.artifact, hostLedger, transport, location: squarePath, activity: actIndex, timeoutMs: Number(env.SQUARE_NOTIFY_DELIVERY_WAIT_MS ?? 5000), now: Date.now() }).catch(() => undefined);
+                for (const actIndex of selected) {
+                    const remaining = remainingMs();
+                    if (remaining === 0)
+                        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);
+                }
             }
             finally {
                 await closeOpenSquare(square);

package/dist/paseo-delivery.d.ts

@@ -10,5 +10,5 @@ export declare class PaseoAdapter implements WakeAdapter {
     private readonly opts;
     readonly kind: "paseo";
     constructor(opts?: PaseoAdapterOptions);
-    dispatch(address: Readonly<Record<string, string>>, payload: string, beforeSend: () => Promise<boolean>): Promise<WakeDispatchResult>;
+    dispatch(address: Readonly<Record<string, string>>, payload: string, beforeSend: () => Promise<boolean>, timeoutMs?: number): Promise<WakeDispatchResult>;
 }

package/dist/paseo-delivery.js

@@ -30,7 +30,15 @@ export class PaseoAdapter {
     constructor(opts = {}) {
         this.opts = opts;
     }
-    async dispatch(address, payload, beforeSend) {
+    async dispatch(address, payload, beforeSend, timeoutMs = 5000) {
+        const deadline = Date.now() + timeoutMs;
+        const remainingMs = () => Math.max(0, deadline - Date.now());
+        const budgetUnavailable = () => ({
+            outcome: 'unavailable',
+            signature: 'dispatch_budget_exhausted',
+            message: 'The wake dispatch budget elapsed before Paseo accepted the wake.',
+            retainRoute: true,
+        });
         const agentId = address.agentId?.trim();
         if (!agentId) {
             return {
@@ -41,7 +49,10 @@ export class PaseoAdapter {
                 diagnostic: diagnostic('selection', address, 'invalid_address'),
             };
         }
-        const discovery = (this.opts.discover ?? discoverPaseoAgents)();
+        let remaining = remainingMs();
+        if (remaining === 0)
+            return budgetUnavailable();
+        const discovery = (this.opts.discover ?? discoverPaseoAgents)(remaining);
         if (discovery.error && discovery.agents.length === 0) {
             return {
                 outcome: 'unavailable',
@@ -62,7 +73,10 @@ export class PaseoAdapter {
                 ...(agent === undefined ? { routeStale: true } : {}),
             };
         }
-        if (!(await (this.opts.waitForBoundary ?? waitForPaseoWakeBoundary)(agent))) {
+        remaining = remainingMs();
+        if (remaining === 0)
+            return budgetUnavailable();
+        if (!(await (this.opts.waitForBoundary ?? waitForPaseoWakeBoundary)(agent, remaining))) {
             return {
                 outcome: 'unavailable',
                 signature: 'boundary_unavailable',
@@ -73,8 +87,11 @@ export class PaseoAdapter {
         }
         if (!(await beforeSend()))
             return { outcome: 'cancelled' };
+        remaining = remainingMs();
+        if (remaining === 0)
+            return budgetUnavailable();
         try {
-            (this.opts.sendWake ?? sendPaseoWake)({ agentId, prompt: payload });
+            (this.opts.sendWake ?? sendPaseoWake)({ agentId, prompt: payload }, { timeoutMs: remaining });
             return { outcome: 'accepted' };
         }
         catch (error) {

package/dist/paseo-state.d.ts

@@ -8,4 +8,4 @@ export declare function discoverPaseoAgents(timeoutMs?: number): {
     agents: PaseoAgent[];
     error?: string;
 };
-export declare function waitForPaseoWakeBoundary(agent: Pick<PaseoAgent, 'id' | 'status'>): Promise<boolean>;
+export declare function waitForPaseoWakeBoundary(agent: Pick<PaseoAgent, 'id' | 'status'>, timeoutMs?: number): Promise<boolean>;

package/dist/paseo-state.js

@@ -22,10 +22,10 @@ export function discoverPaseoAgents(timeoutMs = 5000) {
         return { agents: [], error: error instanceof Error ? error.message : String(error) };
     }
 }
-export async function waitForPaseoWakeBoundary(agent) {
+export async function waitForPaseoWakeBoundary(agent, timeoutMs = 30_000) {
     if (agent.status === 'idle')
         return true;
     if (agent.status !== 'running')
         return false;
-    return waitForPaseoToolBoundary(agent.id);
+    return waitForPaseoToolBoundary(agent.id, { timeoutMs });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrosheep/square",
-  "version": "0.3.32",
+  "version": "0.3.33",
   "description": "A shared public square where agents join, catch activity, express, and step out when done.",
   "type": "module",
   "bin": {