@astrosheep/square 0.4.0 → 0.4.1

package/dist/claude-mod.js

@@ -1,20 +1,8 @@
-import { operationEnv } from './participant-identity.js';
-import { channelArtifact, createArtifactPort } from './artifact.js';
-import { recordClaudeDeliveryStatus } from './claude-delivery-status.js';
-import { Square } from './square-api.js';
 import { observeClaudeDelivery } from './claude-delivery.js';
-import { processActNotificationsOnce } from './notifications.js';
-import { sweepPending } from './delivery-operations.js';
 import { beginClaudeMcpCall, endClaudeMcpCall } from './claude-mcp-context.js';
-import { asSeatRef } from './seats.js';
-import { projectSessionSeats } from './inbox.js';
-import { restoreSessionSeats } from './session-lifecycle.js';
+import { DeliveryLedger } from './delivery-ledger.js';
+import { attachDeliverySessionRoutes, detachDeliverySession } from './session-lifecycle.js';
 import { harnessOwner } from './owner.js';
-import { InternalSquareError, SquareError } from './model.js';
-/** Persisted hook state keeps its wire coordinate; internal consumers keep the located seat. */
-function claudeBinding({ location, seat }, sessionId) {
-    return { location, participant: seat.participant, session: sessionId, generation: seat.generation };
-}
 /** JSON stdin bridge. Identity is explicit per operation; process.env is never rewritten. */
 export async function runClaudeMod(inputText, env = process.env) {
     if (inputText.length > 512_000)
@@ -22,10 +10,6 @@ export async function runClaudeMod(inputText, env = process.env) {
     const input = JSON.parse(inputText);
     if (!input || typeof input.sessionId !== 'string' || !input.sessionId || typeof input.cwd !== 'string')
         throw new Error('Claude bridge coordinate missing.');
-    if (input.operation === 'status') {
-        const recorded = input.status?.sessionId === input.sessionId && await recordClaudeDeliveryStatus(input.status, env);
-        return `${JSON.stringify({ recorded })}\n`;
-    }
     if (input.operation === 'tool-begin') {
         return `${JSON.stringify(await beginClaudeMcpCall({ toolUseId: input.toolUseId, sessionId: input.sessionId, cwd: input.cwd, agentId: input.agentId }, env))}\n`;
     }
@@ -33,140 +17,44 @@ export async function runClaudeMod(inputText, env = process.env) {
         await endClaudeMcpCall(input.toolUseId, input.token, env);
         return '{}\n';
     }
-    const scoped = operationEnv('claude', input.sessionId, env);
-    const signal = AbortSignal.timeout(2500);
     const owner = harnessOwner({ channel: 'claude-code', session: input.sessionId, ...(input.agentId === undefined ? {} : { agent: input.agentId }) });
     const supported = process.platform === 'darwin' && typeof input.endpoint === 'string' && input.endpoint.startsWith('/');
-    const sessionSeats = async () => (await projectSessionSeats({ owner, env }, signal)).filter(member => member.seat.attachment === 'attached');
-    if (input.operation === 'end') {
-        const retired = [];
-        const captured = [...input.bindings ?? []];
-        // Discover committed late joins at the pinned end boundary, never later owners.
-        if (input.endedAt !== undefined)
-            for (const member of await projectSessionSeats({ owner, env }, signal)) {
-                if (member.joinedAt > input.endedAt || captured.some((item) => item.location === member.location
-                    && item.participant === member.seat.participant && item.generation === member.seat.generation))
-                    continue;
-                captured.push(claudeBinding(member, input.sessionId));
-            }
-        for (const binding of captured) {
-            if (binding.session !== input.sessionId)
-                continue;
-            const square = await Square.at({ path: binding.location, env: scoped });
+    const routes = supported ? [{ kind: 'claude-native', address: { sessionId: input.sessionId, endpoint: input.endpoint, version: input.version, platform: 'darwin', loaded: 'true' } }] : [];
+    const captured = input.bindings?.find(binding => binding.session === input.sessionId)?.generation;
+    if (input.operation === 'start') {
+        const session = await attachDeliverySessionRoutes(owner, env, routes, AbortSignal.timeout(2500));
+        if (session && !supported && session.routes.some(route => route.kind === 'claude-native')) {
+            const ledger = await DeliveryLedger.open({ location: env.SQUARE_DELIVERY });
             try {
-                const detached = binding.generation === undefined ? null
-                    : await square.detach(binding.participant, { owner, generation: binding.generation });
-                if (detached)
-                    retired.push(binding);
+                await ledger.updateRoutes({ owner, generation: session.generation, routes: session.routes.filter(route => route.kind !== 'claude-native') });
             }
             finally {
-                await square.close();
+                await ledger.close();
             }
-            if (signal.aborted)
-                break;
         }
-        return `${JSON.stringify({ retired })}\n`;
+        return `${JSON.stringify({ available: supported, diagnostic: supported ? undefined : 'Native inbox unavailable: requires macOS Claude with an interactive loaded mod and its real endpoint.', bindings: session ? [{ session: input.sessionId, generation: session.generation }] : [] })}\n`;
     }
-    const recovery = new Set();
-    const cancelledBindings = [...input.cancelledBindings ?? []];
-    if (input.operation === 'start') {
-        await restoreSessionSeats(owner, scoped, supported ? {
-            kind: 'claude-native', address: { sessionId: input.sessionId, endpoint: input.endpoint, version: input.version, platform: 'darwin', loaded: 'true' },
-        } : undefined, signal);
+    if (input.operation === 'end') {
+        const retired = captured && await detachDeliverySession(owner, captured, env);
+        return `${JSON.stringify({ retired: retired ? input.bindings : [] })}\n`;
     }
-    if (input.operation === 'start' || input.operation === 'reconcile' || input.operation === 'cancel' || input.cancelAt !== undefined) {
-        for (const member of await sessionSeats()) {
-            if (signal.aborted)
-                break;
-            const { location, seat: capturedSeat, joinedAt } = member;
-            const matches = (item) => item !== undefined
-                && item.location === location && item.participant === capturedSeat.participant && item.session === input.sessionId
-                && (item.generation === undefined || item.generation === capturedSeat.generation);
-            const expected = input.bindings?.find(matches);
-            const cancelled = input.cancelledBindings?.find(matches) ?? (input.operation === 'cancel' ? expected : undefined);
-            const lateCancelledJoin = input.operation === 'cancel' && input.cancelAt !== undefined
-                && joinedAt <= input.cancelAt && expected === undefined;
-            if (lateCancelledJoin && !cancelledBindings.some(matches))
-                cancelledBindings.push(claudeBinding(member, input.sessionId));
-            if (input.operation !== 'start' && input.operation !== 'reconcile' && !lateCancelledJoin && expected === undefined)
-                continue;
-            const artifact = createArtifactPort(location, undefined, signal);
-            try {
-                const { value: currentSeat } = await artifact.read((facts) => facts.seat(capturedSeat.participant), signal);
-                if (currentSeat === undefined || currentSeat.attachment !== 'attached' || currentSeat.generation !== capturedSeat.generation
-                    || currentSeat.owner !== capturedSeat.owner)
-                    continue;
-                const seat = asSeatRef(currentSeat);
-                const existing = currentSeat.wakeAddress?.kind === 'claude-native' ? currentSeat.wakeAddress : undefined;
-                const cutoff = input.cancelAt !== undefined && (cancelled !== undefined || lateCancelledJoin) ? input.cancelAt : undefined;
-                if (cutoff !== undefined) {
-                    const { value: through } = await artifact.read((facts) => {
-                        let beforeIndex;
-                        for (;;) {
-                            const page = facts.activityHeads({ beforeIndex }, { edge: 'newest', limit: 100 });
-                            const last = page.items.find((activity) => activity.at <= cutoff && activity.messageIndex !== undefined);
-                            if (last !== undefined)
-                                return last.messageIndex;
-                            if (!page.hasMore)
-                                return -1;
-                            beforeIndex = page.items[0].index;
-                        }
-                    }, signal);
-                    if (through >= 0)
-                        await artifact.cancelDeliveries(seat, through, signal);
-                }
-                if (!supported) {
-                    if (existing !== undefined)
-                        await artifact.transactAs({ kind: 'participant', seat }, (facts) => facts.updateWakeAddress(seat, undefined), signal);
-                    continue;
-                }
-                if (existing === undefined || existing.address.endpoint !== input.endpoint)
-                    recovery.add(location);
-                await artifact.transactAs({ kind: 'participant', seat }, (facts) => facts.updateWakeAddress(seat, {
-                    kind: 'claude-native', address: { sessionId: input.sessionId, endpoint: input.endpoint, version: input.version, platform: 'darwin', loaded: 'true' },
-                }), signal);
-            }
-            catch (error) {
-                if (error instanceof InternalSquareError && error.code === 'not_found')
-                    throw new SquareError('unavailable', `Square is unavailable at ${location}`);
-                throw error;
-            }
-            finally {
-                await artifact.close();
+    if (input.operation === 'reconcile' || input.operation === 'cancel') {
+        const ledger = await DeliveryLedger.open({ location: env.SQUARE_DELIVERY });
+        try {
+            const session = await ledger.session(owner);
+            if (captured && session?.generation === captured && session.state === 'attached') {
+                if (input.operation === 'cancel')
+                    await ledger.cancel({ owner, generation: captured });
+                else
+                    await ledger.updateRoutes({ owner, generation: captured, routes: [...session.routes.filter(route => route.kind !== 'claude-native'), ...routes] });
             }
+            return `${JSON.stringify({ available: supported, diagnostic: supported ? undefined : 'Native inbox unavailable: requires macOS Claude with an interactive loaded mod and its real endpoint.', bindings: input.bindings ?? [], cancelledBindings: input.bindings ?? [] })}\n`;
+        }
+        finally {
+            await ledger.close();
         }
-    }
-    if (input.operation === 'start' || input.operation === 'reconcile' || input.operation === 'cancel') {
-        const members = await sessionSeats();
-        // One startup recovery pass for known unsent work. Unknown/admitted sends never replay.
-        if (supported && input.operation !== 'cancel')
-            for (const { location } of members) {
-                if (signal.aborted)
-                    break;
-                if (input.operation !== 'start' && !recovery.has(location))
-                    continue;
-                const artifact = createArtifactPort(location, undefined, signal);
-                let indices;
-                try {
-                    indices = await sweepPending({ artifact: channelArtifact(artifact), location, now: Date.now(), graceMs: 0, limit: 8 });
-                }
-                catch (error) {
-                    if (error instanceof InternalSquareError && error.code === 'not_found')
-                        throw new SquareError('unavailable', `Square is unavailable at ${location}`);
-                    throw error;
-                }
-                finally {
-                    await artifact.close();
-                }
-                for (const index of indices) {
-                    if (signal.aborted)
-                        break;
-                    await processActNotificationsOnce(location, index, { env: { ...env, SQUARE_NOTIFY_DELIVERY_WAIT_MS: '200' } });
-                }
-            }
-        return `${JSON.stringify({ available: supported, diagnostic: supported ? undefined : 'Native inbox unavailable: requires macOS Claude with an interactive loaded mod and its real endpoint.', bindings: members.map(member => claudeBinding(member, input.sessionId)), cancelledBindings })}\n`;
     }
     if (!['guard', 'admitted', 'stored'].includes(input.operation) || typeof input.text !== 'string')
         throw new Error('Unknown Claude bridge operation.');
-    return `${JSON.stringify(await observeClaudeDelivery(input.sessionId, input.text, input.operation, env))}\n`;
+    return `${JSON.stringify(await observeClaudeDelivery(input.sessionId, input.text, input.operation, env, input.refs))}\n`;
 }

package/dist/claude-transport.d.ts

@@ -1,5 +1,5 @@
-import type { WakeTransportPort } from './channel-transport.js';
+import type { DeliveryTransport } from './delivery-ledger.js';
 export declare function nativeTokens(text: string): string[];
-export declare function nativePayload(token: string, preview: string): string;
+export declare function nativePayload(token: string, text: string): string;
 export declare function hashPayload(payload: string): string;
-export declare function createClaudeWakeTransport(env?: NodeJS.ProcessEnv): WakeTransportPort;
+export declare function createClaudeWakeTransport(env?: NodeJS.ProcessEnv): DeliveryTransport;

package/dist/claude-transport.js

@@ -1,58 +1,34 @@
 import { stat } from 'node:fs/promises';
 import { createHash, randomUUID } from 'node:crypto';
+import { renderDeliveryReminder } from './delivery-frame.js';
 import { writeClaudeNative } from './packages/agent-delivery/src/claude-native.js';
 const marker = /(?:^|\n)\[square-inbox:([a-zA-Z0-9-]+)\](?:\n|$)/g;
-export function nativeTokens(text) { return [...text.matchAll(marker)].map((match) => match[1]); }
-export function nativePayload(token, preview) { return `[square-inbox:${token}]\n${preview}\n[/square-inbox:${token}]`; }
-function nativeSupported(route) { return route.address.loaded === 'true' && !!route.address.endpoint; }
-export function hashPayload(payload) { return createHash('sha256').update(payload).digest('hex'); }
-async function preview(request) {
-    return request.presentation;
-}
-async function writeClaudeWake(sessionId, endpoint, messageId, payload, timeoutMs, signal) {
-    const result = await writeClaudeNative({ sessionId, endpoint, messageId }, payload, { deadline: Date.now() + timeoutMs, signal });
-    if (result.outcome === 'unavailable')
-        return { outcome: 'failed', signature: 'claude_endpoint_unavailable', message: result.message };
-    return { outcome: 'unknown', signature: 'native_admission_unconfirmed', message: result.outcome === 'written' ? 'Claude accepted the local write; native admission is unconfirmed.' : result.message };
+export function nativeTokens(text) { return [...text.matchAll(marker)].map(match => match[1]); }
+export function nativePayload(token, text) {
+    return renderDeliveryReminder([`[square-inbox:${token}]\n${text}\n[/square-inbox:${token}]`], { tagged: false });
 }
+export function hashPayload(payload) { return createHash('sha256').update(payload).digest('hex'); }
 export function createClaudeWakeTransport(env = process.env) {
     return {
-        async probe(route) {
-            if (!nativeSupported(route))
-                return { outcome: 'not-capable', diagnostic: 'Claude native inbox unavailable: a loaded interactive Square mod is required.' };
+        kind: 'claude-native',
+        async send(card, address, context) {
+            if (address.loaded !== 'true' || !address.endpoint || !address.sessionId)
+                return 'not-capable';
             try {
-                return (await stat(route.address.endpoint)).isSocket() || { outcome: 'not-capable', diagnostic: 'Claude native inbox endpoint is not a socket.' };
+                if (!(await stat(address.endpoint)).isSocket())
+                    return 'not-capable';
             }
             catch {
-                return { outcome: 'not-capable', diagnostic: 'Claude native inbox endpoint unavailable.' };
+                return 'not-capable';
             }
+            const messageId = randomUUID();
+            const payload = nativePayload(context.token, card.text);
+            if (!await context.prepare({ token: context.token, messageId, payloadHash: hashPayload(payload) }))
+                return 'not-capable';
+            if (context.signal.aborted || Date.now() >= context.deadline)
+                return 'not-capable';
+            const result = await writeClaudeNative({ sessionId: address.sessionId, endpoint: address.endpoint, messageId, env }, payload, { deadline: context.deadline, signal: context.signal, beforeSend: context.beforeSend });
+            return result.outcome === 'unavailable' ? 'failed' : 'unknown';
         },
-        attempt: (request, timeoutMs, beforeSend) => dispatchClaude(request, timeoutMs, beforeSend, env),
     };
 }
-async function dispatchClaude(request, timeoutMs, beforeSend, env = process.env) {
-    void env;
-    const signal = AbortSignal.timeout(timeoutMs);
-    if (!nativeSupported(request.route) || request.claimToken === undefined)
-        return { outcome: 'not-capable', diagnostic: 'Claude native delivery needs a current artifact claim and loaded inbox.' };
-    if (signal.aborted || !await beforeSend())
-        return { outcome: 'unknown', signature: 'native_send_suppressed' };
-    const prepared = await preview(request);
-    if (prepared === undefined)
-        return { outcome: 'not-capable', diagnostic: 'Claude activity is no longer current.' };
-    const messageId = randomUUID();
-    const payload = nativePayload(request.claimToken, prepared.payload);
-    const correlation = { harness: 'claude', token: request.claimToken, messageId, payloadHash: hashPayload(payload) };
-    if (!await request.channel.prepare({ correlation, coverage: prepared.coverage,
-        ...(prepared.description === undefined ? {} : { description: prepared.description }) }))
-        return { outcome: 'not-capable', diagnostic: 'Claude delivery claim is no longer current.' };
-    const fresh = await preview(request);
-    if (fresh === undefined || nativePayload(request.claimToken, fresh.payload) !== payload)
-        return { outcome: 'not-capable', diagnostic: 'Claude activity changed before native write.' };
-    if (signal.aborted || !await beforeSend())
-        return { outcome: 'not-capable', diagnostic: 'Claude activity was consumed before native write.' };
-    const sessionId = request.route.address.sessionId;
-    if (sessionId === undefined)
-        return { outcome: 'not-capable', diagnostic: 'Claude native route has no session address.' };
-    return writeClaudeWake(sessionId, request.route.address.endpoint, messageId, payload, timeoutMs, signal);
-}

package/dist/cli/context.js

@@ -150,22 +150,20 @@ export function squareInput(context) {
 export function commandIdentity(env, explicit) {
     if (explicit !== undefined)
         return { owner: explicit };
-    const configured = env.SQUARE_OWNER;
-    if (configured !== undefined)
-        return { owner: configured };
-    const selected = harnessSessionSources.flatMap(({ variable, channel }) => env[variable]?.trim() ? [{ channel, session: env[variable].trim() }] : []);
-    const native = selected.filter(source => source.channel !== 'paseo');
+    if (env.SQUARE_OWNER !== undefined)
+        return { owner: env.SQUARE_OWNER };
     if (env.CLAUDE_CODE_CHILD_SESSION === '1')
         throw new Error('Harness identity is incomplete; provide --owner explicitly.');
+    const selected = harnessSessionSources.flatMap(({ variable, channel }) => env[variable]?.trim() ? [{ channel, session: env[variable].trim() }] : []);
+    const native = selected.filter(source => source.channel !== 'paseo');
     if (native.length > 1)
         throw new Error('Multiple harness execution coordinates are present; select one explicit owner.');
-    const paseo = selected.find(source => source.channel === 'paseo');
-    const coordinate = native[0] ?? paseo;
+    const coordinate = native[0] ?? selected[0];
     if (coordinate === undefined)
         return { owner: localUserOwner() };
     const owner = harnessOwner({ channel: coordinate.channel, session: coordinate.session });
-    const wakeAddress = coordinate.channel === 'codex' ? codexWakeAddress(coordinate.session, env)
-        : paseo === undefined ? undefined : { kind: 'paseo', address: { agentId: paseo.session } };
+    const wakeAddress = coordinate.channel === 'codex' ? { ...codexWakeAddress(coordinate.session, env), kind: 'codex-queue' }
+        : coordinate.channel === 'paseo' ? { kind: 'paseo', address: { agentId: coordinate.session } } : undefined;
     return { owner, ...(wakeAddress === undefined ? {} : { wakeAddress }) };
 }
 /** Adapter lifetime only; each callback uses the actual public resource API. */

package/dist/cli/observation-commands.d.ts

@@ -27,4 +27,6 @@ interface InboxIntent {
 export declare const inboxCommand: CommandSpec<InboxIntent, string>;
 export declare const claudeModCommand: CommandSpec<undefined, string>;
 export declare const codexHookCommand: CommandSpec<undefined, string>;
+export declare const codexWatchCommand: CommandSpec<undefined, string>;
+export declare const codexInterruptCommand: CommandSpec<undefined, string>;
 export {};

package/dist/cli/observation-commands.js

@@ -1,7 +1,8 @@
 import path from 'node:path';
 import { once } from 'node:events';
 import { runClaudeMod } from '../claude-mod.js';
-import { runCodexHook } from '../codex-hook.js';
+import { runCodexHook, runCodexInterrupt } from '../codex-hook.js';
+import { runCodexWatch } from '../codex-watch.js';
 import { isSquareError } from '../model.js';
 import { commandPrefix, participantIdentity, truncateChars, withPathOutput, quoteShell, } from '../presentation.js';
 import { PARTICIPANTS_DEFAULT_LIMIT, PARTICIPANTS_MAX_LIMIT, renderHistoryResult, renderParticipantsResult, renderStatusResult, } from '../operation-presentation.js';
@@ -526,4 +527,13 @@ function hookCommand(runHook) {
     };
 }
 export const claudeModCommand = hookCommand(runClaudeMod);
-export const codexHookCommand = hookCommand(runCodexHook);
+export const codexHookCommand = {
+    parse(argv, context) { if (argv.length > 0)
+        usage(context.command); return undefined; },
+    execute: async () => runCodexHook(await readStdin(), process.env, text => new Promise((resolve, reject) => {
+        process.stdout.write(text, error => error ? reject(error) : resolve());
+    })),
+    present: () => { },
+};
+export const codexWatchCommand = hookCommand(input => runCodexWatch(input, process.env));
+export const codexInterruptCommand = hookCommand(input => runCodexInterrupt(input, process.env));

package/dist/cli/registry.js

@@ -4,7 +4,7 @@ import { harnessCommand, installCommand, uninstallCommand } from './harness-comm
 import { helpCommand, versionCommand } from './meta-commands.js';
 import { mcpServerCommand } from './mcp-server-command.js';
 import { JSON_COMMANDS } from './json.js';
-import { catchCommand, claudeModCommand, codexHookCommand, historyCommand, inboxCommand, listCommand, participantsCommand, statusCommand, streamCommand, } from './observation-commands.js';
+import { catchCommand, claudeModCommand, codexHookCommand, codexWatchCommand, codexInterruptCommand, historyCommand, inboxCommand, listCommand, participantsCommand, statusCommand, streamCommand, } from './observation-commands.js';
 /** Every public command is an executable adapter, including aliases and utility commands. */
 export const commandRegistry = [
     { names: ['build'], spec: buildCommand },
@@ -14,6 +14,8 @@ export const commandRegistry = [
     { names: ['inbox'], spec: inboxCommand },
     { names: ['claude-mod'], spec: claudeModCommand },
     { names: ['codex-hook'], spec: codexHookCommand },
+    { names: ['codex-watch'], spec: codexWatchCommand },
+    { names: ['codex-interrupt'], spec: codexInterruptCommand },
     { names: ['catch'], spec: catchCommand },
     { names: ['express'], spec: expressCommand },
     { names: ['listen'], spec: listenCommand },

package/dist/codex-address.d.ts

@@ -1,3 +1,3 @@
-import type { WakeAddress } from './channel-values.js';
+import type { DeliveryRoute } from './delivery-ledger.js';
 /** Capture the receiver's CLI configuration when its seat is established, not at send time. */
-export declare function codexWakeAddress(threadId: string, env: NodeJS.ProcessEnv): WakeAddress;
+export declare function codexWakeAddress(threadId: string, env: NodeJS.ProcessEnv): DeliveryRoute;

package/dist/codex-boundary-state.d.ts

@@ -1,6 +1,2 @@
-export type { CodexBoundary } from './packages/agent-delivery/src/codex-boundary.js';
+export type { CodexBoundary, CodexStopEpoch } from './packages/agent-delivery/src/codex-boundary.js';
 export declare function codexBoundaryStore(env?: NodeJS.ProcessEnv): import("./packages/agent-delivery/src/codex-boundary.js").CodexBoundaryStore;
-export declare const readCodexBoundary: (id: string, env?: NodeJS.ProcessEnv) => Promise<import("./packages/agent-delivery/src/codex-boundary.js").CodexBoundary | undefined>;
-export declare const codexQueueEligible: (id: string, env?: NodeJS.ProcessEnv) => Promise<boolean>;
-export declare const recordCodexBoundary: (id: string, event: "Stop" | "non-stop" | "start" | "end", env?: NodeJS.ProcessEnv, signal?: AbortSignal) => Promise<void>;
-export declare const clearCodexBoundary: (id: string, env?: NodeJS.ProcessEnv, signal?: AbortSignal) => Promise<void>;

package/dist/codex-boundary-state.js

@@ -4,7 +4,3 @@ import { createCodexBoundaryStore } from './packages/agent-delivery/src/codex-bo
 export function codexBoundaryStore(env = process.env) {
     return createCodexBoundaryStore(env.SQUARE_CODEX_BOUNDARIES || path.join(os.homedir(), '.square', 'codex-boundaries.json'));
 }
-export const readCodexBoundary = (id, env) => codexBoundaryStore(env).read(id);
-export const codexQueueEligible = (id, env) => codexBoundaryStore(env).queueEligible(id);
-export const recordCodexBoundary = (id, event, env, signal) => codexBoundaryStore(env).record(id, event, signal);
-export const clearCodexBoundary = (id, env, signal) => codexBoundaryStore(env).clear(id, signal);

package/dist/codex-hook.d.ts

@@ -1,12 +1,9 @@
-import { type Owner } from './owner.js';
-import type { PendingMembership } from './model.js';
-import type { WakeTransports } from './notifications.js';
-export interface CodexHookInput {
-    session_id?: unknown;
-    hook_event_name?: unknown;
-    cwd?: unknown;
-}
+import { type CodexHookInput } from './packages/agent-delivery/src/codex-hook.js';
 export type HookTrace = (line: string) => void;
 export declare const CODEX_HOOK_BUDGET_MS = 4500;
-export declare function codexHookResponse(input: CodexHookInput, lookup?: (identity: Owner, env?: NodeJS.ProcessEnv, signal?: AbortSignal) => Promise<PendingMembership[]> | PendingMembership[], env?: NodeJS.ProcessEnv, deliveryTransports?: WakeTransports, trace?: HookTrace): Promise<object | undefined>;
-export declare function runCodexHook(inputText: string, env?: NodeJS.ProcessEnv): Promise<string>;
+/** sink resolves only after stdout has accepted the complete hook response. */
+export declare function codexHookResponse(value: unknown, sink: ((text: string) => void | Promise<void>) | undefined, env?: NodeJS.ProcessEnv, trace?: HookTrace): Promise<object | undefined>;
+export declare function parseCodexHookText(text: string): CodexHookInput | undefined;
+/** The caller owns stdout; no receipt is written when no output sink is supplied. */
+export declare function runCodexHook(inputText: string, env?: NodeJS.ProcessEnv, sink?: (text: string) => void | Promise<void>): Promise<string>;
+export declare function runCodexInterrupt(inputText: string, env?: NodeJS.ProcessEnv): Promise<string>;

package/dist/codex-hook.js

@@ -1,49 +1,85 @@
-import { handleCodexHook } from './packages/agent-delivery/src/codex-hook.js';
+import { handleCodexHook, parseCodexHook } from './packages/agent-delivery/src/codex-hook.js';
 import { presentPendingAtBoundary } from './boundary-presentation.js';
-import { sessionInbox } from './inbox.js';
+import { DeliveryLedger } from './delivery-ledger.js';
 import { harnessOwner } from './owner.js';
-import { detachSessionSeats, restoreSessionSeats } from './session-lifecycle.js';
+import { attachDeliverySessionRoutes, detachDeliverySession } from './session-lifecycle.js';
 import { codexBoundaryStore } from './codex-boundary-state.js';
 import { codexWakeAddress } from './codex-address.js';
-import { PRIVILEGED_HOOK_BUDGET_MS, sweepPrivilegedPending } from './notifications.js';
 export const CODEX_HOOK_BUDGET_MS = 4500;
-const defaultTrace = (line) => { process.stderr.write(`${line}\n`); };
-export async function codexHookResponse(input, lookup = sessionInbox, env = process.env, deliveryTransports, trace = defaultTrace) {
+const defaultTrace = line => { process.stderr.write(`${line}\n`); };
+/** sink resolves only after stdout has accepted the complete hook response. */
+export async function codexHookResponse(value, sink, env = process.env, trace = defaultTrace) {
+    const input = parseCodexHook(value);
+    if (!input)
+        return;
     const configured = Number(env.SQUARE_CODEX_HOOK_BUDGET_MS ?? CODEX_HOOK_BUDGET_MS);
-    const startedAt = Date.now();
-    let mark = startedAt;
-    const timeoutMs = Number.isFinite(configured) && configured > 0 ? configured : CODEX_HOOK_BUDGET_MS;
+    const timeoutMs = Math.min(input.hook_event_name === 'Interrupt' || input.hook_event_name === 'SessionEnd' ? 2500 : CODEX_HOOK_BUDGET_MS, Number.isFinite(configured) && configured > 0 ? configured : CODEX_HOOK_BUDGET_MS);
     const signal = AbortSignal.timeout(timeoutMs);
-    if ((input.hook_event_name === 'SessionStart' || input.hook_event_name === 'SessionResume')
-        && typeof input.session_id === 'string' && input.session_id.trim()) {
-        await restoreSessionSeats(harnessOwner({ channel: 'codex', session: input.session_id }), env, codexWakeAddress(input.session_id, env), signal);
+    const owner = harnessOwner({ channel: 'codex', session: input.session_id });
+    // Capture before any asynchronous boundary update; a replacement attachment
+    // must never inherit this callback's cancellation or detachment.
+    let generation;
+    if (input.hook_event_name === 'SessionEnd' || input.hook_event_name === 'Interrupt') {
+        const ledger = await DeliveryLedger.open({ location: env.SQUARE_DELIVERY });
+        try {
+            generation = (await ledger.session(owner))?.generation;
+        }
+        finally {
+            await ledger.close();
+        }
     }
-    return handleCodexHook(input, {
-        boundaries: codexBoundaryStore(env),
-        timeoutMs,
-        signal,
-        sweepTimeoutMs: PRIVILEGED_HOOK_BUDGET_MS,
-        pull: (id, signal) => presentPendingAtBoundary(harnessOwner({ channel: 'codex', session: id }), (context) => context, lookup, env, signal),
-        sweep: (cwd, deadline, signal) => sweepPrivilegedPending(cwd ?? process.cwd(), env, deliveryTransports, deadline, signal),
-        end: async (id) => { await detachSessionSeats('codex', id, env); },
-        trace: (name, detail = '') => {
-            const now = Date.now();
-            const durationMs = now - mark;
-            mark = now;
-            trace(`square-codex-hook: stage=${name} durationMs=${durationMs} totalMs=${now - startedAt}${detail ? ` ${detail}` : ''}`);
+    const result = await handleCodexHook(input, {
+        boundaries: codexBoundaryStore(env), timeoutMs, signal,
+        pull: async (_sessionId, pullSignal, event) => {
+            if (!sink)
+                return;
+            return presentPendingAtBoundary(owner, async (context) => {
+                await sink(`${JSON.stringify({ hookSpecificOutput: { hookEventName: event, additionalContext: context } })}\n`);
+                return context;
+            }, env, pullSignal);
         },
+        end: async () => { if (generation)
+            await detachDeliverySession(owner, generation, env); },
+        interrupt: async () => {
+            if (!generation || signal.aborted)
+                return;
+            const ledger = await DeliveryLedger.open({ location: env.SQUARE_DELIVERY });
+            try {
+                await ledger.cancel({ owner, generation });
+            }
+            finally {
+                await ledger.close();
+            }
+        },
+        trace: name => trace(`square-codex-hook: stage=${name}`),
     });
+    // Disarm before rotating the native attachment, even if there is no old session.
+    if (input.hook_event_name === 'SessionStart' && !signal.aborted)
+        await attachDeliverySessionRoutes(owner, env, [codexWakeAddress(input.session_id, env)], signal);
+    return result;
 }
-export async function runCodexHook(inputText, env = process.env) {
-    let input;
+export function parseCodexHookText(text) {
     try {
-        input = JSON.parse(inputText);
+        return parseCodexHook(JSON.parse(text));
     }
     catch {
-        return '';
+        return;
+    }
+}
+/** The caller owns stdout; no receipt is written when no output sink is supplied. */
+export async function runCodexHook(inputText, env = process.env, sink) {
+    await codexHookResponse(parseCodexHookText(inputText), sink, env);
+    return '';
+}
+export async function runCodexInterrupt(inputText, env = process.env) {
+    const input = parseCodexHookText(inputText);
+    if (input?.hook_event_name === 'Interrupt') {
+        try {
+            await codexHookResponse(input, undefined, env);
+        }
+        catch {
+            throw new Error('Codex interrupt unavailable.');
+        }
     }
-    if (input === null || typeof input !== 'object')
-        return '';
-    const result = await codexHookResponse(input, sessionInbox, env);
-    return result === undefined ? '' : `${JSON.stringify(result)}\n`;
+    return '';
 }

package/dist/codex-queue.d.ts

@@ -1,15 +1,14 @@
-import { type CodexCliAgent, type CodexCliConnectOptions } from './packages/agent-delivery/src/index.js';
-export { sendCodexQueue, CodexQueueSendError } from './packages/agent-delivery/src/codex-queue.js';
-export type { CodexQueueRequest, CodexQueueFailureKind } from './packages/agent-delivery/src/codex-queue.js';
-import type { WakeRequest, WakeOutcome, WakeTransportPort } from './channel-transport.js';
-import type { WakeRoute } from './channel-values.js';
+import { type CodexStopEpoch } from './codex-boundary-state.js';
+import type { DeliveryCard, DeliveryTransport, DeliveryTransportContext, TransportOutcome } from './delivery-ledger.js';
 export interface CodexQueueTransportOptions {
-    env?: NodeJS.ProcessEnv;
-    connect?: (options: CodexCliConnectOptions) => Promise<CodexCliAgent>;
+    readonly epoch: CodexStopEpoch;
+    readonly address: Readonly<Record<string, string>>;
+    readonly env?: NodeJS.ProcessEnv;
 }
-export declare class CodexQueueTransport implements WakeTransportPort {
+/** Instantiated only by the receiver, for one captured Stop epoch. */
+export declare class CodexQueueTransport implements DeliveryTransport {
     private readonly opts;
-    constructor(opts?: CodexQueueTransportOptions);
-    attempt(request: WakeRequest, timeoutMs: number, beforeSend: () => Promise<boolean>): Promise<WakeOutcome>;
+    readonly kind = "codex-queue";
+    constructor(opts: CodexQueueTransportOptions);
+    send(card: DeliveryCard, address: Readonly<Record<string, string>>, context: DeliveryTransportContext): Promise<TransportOutcome>;
 }
-export type { WakeRoute };