@astrosheep/square 0.4.0 → 0.4.2

package/dist/harness.js

@@ -1,6 +1,4 @@
-import fs from 'node:fs';
-import { doctorDeliveryHealth } from './delivery-health.js';
-import { wakeGraceMs } from './notifications.js';
+import { DeliveryLedger, deliveryLedgerLocation } from './delivery-ledger.js';
 import { truncateExternalDiagnostic } from './presentation.js';
 import { doctorClaudePlugin, installClaudePlugin, uninstallClaudePlugin, } from './harness-claude.js';
 import { doctorCodexPlugin, installCodexPlugin, uninstallCodexPlugin, } from './harness-codex.js';
@@ -18,16 +16,6 @@ async function doctorHost(label, inspect) {
         return result([`○ ${label} doctor unavailable (${truncateExternalDiagnostic(diagnostic)})`]);
     }
 }
-function readableSquarePath(squarePath) {
-    if (squarePath === undefined)
-        return false;
-    try {
-        return fs.statSync(squarePath).isFile() && (fs.accessSync(squarePath, fs.constants.R_OK), true);
-    }
-    catch {
-        return false;
-    }
-}
 const TARGETS = [
     {
         name: 'claude',
@@ -78,10 +66,17 @@ const TARGETS = [
     {
         name: 'delivery',
         capabilities: ['doctor'],
-        async doctor({ squarePath }) {
-            return result(readableSquarePath(squarePath)
-                ? await doctorDeliveryHealth(squarePath, wakeGraceMs())
-                : ['○ delivery health skipped (no readable square path)']);
+        async doctor({ homeDir }) {
+            return doctorHost('delivery', async () => {
+                const ledger = await DeliveryLedger.open({ location: deliveryLedgerLocation(process.env, homeDir) });
+                try {
+                    const health = await ledger.health();
+                    return [`· delivery health · ${health.unknownAttempts.length} unknown attempts · ${health.repeatedFailures.length} repeated failures · ${health.sessionsWithoutRoute.length} sessions without route`];
+                }
+                finally {
+                    await ledger.close();
+                }
+            });
         },
     },
 ];

package/dist/help.js

@@ -58,7 +58,10 @@ const COMMANDS = [
         details: ['Options:', '  --for-owner <id>    Required opaque owner.', '  --limit <N>         Snapshot memberships (default 20, maximum 100).'],
     },
     { names: ['codex-hook'], usage: '{command}', summary: 'Present pending attention at one native agent boundary.', hiddenFromIndex: true },
-    { names: ['claude-mod'], usage: '{command}', summary: 'Receive a structured operation from the loaded Claude mod.', hiddenFromIndex: true },
+    { names: ['codex-watch'], usage: '{command}', summary: 'Observe pending attention from a native async Stop hook.', hiddenFromIndex: true },
+    { names: ['codex-interrupt'], usage: '{command}', summary: 'Cancel pending attention at a native Interrupt boundary.', hiddenFromIndex: true },
+    { names: ['claude-hook'], usage: '{command}', summary: 'Receive a native Claude hook event.', hiddenFromIndex: true },
+    { names: ['claude-watch'], usage: '{command}', summary: 'Observe pending attention from a native async Stop hook.', hiddenFromIndex: true },
     {
         names: ['history'], usage: 'history [filters] [output]', usesSquare: true, group: 'participant',
         summary: 'Read or search the archive without changing what you have caught.',

package/dist/http-delivery.d.ts

@@ -1,16 +1,12 @@
-import type { WakeRoute } from './channel-values.js';
-import type { WakeOutcome, WakeRequest, WakeTransportPort } from './channel-transport.js';
+import type { DeliveryCard, DeliveryTransport, DeliveryTransportContext, TransportOutcome } from './delivery-ledger.js';
 export interface HttpWakeTransportOptions {
     fetch?: typeof fetch;
     env?: NodeJS.ProcessEnv;
 }
-/** HTTP accepts wake custody only; it never consumes or presents Square activity. */
-export declare class HttpWakeTransport implements WakeTransportPort {
+/** A successful HTTP response acknowledges custody, not presentation. */
+export declare class HttpWakeTransport implements DeliveryTransport {
     private readonly opts;
+    readonly kind = "http";
     constructor(opts?: HttpWakeTransportOptions);
-    probe(route: WakeRoute): Promise<boolean | {
-        outcome: 'not-capable';
-        diagnostic: string;
-    }>;
-    attempt(request: WakeRequest, timeoutMs: number, beforeSend: () => Promise<boolean>): Promise<WakeOutcome>;
+    send(card: DeliveryCard, address: Readonly<Record<string, string>>, context: DeliveryTransportContext): Promise<TransportOutcome>;
 }

package/dist/http-delivery.js

@@ -1,99 +1,42 @@
-/** Configuration only: probing never contacts the receiver. */
-function configuration(route, env) {
-    if (route.kind !== 'http')
-        return undefined;
+function configuration(address, env) {
     try {
-        const url = new URL(route.address.url);
-        if (!['http:', 'https:'].includes(url.protocol) || !url.hostname || url.username || url.password
-            || route.address.url.includes('#'))
+        const url = new URL(address.url);
+        if (!['http:', 'https:'].includes(url.protocol) || !url.hostname || url.username || url.password || address.url.includes('#'))
             return undefined;
         const headers = new Headers({ 'Content-Type': 'application/json' });
-        const tokenEnv = route.address.tokenEnv;
-        if (tokenEnv !== undefined) {
-            const token = tokenEnv.trim() ? env[tokenEnv] : undefined;
-            // RFC 6750 bearer credentials; whitespace/control characters cannot become headers.
+        if (address.tokenEnv !== undefined) {
+            const token = address.tokenEnv.trim() ? env[address.tokenEnv] : undefined;
             if (!token || token !== token.trim() || !/^[A-Za-z0-9._~+\/-]+=*$/.test(token))
                 return undefined;
             headers.set('Authorization', `Bearer ${token}`);
         }
-        return { url: route.address.url, headers };
+        return { url: address.url, headers };
     }
     catch {
         return undefined;
     }
 }
-/** HTTP accepts wake custody only; it never consumes or presents Square activity. */
+/** A successful HTTP response acknowledges custody, not presentation. */
 export class HttpWakeTransport {
     opts;
+    kind = 'http';
     constructor(opts = {}) {
         this.opts = opts;
     }
-    async probe(route) {
-        return configuration(route, this.opts.env ?? process.env) !== undefined
-            ? true : { outcome: 'not-capable', diagnostic: 'HTTP wake configuration unavailable.' };
-    }
-    async attempt(request, timeoutMs, beforeSend) {
-        const deadline = Date.now() + timeoutMs;
-        if (request.route.kind !== 'http')
-            return { outcome: 'not-capable' };
-        const config = configuration(request.route, this.opts.env ?? process.env);
-        if (config === undefined)
-            return { outcome: 'failed', signature: 'http_config_rejected', message: 'Invalid HTTP wake configuration.' };
-        const controller = new AbortController();
-        let sent = false;
-        const budgetUnavailable = () => sent
-            ? { outcome: 'unknown', signature: 'http_send_timeout', message: 'HTTP wake acceptance is unknown after timeout.' }
-            : { outcome: 'failed', signature: 'http_pre_send_timeout', message: 'HTTP wake budget elapsed before sending.' };
-        if (!Number.isFinite(timeoutMs) || Date.now() >= deadline)
-            return budgetUnavailable();
-        let timer;
-        const timeout = new Promise(resolve => {
-            timer = setTimeout(() => { controller.abort(); resolve(budgetUnavailable()); }, Math.max(0, deadline - Date.now()));
-        });
-        const send = async () => {
-            try {
-                const preview = request.presentation?.payload;
-                if (preview === undefined)
-                    return { outcome: 'not-capable', diagnostic: 'No pending Square activity to preview.' };
-                const body = JSON.stringify({
-                    location: request.location, participant: request.participant, message: request.message, actor: request.actor,
-                    ...(request.attemptN === undefined ? {} : { attemptN: request.attemptN }), preview,
-                });
-                if (controller.signal.aborted || Date.now() >= deadline)
-                    return budgetUnavailable();
-                if (!(await beforeSend()))
-                    return { outcome: 'not-capable' };
-                // Preview and the final gate spend the same absolute budget as the request.
-                if (controller.signal.aborted || Date.now() >= deadline)
-                    return budgetUnavailable();
-                sent = true;
-                const response = await (this.opts.fetch ?? fetch)(config.url, {
-                    method: 'POST', headers: config.headers, body, redirect: 'manual', signal: controller.signal,
-                });
-                // Status is the whole acknowledgement; never wait for or buffer a receiver body.
-                void response.body?.cancel().catch(() => undefined);
-                if (response.status >= 200 && response.status < 300)
-                    return { outcome: 'accepted', signature: 'http_accepted' };
-                return {
-                    outcome: 'failed', signature: response.status >= 500 && response.status < 600 ? 'http_status_transient' : 'http_status_rejected',
-                    message: `HTTP wake returned status ${response.status}.`,
-                };
-            }
-            catch {
-                // URLs, query credentials and raw fetch exceptions must never reach evidence.
-                if (controller.signal.aborted)
-                    return budgetUnavailable();
-                return sent
-                    ? { outcome: 'unknown', signature: 'http_send_unknown', message: 'HTTP wake acceptance is unknown after a network error.' }
-                    : { outcome: 'failed', signature: 'http_pre_send_failed', message: 'HTTP wake could not be prepared.' };
-            }
-        };
+    async send(card, address, context) {
+        const config = configuration(address, this.opts.env ?? process.env);
+        if (!config)
+            return 'not-capable';
+        if (!await context.beforeSend() || context.signal.aborted || Date.now() >= context.deadline)
+            return 'not-capable';
         try {
-            return await Promise.race([send(), timeout]);
+            const response = await (this.opts.fetch ?? fetch)(config.url, { method: 'POST', headers: config.headers,
+                body: JSON.stringify({ owner: card.owner, key: card.key, text: card.text }), redirect: 'manual', signal: context.signal });
+            void response.body?.cancel().catch(() => undefined);
+            return response.status >= 200 && response.status < 300 ? 'accepted' : 'failed';
         }
-        finally {
-            if (timer !== undefined)
-                clearTimeout(timer);
+        catch {
+            return 'unknown';
         }
     }
 }

package/dist/inbox.d.ts

@@ -1,50 +1,7 @@
-import { type Owner, type LocatedSeat, type PendingMembership } from './model.js';
-import type { SquareRead } from './ports.js';
-import { type NativePendingInput } from './delivery.js';
-export interface PendingWaitOptions {
-    signal?: AbortSignal;
-    /** Local delivery suppression, never persisted as evidence of receipt. */
-    excludeKeys?: ReadonlySet<string>;
-    /** Arm before dispatch; retry only after a substantive change, not our failed evidence write. */
-    skipImmediate?: boolean;
-    onChangeArmed?: (armed: boolean) => void;
-}
-export declare function pendingKey(membership: LocatedSeat, messageIndex: number): string;
-/** Revalidate a supplied batch immediately before the boundary's independent claim/send checks. */
-export declare function projectBoundaryEligibility(inbox: readonly PendingMembership[]): Promise<PendingMembership[]>;
-export interface SessionBindingCandidate {
-    readonly location: string;
+import type { Owner } from './model.js';
+import type { InboxMembershipSummary } from './square-facade.js';
+/** Filesystem-scoped membership counts. This is a World read, not a delivery scan. */
+export declare function sessionInboxCounts(input: {
     readonly owner: Owner;
-}
-/** HOME is a candidate path index; current seats and delivery evidence live in the artifact. */
-export declare function projectSessionCandidates(input: SessionSeatQuery): Promise<readonly SessionBindingCandidate[]>;
-export interface SessionSeatQuery {
-    readonly owner?: Owner;
-    readonly location?: string;
-    readonly env?: NodeJS.ProcessEnv;
-}
-/** Lifecycle reads resolve seats and join times, never pending activity bodies. */
-export declare function projectSessionSeats(input: SessionSeatQuery, signal?: AbortSignal): Promise<LocatedSeat[]>;
-/** Public count boundary: one coherent read per artifact, without pending body hydration. */
-export declare function sessionInboxCounts(input: SessionSeatQuery, signal?: AbortSignal): Promise<import('./square-facade.js').InboxMembershipSummary[]>;
-export interface NativePendingPreview {
-    readonly payload: string;
-    readonly clipped: boolean;
-}
-export interface NativePendingSource {
-    readonly text: string;
-    readonly clipped: boolean;
-}
-/** One current eligibility + source projection read; senders use text, ACK coverage uses clipped. */
-export declare function nativePendingSource(facts: SquareRead, input: NativePendingInput): NativePendingSource | undefined;
-/** The sender-facing fixed reminder over the shared source projection. */
-export declare function nativePendingPreview(facts: SquareRead, input: NativePendingInput): NativePendingPreview | undefined;
-export declare function sessionInbox(owner: Owner, env?: NodeJS.ProcessEnv, signal?: AbortSignal): Promise<PendingMembership[]>;
-export interface SessionPendingObserver {
-    /** Read committed revisions before reusing content; filesystem hints are only for waiting. */
-    read(options?: Pick<PendingWaitOptions, 'signal' | 'excludeKeys'>): Promise<PendingMembership[]>;
-    wait(timeoutMs: number, options?: PendingWaitOptions): Promise<PendingMembership[]>;
-    close(): void;
-}
-/** Session-scoped projection over process-shared storage change detectors. */
-export declare function observeSessionPending(owner: Owner, suppliedEnv?: NodeJS.ProcessEnv): Promise<SessionPendingObserver>;
+    readonly cwd?: string;
+}, signal?: AbortSignal): Promise<InboxMembershipSummary[]>;