@astrosheep/square 0.3.90 → 0.3.92

package/dist/cli/context.js

@@ -1,4 +1,5 @@
 import os from 'node:os';
+import { codexWakeAddress } from '../codex-address.js';
 import { commandUsageHint } from '../help.js';
 import { parseParticipantList, validateName } from '../model.js';
 import { Square, squareClock } from '../square-api.js';
@@ -161,7 +162,7 @@ function commandIdentity(env) {
         return {};
     const body = { channel: selected.channel, session: selected.session };
     const wakeAddress = selected.channel === 'codex'
-        ? { kind: 'codex-queue', address: { threadId: selected.session } }
+        ? codexWakeAddress(selected.session, env)
         : paseo === undefined ? undefined : { kind: 'paseo', address: { agentId: paseo.session } };
     return { body, ...(wakeAddress === undefined ? {} : { wakeAddress }) };
 }

package/dist/cli/maintenance-commands.js

@@ -10,10 +10,13 @@ export const migrateCommand = {
     async execute(_intent, context) {
         const squarePath = requireSquarePath(context);
         const outcome = await migrateSquare(squareInput(context));
-        const body = outcome.status === 'migrated' && outcome.counts !== undefined
+        const body = outcome.status === 'migrated'
             ? [
                 '✓ migrated to current row storage',
-                `  · ${outcome.counts.activities} activities · ${outcome.counts.receipts} receipts · ${outcome.counts.leases} leases · ${outcome.counts.routes} routes`,
+                ...(outcome.counts === undefined ? [] : [
+                    `  · ${outcome.counts.activities} activities · ${outcome.counts.receipts} receipts · ${outcome.counts.leases} leases · ${outcome.counts.routes} routes`,
+                    `  · ${outcome.counts.recoveredSeats} recovered seats · ${outcome.counts.unownedStanding} unowned standing · ${outcome.counts.sharedBodySeats} shared-body seats · ${outcome.counts.skippedEvidence} skipped evidence`,
+                ]),
             ].join('\n')
             : '· already current format — nothing changed';
         return { output: withPathOutput(squarePath, body, { participantCount: outcome.standing }) };

package/dist/codex-address.d.ts

@@ -0,0 +1,3 @@
+import type { WakeAddress } from './model.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;

package/dist/codex-address.js

@@ -0,0 +1,8 @@
+import { resolveCodexHome } from './packages/agent-delivery/src/codex-endpoint.js';
+/** Capture the receiver's CLI configuration when its seat is established, not at send time. */
+export function codexWakeAddress(threadId, env) {
+    const endpoint = env.SQUARE_CODEX_ENDPOINT?.trim();
+    return { kind: 'codex-queue', address: {
+            threadId, codexHome: resolveCodexHome(env), ...(endpoint ? { endpoint } : {}),
+        } };
+}

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

@@ -1,8 +1,6 @@
-export interface CodexBoundary {
-    lastStop: number;
-    lastNonStop: number;
-}
-export declare function readCodexBoundary(threadId: string, env?: NodeJS.ProcessEnv): Promise<CodexBoundary | undefined>;
-export declare function codexQueueEligible(threadId: string, env?: NodeJS.ProcessEnv): Promise<boolean>;
-export declare function recordCodexBoundary(threadId: string, event: 'Stop' | 'non-stop', env?: NodeJS.ProcessEnv, signal?: AbortSignal): Promise<void>;
-export declare function clearCodexBoundary(threadId: string, env?: NodeJS.ProcessEnv, signal?: AbortSignal): Promise<void>;
+export type { CodexBoundary } 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

@@ -1,87 +1,10 @@
-import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { withFileLock } from './file-lock.js';
-function statePath(env = process.env) {
-    return env.SQUARE_CODEX_BOUNDARIES || path.join(os.homedir(), '.square', 'codex-boundaries.json');
-}
-function lockPath(filePath) {
-    return `${filePath}.lock`;
-}
-function emptyFile() {
-    return { v: 1, nextSequence: 0, threads: {} };
-}
-async function readFile(filePath) {
-    let raw;
-    try {
-        raw = await fs.promises.readFile(filePath, 'utf8');
-    }
-    catch (error) {
-        if (error.code === 'ENOENT')
-            return emptyFile();
-        throw error;
-    }
-    try {
-        const value = JSON.parse(raw);
-        if (value.v !== 1 || typeof value.nextSequence !== 'number' || !Number.isSafeInteger(value.nextSequence) || value.nextSequence < 0 || value.threads === null || typeof value.threads !== 'object')
-            return emptyFile();
-        const nextSequence = value.nextSequence;
-        const threads = {};
-        for (const [threadId, boundary] of Object.entries(value.threads)) {
-            if (boundary === null || typeof boundary !== 'object')
-                continue;
-            const item = boundary;
-            const lastStop = item.lastStop;
-            const lastNonStop = item.lastNonStop;
-            if (typeof lastStop === 'number' && Number.isSafeInteger(lastStop) && lastStop >= 0 && typeof lastNonStop === 'number' && Number.isSafeInteger(lastNonStop) && lastNonStop >= 0) {
-                threads[threadId] = { lastStop, lastNonStop };
-            }
-        }
-        return { v: 1, nextSequence, threads };
-    }
-    catch {
-        return emptyFile();
-    }
-}
-async function writeFile(filePath, value) {
-    await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
-    const temporary = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-    await fs.promises.writeFile(temporary, `${JSON.stringify(value)}\n`, { mode: 0o600 });
-    await fs.promises.rename(temporary, filePath);
-}
-export async function readCodexBoundary(threadId, env = process.env) {
-    if (!threadId)
-        return undefined;
-    const filePath = statePath(env);
-    return (await readFile(filePath)).threads[threadId];
-}
-export async function codexQueueEligible(threadId, env = process.env) {
-    const boundary = await readCodexBoundary(threadId, env);
-    return boundary !== undefined && boundary.lastStop > boundary.lastNonStop;
-}
-export async function recordCodexBoundary(threadId, event, env = process.env, signal) {
-    if (!threadId)
-        return;
-    const filePath = statePath(env);
-    await withFileLock(lockPath(filePath), { retryMs: 10, signal }, async () => {
-        const value = await readFile(filePath);
-        value.nextSequence += 1;
-        const current = value.threads[threadId] ?? { lastStop: 0, lastNonStop: 0 };
-        value.threads[threadId] = event === 'Stop'
-            ? { ...current, lastStop: value.nextSequence }
-            : { ...current, lastNonStop: value.nextSequence };
-        await writeFile(filePath, value);
-    });
-}
-export async function clearCodexBoundary(threadId, env = process.env, signal) {
-    if (!threadId)
-        return;
-    const filePath = statePath(env);
-    await withFileLock(lockPath(filePath), { retryMs: 10, signal }, async () => {
-        const value = await readFile(filePath);
-        if (!(threadId in value.threads))
-            return;
-        delete value.threads[threadId];
-        await writeFile(filePath, value);
-    });
-}
+import { createCodexBoundaryStore } from './packages/agent-delivery/src/codex-boundary.js';
+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

@@ -7,9 +7,7 @@ export interface CodexHookInput {
     source?: unknown;
 }
 export type HookTrace = (line: string) => void;
-/** Overall hook budget: Codex kills the hook at its configured 5s timeout, so the hook must
- * bound every wait/retry itself and exit with a readable stage trace before that. */
 export declare const CODEX_HOOK_BUDGET_MS = 4500;
 export declare function codexHookResponse(input: CodexHookInput, lookup?: (identity: Body, 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>;
-export declare function runCodexHookAsync(inputText: string, env?: NodeJS.ProcessEnv): Promise<string>;
+export declare const runCodexHookAsync: typeof runCodexHook;

package/dist/codex-hook.js

@@ -1,59 +1,29 @@
+import { handleCodexHook } from './packages/agent-delivery/src/codex-hook.js';
 import { presentPendingAtBoundary } from './boundary-presentation.js';
 import { sessionInbox } from './inbox.js';
 import { endSessionMemberships } from './session-lifecycle.js';
-import { clearCodexBoundary, recordCodexBoundary } from './codex-boundary-state.js';
+import { codexBoundaryStore } from './codex-boundary-state.js';
 import { PRIVILEGED_HOOK_BUDGET_MS, sweepPrivilegedPending } from './notifications.js';
-/** Overall hook budget: Codex kills the hook at its configured 5s timeout, so the hook must
- * bound every wait/retry itself and exit with a readable stage trace before that. */
 export const CODEX_HOOK_BUDGET_MS = 4500;
-const CODEX_HOOK_EVENTS = {
-    PostToolUse: 'PostToolUse',
-    Stop: 'Stop',
-};
 const defaultTrace = (line) => { process.stderr.write(`${line}\n`); };
-function hookBudgetMs(env) {
-    const configured = Number(env.SQUARE_CODEX_HOOK_BUDGET_MS ?? CODEX_HOOK_BUDGET_MS);
-    return Number.isFinite(configured) && configured > 0 ? configured : CODEX_HOOK_BUDGET_MS;
-}
 export async function codexHookResponse(input, lookup = sessionInbox, env = process.env, deliveryTransports, trace = defaultTrace) {
-    if (typeof input.session_id !== 'string' || input.session_id === '')
-        return undefined;
-    if (typeof input.hook_event_name !== 'string')
-        return undefined;
-    const hookEventName = CODEX_HOOK_EVENTS[input.hook_event_name];
-    if (hookEventName === undefined)
-        return undefined;
-    // Per-stage timings, emitted as each stage completes so a killed hook still leaves a trace.
+    const configured = Number(env.SQUARE_CODEX_HOOK_BUDGET_MS ?? CODEX_HOOK_BUDGET_MS);
     const startedAt = Date.now();
     let mark = startedAt;
-    const stage = (name, extra = '') => {
-        const now = Date.now();
-        const durationMs = now - mark;
-        mark = now;
-        trace(`square-codex-hook: stage=${name} durationMs=${durationMs} totalMs=${now - startedAt}${extra === '' ? '' : ` ${extra}`}`);
-    };
-    const signal = AbortSignal.timeout(hookBudgetMs(env));
-    const sweepDeadline = Date.now() + Math.min(PRIVILEGED_HOOK_BUDGET_MS, hookBudgetMs(env));
-    const cwd = typeof input.cwd === 'string' ? input.cwd : process.cwd();
-    await recordCodexBoundary(input.session_id, hookEventName === 'Stop' ? 'Stop' : 'non-stop', env, signal);
-    stage('boundary-record');
-    if (hookEventName === 'Stop') {
-        await sweepPrivilegedPending(cwd, env, deliveryTransports, sweepDeadline, signal).catch(() => undefined);
-        stage('sweep', signal.aborted ? 'aborted=true' : '');
-        return undefined;
-    }
-    let response;
-    try {
-        response = await presentPendingAtBoundary({ channel: 'codex', session: input.session_id }, (context) => ({ hookSpecificOutput: { hookEventName: 'PostToolUse', additionalContext: context } }), lookup, env, signal);
-        stage('presentation', signal.aborted ? 'aborted=true' : '');
-    }
-    catch (error) {
-        stage('presentation', `error=${error instanceof Error ? error.name : String(error)}`);
-        response = undefined;
-    }
-    await sweepPrivilegedPending(cwd, env, deliveryTransports, sweepDeadline, signal).catch(() => undefined);
-    stage('sweep', signal.aborted ? 'aborted=true' : '');
-    return response;
+    return handleCodexHook(input, {
+        boundaries: codexBoundaryStore(env),
+        timeoutMs: Number.isFinite(configured) && configured > 0 ? configured : CODEX_HOOK_BUDGET_MS,
+        sweepTimeoutMs: PRIVILEGED_HOOK_BUDGET_MS,
+        pull: (id, signal) => presentPendingAtBoundary({ 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 endSessionMemberships('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}` : ''}`);
+        },
+    });
 }
 export async function runCodexHook(inputText, env = process.env) {
     let input;
@@ -65,33 +35,7 @@ export async function runCodexHook(inputText, env = process.env) {
     }
     if (input === null || typeof input !== 'object')
         return '';
-    const response = await codexHookResponse(input, sessionInbox, env);
-    return response === undefined ? '' : `${JSON.stringify(response)}\n`;
-}
-export async function runCodexHookAsync(inputText, env = process.env) {
-    let input;
-    try {
-        input = JSON.parse(inputText);
-    }
-    catch {
-        return '';
-    }
-    if (input === null || typeof input !== 'object')
-        return '';
-    const value = input;
-    if (typeof value.session_id !== 'string')
-        return runCodexHook(inputText, env);
-    if (value.hook_event_name === 'SessionStart' || value.hook_event_name === 'SessionResume') {
-        await recordCodexBoundary(value.session_id, 'non-stop', env, AbortSignal.timeout(hookBudgetMs(env)));
-        return '';
-    }
-    if (value.hook_event_name === 'SessionEnd') {
-        await clearCodexBoundary(value.session_id, env, AbortSignal.timeout(hookBudgetMs(env)));
-        try {
-            await endSessionMemberships('codex', value.session_id, env);
-        }
-        catch { /* end remains bounded */ }
-        return '';
-    }
-    return runCodexHook(inputText, env);
+    const result = await codexHookResponse(input, sessionInbox, env);
+    return result === undefined ? '' : `${JSON.stringify(result)}\n`;
 }
+export const runCodexHookAsync = runCodexHook;

package/dist/codex-queue.d.ts

@@ -1,23 +1,11 @@
+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 './ports.js';
-import { type WakeRoute } from './model.js';
-export interface CodexQueueRequest {
-    threadId: string;
-    message: string;
-}
-export type CodexQueueFailureKind = 'transient' | 'rejected' | 'unknown';
-export declare class CodexQueueSendError extends Error {
-    readonly kind: CodexQueueFailureKind;
-    constructor(message: string, kind: CodexQueueFailureKind);
-}
-export declare function sendCodexQueue({ threadId, message }: CodexQueueRequest, opts?: {
-    args?: string[];
-    bin?: string;
-    env?: NodeJS.ProcessEnv;
-    timeoutMs?: number;
-}): void;
+import type { WakeRoute } from './model.js';
 export interface CodexQueueTransportOptions {
     env?: NodeJS.ProcessEnv;
-    sendQueue?: typeof sendCodexQueue;
+    connect?: (options: CodexCliConnectOptions) => Promise<CodexCliAgent>;
 }
 export declare class CodexQueueTransport implements WakeTransportPort {
     private readonly opts;

package/dist/codex-queue.js

@@ -1,36 +1,7 @@
-import { spawnSync } from 'node:child_process';
-import { codexQueueEligible } from './codex-boundary-state.js';
+import { connect, DeliveryError } from './packages/agent-delivery/src/index.js';
+export { sendCodexQueue, CodexQueueSendError } from './packages/agent-delivery/src/codex-queue.js';
+import { codexBoundaryStore } from './codex-boundary-state.js';
 import { wakePreview } from './delivery.js';
-export class CodexQueueSendError extends Error {
-    kind;
-    constructor(message, kind) {
-        super(message);
-        this.kind = kind;
-        this.name = 'CodexQueueSendError';
-    }
-}
-function classifyFailure(message) {
-    if (/ENOENT|not found.*executable|ECONNREFUSED|timed out|timeout/i.test(message))
-        return 'transient';
-    if (/invalid|unknown thread|not found|rejected|permission|auth/i.test(message))
-        return 'rejected';
-    return 'unknown';
-}
-export function sendCodexQueue({ threadId, message }, opts = {}) {
-    // The explicit bin wins. Otherwise a supplied env decides the executable and the child
-    // environment; it never falls back to the ambient process env for a key it omits.
-    const env = opts.env ?? process.env;
-    const result = spawnSync(opts.bin ?? env.SQUARE_CODEX_BIN ?? 'codex', [...(opts.args ?? []), 'queue', '--thread', threadId, '--message', message], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], timeout: opts.timeoutMs ?? 5000, env });
-    if (result.error) {
-        const messageText = result.error.message;
-        throw new CodexQueueSendError(messageText, classifyFailure(messageText));
-    }
-    if (result.status === 0)
-        return;
-    const output = `${result.stderr ?? ''}${result.stdout ?? ''}`.trim();
-    const messageText = output || `codex queue exited with ${result.status ?? 'no status'}`;
-    throw new CodexQueueSendError(messageText, classifyFailure(messageText));
-}
 export class CodexQueueTransport {
     opts;
     constructor(opts = {}) {
@@ -38,54 +9,40 @@ export class CodexQueueTransport {
     }
     async attempt(request, timeoutMs, beforeSend) {
         const deadline = Date.now() + timeoutMs;
-        const remainingMs = () => Math.max(0, deadline - Date.now());
-        const threadId = request.route.address.threadId?.trim();
+        const { address } = request.route;
+        const threadId = address.threadId?.trim();
         if (!threadId) {
             return { outcome: 'failed', unavailable: true, signature: 'invalid_address', message: 'Codex route has no thread id.', routeStale: true };
         }
         const env = this.opts.env ?? process.env;
-        if (!await codexQueueEligible(threadId, env)) {
-            return {
-                outcome: 'failed',
-                unavailable: true,
-                signature: 'boundary_not_stopped',
-                message: 'The Codex thread has not reached a current Stop boundary.',
-                retainRoute: true,
-            };
-        }
         const payload = request.artifact === undefined ? undefined
             : (await request.artifact.read((facts) => wakePreview(facts, request))).value;
         if (payload === undefined)
             return { outcome: 'not-capable', diagnostic: 'No pending Square activity to preview.' };
         if (!(await beforeSend()))
             return { outcome: 'not-capable' };
-        if (!await codexQueueEligible(threadId, env)) {
-            return {
-                outcome: 'failed',
-                unavailable: true,
-                signature: 'boundary_not_stopped',
-                message: 'The Codex thread left its Stop boundary before queueing.',
-                retainRoute: true,
-            };
-        }
-        const remaining = remainingMs();
-        if (remaining === 0) {
-            return { outcome: 'failed', unavailable: true, signature: 'dispatch_budget_exhausted', message: 'The wake dispatch budget elapsed before queueing.', retainRoute: true };
-        }
         try {
-            (this.opts.sendQueue ?? sendCodexQueue)({ threadId, message: payload }, { env, timeoutMs: remaining });
+            const agent = await (this.opts.connect ?? connect)({
+                harness: 'codex', transport: 'cli', sessionId: threadId, boundaries: codexBoundaryStore(env),
+                env, bin: env.SQUARE_CODEX_BIN, codexHome: address.codexHome, endpoint: address.endpoint,
+            });
+            const remaining = deadline - Date.now();
+            if (remaining <= 0) {
+                return { outcome: 'failed', unavailable: true, signature: 'dispatch_budget_exhausted', message: 'The wake dispatch budget elapsed before queueing.', retainRoute: true };
+            }
+            await agent.queue(payload, { timeoutMs: remaining });
             return { outcome: 'accepted' };
         }
         catch (error) {
+            if (error instanceof DeliveryError && error.code === 'session_inactive') {
+                return { outcome: 'failed', unavailable: true, signature: 'boundary_not_stopped',
+                    message: 'The Codex thread has no current Stop boundary for queueing.', retainRoute: true };
+            }
             const message = error instanceof Error ? error.message : String(error);
-            const kind = error instanceof CodexQueueSendError ? error.kind : 'unknown';
-            if (kind === 'unknown')
+            if (!(error instanceof DeliveryError) || error.maybeDelivered)
                 return { outcome: 'unknown', signature: 'queue_unknown', message };
-            return {
-                outcome: 'failed',
-                signature: kind === 'transient' ? 'queue_pre_accept_transient' : 'queue_pre_accept_rejected',
-                message,
-            };
+            return { outcome: 'failed', signature: ['unavailable', 'timeout', 'aborted'].includes(error.code)
+                    ? 'queue_pre_accept_transient' : 'queue_pre_accept_rejected', message };
         }
     }
 }

package/dist/file-lock.d.ts

@@ -1,17 +1 @@
-export interface FileLockOptions {
-    retryMs: number;
-    signal?: AbortSignal;
-    createParent?: boolean;
-    /** Optional discovery may skip a busy lock; ordinary lock users still wait. */
-    skipIfBusy?: boolean;
-}
-export declare class FileLockError extends Error {
-    readonly code: "not_a_database";
-    constructor(lockPath: string, cause?: unknown);
-}
-export declare function withFileLock<T>(lockPath: string, options: FileLockOptions & {
-    skipIfBusy: true;
-}, fn: () => T | Promise<T>): Promise<T | undefined>;
-export declare function withFileLock<T>(lockPath: string, options: FileLockOptions & {
-    skipIfBusy?: false;
-}, fn: () => T | Promise<T>): Promise<T>;
+export { withFileLock, FileLockError, type FileLockOptions } from './packages/agent-delivery/src/file-lock.js';

package/dist/file-lock.js

@@ -1,64 +1 @@
-import { DatabaseSync } from 'node:sqlite';
-import { promises as fs } from 'node:fs';
-import path from 'node:path';
-import { setTimeout as sleep } from 'node:timers/promises';
-export class FileLockError extends Error {
-    code = 'not_a_database';
-    constructor(lockPath, cause) {
-        super(`File lock is not a database: ${lockPath}`);
-        this.name = 'FileLockError';
-        if (cause !== undefined)
-            this.cause = cause;
-    }
-}
-function isBusy(error) {
-    return error instanceof Error && /database is locked|SQLITE_BUSY/i.test(error.message);
-}
-function isNotADatabase(error) {
-    return error instanceof Error && /not a database|file is not a database/i.test(error.message);
-}
-export async function withFileLock(lockPath, options, fn) {
-    if (options.createParent !== false)
-        await fs.mkdir(path.dirname(lockPath), { recursive: true });
-    while (true) {
-        if (options.signal?.aborted)
-            throw options.signal.reason ?? new Error('File lock acquisition aborted');
-        let database;
-        try {
-            database = new DatabaseSync(lockPath);
-            database.exec(`PRAGMA busy_timeout = 0;
-        BEGIN EXCLUSIVE;
-        CREATE TABLE IF NOT EXISTS __square_file_lock (id INTEGER PRIMARY KEY CHECK (id = 1));`);
-        }
-        catch (error) {
-            try {
-                database?.close();
-            }
-            catch { }
-            if (isBusy(error)) {
-                if (options.skipIfBusy)
-                    return undefined;
-                await sleep(options.retryMs, undefined, { signal: options.signal });
-                continue;
-            }
-            if (isNotADatabase(error))
-                throw new FileLockError(lockPath, error);
-            throw error;
-        }
-        try {
-            const result = await fn();
-            database.exec('COMMIT;');
-            return result;
-        }
-        catch (error) {
-            try {
-                database.exec('ROLLBACK;');
-            }
-            catch { }
-            throw error;
-        }
-        finally {
-            database.close();
-        }
-    }
-}
+export { withFileLock, FileLockError } from './packages/agent-delivery/src/file-lock.js';

package/dist/help.js

@@ -92,8 +92,8 @@ const COMMANDS = [
     },
     {
         names: ['migrate'], usage: 'migrate', usesSquare: true, group: 'maintenance',
-        summary: 'Convert an existing version 2 or 3 square to current format 4 in place.',
-        details: ['For the selected .square artifact only. Stop sessions using this artifact before conversion. Back up the stopped artifact, migrate it, then run square --location <path> doctor before starting updated clients.', 'A version 2 or 3 square is accepted; version 1, unrelated or unsupported artifacts are refused without a write. There is no --check, --backup or --force.'],
+        summary: 'Convert a supported older square to the current format in place.',
+        details: ['For the selected .square artifact only. Stop sessions using this artifact before conversion. Back up the stopped artifact, migrate it, then run square --location <path> doctor before starting updated clients.', 'Versions 2, 3 and 4 are accepted; version 1, unrelated or unsupported artifacts are refused without a write. Names whose own owner and route evidence agrees may share a body; names with missing or conflicting ownership stay standing without write or delivery authority. Migration reports recovered seats, unowned standing names, shared-body seats and skipped evidence. There is no --check, --backup or --force.'],
     },
 ];
 function definitionFor(command) {

package/dist/mcp.js

@@ -2,6 +2,7 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { SQUARE_TOOLS, SQUARE_TOOL_INSTRUCTIONS, squareToolFailure, squareToolFailureText } from './square-tools.js';
 import { operationEnv } from './participant-identity.js';
+import { codexWakeAddress } from './codex-address.js';
 import { readClaudeMcpCall } from './claude-mcp-context.js';
 import { SQUARE_IDENTITY } from './identity.js';
 import { Square, createSquareResourceOwner } from './square-api.js';
@@ -46,7 +47,7 @@ export function createSquareMcpServer(options) {
                         ...options, env, body, cwd: claude?.cwd ?? options.cwd,
                         // A call-local Codex thread uses its native queue even when managed by Paseo.
                         wakeAddress: claude === undefined && typeof threadId === 'string' && threadId.trim()
-                            ? { kind: 'codex-queue', address: { threadId } } : options.wakeAddress,
+                            ? codexWakeAddress(threadId, env) : options.wakeAddress,
                         path: location ?? options.path,
                         participant: participant ?? options.participant,
                         // The server owner is bound to its configured square; overrides close after each call.

package/dist/packages/agent-delivery/src/codex-boundary.d.ts

@@ -0,0 +1,13 @@
+export interface CodexBoundary {
+    readonly lastStop: number;
+    readonly lastNonStop: number;
+    readonly ended?: true;
+}
+export interface CodexBoundaryStore {
+    read(sessionId: string): Promise<CodexBoundary | undefined>;
+    queueEligible(sessionId: string): Promise<boolean>;
+    record(sessionId: string, event: 'Stop' | 'non-stop' | 'start' | 'end', signal?: AbortSignal): Promise<void>;
+    clear(sessionId: string, signal?: AbortSignal): Promise<void>;
+}
+/** Caller-owned observation file, shared by independent hook and sender processes. */
+export declare function createCodexBoundaryStore(file: string): CodexBoundaryStore;

package/dist/packages/agent-delivery/src/codex-boundary.js

@@ -0,0 +1,75 @@
+import { promises as fs } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { withFileLock } from './file-lock.js';
+const empty = () => ({ v: 1, nextSequence: 0, threads: Object.create(null) });
+/** Caller-owned observation file, shared by independent hook and sender processes. */
+export function createCodexBoundaryStore(file) {
+    const load = async () => {
+        let raw;
+        try {
+            raw = await fs.readFile(file, 'utf8');
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return empty();
+            throw error;
+        }
+        try {
+            const value = JSON.parse(raw);
+            if (value?.v !== 1 || !Number.isSafeInteger(value.nextSequence) || value.nextSequence < 0 ||
+                !value.threads || typeof value.threads !== 'object')
+                return empty();
+            const result = empty();
+            result.nextSequence = value.nextSequence;
+            for (const [id, boundary] of Object.entries(value.threads)) {
+                const item = boundary;
+                if (item && Number.isSafeInteger(item.lastStop) && item.lastStop >= 0 &&
+                    Number.isSafeInteger(item.lastNonStop) && item.lastNonStop >= 0)
+                    result.threads[id] = item;
+            }
+            return result;
+        }
+        catch {
+            return empty();
+        }
+    };
+    const update = (change, signal) => withFileLock(`${file}.lock`, { retryMs: 10, signal }, async () => {
+        const state = await load();
+        change(state);
+        signal?.throwIfAborted();
+        const temporary = `${file}.${randomUUID()}.tmp`;
+        try {
+            await fs.writeFile(temporary, JSON.stringify(state), { mode: 0o600 });
+            await fs.rename(temporary, file);
+        }
+        finally {
+            await fs.unlink(temporary).catch(() => { });
+        }
+    });
+    const read = async (id) => id ? (await load()).threads[id] : undefined;
+    return {
+        read,
+        async queueEligible(id) {
+            const boundary = await read(id);
+            return boundary !== undefined && boundary.ended !== true && boundary.lastStop > boundary.lastNonStop;
+        },
+        async record(id, event, signal) {
+            if (!id)
+                return;
+            await update((state) => {
+                const previous = state.threads[id] ?? { lastStop: 0, lastNonStop: 0 };
+                // A late Stop/tool callback must not reopen an ended session.
+                if (previous.ended && event !== 'start')
+                    return;
+                state.nextSequence += 1;
+                state.threads[id] = event === 'start'
+                    ? { lastStop: 0, lastNonStop: state.nextSequence }
+                    : event === 'end' ? { ...previous, lastNonStop: state.nextSequence, ended: true }
+                        : event === 'Stop' ? { ...previous, lastStop: state.nextSequence }
+                            : { ...previous, lastNonStop: state.nextSequence };
+            }, signal);
+        },
+        async clear(id, signal) { if (id)
+            await update((state) => { delete state.threads[id]; }, signal); },
+    };
+}