@astrosheep/square 0.3.27 → 0.3.29

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

@@ -1,6 +1,6 @@
 {
   "name": "square",
-  "version": "0.3.27",
+  "version": "0.3.29",
   "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.27",
+  "version": "0.3.29",
   "description": "Shared Square activity with reliable participant attention at Codex boundaries.",
   "author": {
     "name": "Square"

package/dist/artifact.d.ts

@@ -14,7 +14,7 @@ export declare function createSquareState(options: BuildOptions & {
 }, snippet: string): SquareState;
 export declare function encodeSquare(squareState: SquareState): Buffer;
 export declare function decodeSquare(bytes: Buffer): SquareState;
-export declare function writeSquareFile(squarePath: string, squareState: SquareState): void;
-export declare function loadSquare(squarePath: string): SquareState;
-export declare function probeSquare(squarePath: string): SquareState | undefined;
-export declare function diagnoseSquareFile(squarePath: string): DiagnoseResult;
+export declare function writeSquareFile(squarePath: string, squareState: SquareState): Promise<void>;
+export declare function loadSquare(squarePath: string): Promise<SquareState>;
+export declare function probeSquare(squarePath: string): Promise<SquareState | undefined>;
+export declare function diagnoseSquareFile(squarePath: string): Promise<DiagnoseResult>;

package/dist/artifact.js

@@ -10,6 +10,8 @@ const LENGTH_BYTES = 4;
 const DIGEST_BYTES = 32;
 const HEADER_BYTES = SQUARE_MAGIC.length + LENGTH_BYTES + DIGEST_BYTES;
 const utf8 = new TextDecoder('utf-8', { fatal: true });
+const guideNames = ['participant', 'architect', 'brainstorm'];
+const guideContents = new Map(await Promise.all(guideNames.map(async (name) => [name, (await fs.promises.readFile(new URL(`../guides/${name}.md`, import.meta.url), 'utf8')).trim()])));
 function invalidArtifact(detail) {
     return new SquareError('invalid_args', `Invalid square artifact: ${detail}`);
 }
@@ -260,7 +262,10 @@ function normalizedLines(value) {
 }
 function readGuide(name) {
     try {
-        return fs.readFileSync(new URL(`../guides/${name}.md`, import.meta.url), 'utf8').trim();
+        const guide = guideContents.get(name);
+        if (guide === undefined)
+            throw Object.assign(new Error('missing guide'), { code: 'ENOENT' });
+        return guide;
     }
     catch (error) {
         if (error.code === 'ENOENT') {
@@ -288,9 +293,9 @@ export function encodeSquare(squareState) {
 export function decodeSquare(bytes) {
     return validateSquareState(decodeEnvelope(bytes, SQUARE_MAGIC));
 }
-function readArtifact(squarePath) {
+async function readArtifact(squarePath) {
     try {
-        return fs.readFileSync(squarePath);
+        return await fs.promises.readFile(squarePath);
     }
     catch (error) {
         if (error.code === 'ENOENT') {
@@ -304,37 +309,37 @@ function requireSquareExtension(squarePath) {
         throw new SquareError('invalid_args', `Square artifacts must use the .square extension: ${squarePath}`);
     }
 }
-function atomicWrite(target, bytes) {
+async function atomicWrite(target, bytes) {
     const temporary = path.join(path.dirname(target), `.${path.basename(target)}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`);
-    fs.mkdirSync(path.dirname(target), { recursive: true });
+    await fs.promises.mkdir(path.dirname(target), { recursive: true });
     try {
-        fs.writeFileSync(temporary, bytes);
-        fs.renameSync(temporary, target);
+        await fs.promises.writeFile(temporary, bytes);
+        await fs.promises.rename(temporary, target);
     }
     catch (error) {
         try {
-            fs.unlinkSync(temporary);
+            await fs.promises.unlink(temporary);
         }
         catch { }
         throw error;
     }
 }
-export function writeSquareFile(squarePath, squareState) {
+export async function writeSquareFile(squarePath, squareState) {
     requireSquareExtension(squarePath);
-    atomicWrite(squarePath, encodeSquare(squareState));
+    await atomicWrite(squarePath, encodeSquare(squareState));
 }
-export function loadSquare(squarePath) {
+export async function loadSquare(squarePath) {
     requireSquareExtension(squarePath);
-    return decodeSquare(readArtifact(squarePath));
+    return decodeSquare(await readArtifact(squarePath));
 }
-export function probeSquare(squarePath) {
+export async function probeSquare(squarePath) {
     if (!squarePath.endsWith('.square'))
         return undefined;
     let descriptor;
     try {
-        descriptor = fs.openSync(squarePath, 'r');
+        descriptor = await fs.promises.open(squarePath, 'r');
         const magic = Buffer.alloc(SQUARE_MAGIC.length);
-        if (fs.readSync(descriptor, magic, 0, magic.length, 0) !== magic.length || !magic.equals(SQUARE_MAGIC)) {
+        if ((await descriptor.read(magic, 0, magic.length, 0)).bytesRead !== magic.length || !magic.equals(SQUARE_MAGIC)) {
             return undefined;
         }
     }
@@ -343,18 +348,18 @@ export function probeSquare(squarePath) {
     }
     finally {
         if (descriptor !== undefined)
-            fs.closeSync(descriptor);
+            await descriptor.close();
     }
     try {
-        return loadSquare(squarePath);
+        return await loadSquare(squarePath);
     }
     catch {
         return undefined;
     }
 }
-export function diagnoseSquareFile(squarePath) {
+export async function diagnoseSquareFile(squarePath) {
     try {
-        return { problems: [], state: loadSquare(squarePath) };
+        return { problems: [], state: await loadSquare(squarePath) };
     }
     catch (error) {
         return {

package/dist/automatic-session.js

@@ -1,4 +1,4 @@
-import fs from 'node:fs';
+import { promises as fs } from 'node:fs';
 import path from 'node:path';
 import { openSquare } from './square-file-adapter.js';
 import { closeOpenSquare } from './open-square.js';
@@ -16,9 +16,18 @@ const providerEnv = {
 export function publicSquarePath(cwd) {
     return path.join(cwd, '.square', 'PUBLIC.square');
 }
+async function squareExists(squarePath) {
+    try {
+        await fs.access(squarePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 export async function automaticSessionStart(provider, sessionId, cwd, env = process.env) {
     const squarePath = publicSquarePath(cwd);
-    if (!fs.existsSync(squarePath))
+    if (!await squareExists(squarePath))
         return undefined;
     let reader;
     try {
@@ -29,7 +38,8 @@ export async function automaticSessionStart(provider, sessionId, cwd, env = proc
         return undefined;
     }
     const name = automaticParticipant(provider, sessionId, env);
-    const alreadyBound = lookupSessionBindings(sessionId).some((binding) => canonicalSquarePath(binding.squarePath) === canonicalSquarePath(squarePath) && binding.name === name);
+    const canonicalPath = await canonicalSquarePath(squarePath);
+    const alreadyBound = (await lookupSessionBindings(sessionId)).some((binding) => binding.squarePath === canonicalPath && binding.name === name);
     await closeOpenSquare(reader);
     const square = await Square.at({ path: squarePath });
     try {
@@ -37,7 +47,7 @@ export async function automaticSessionStart(provider, sessionId, cwd, env = proc
         if (implicit.state === 'done' || (implicit.state === 'active' && alreadyBound))
             return undefined;
         const channel = provider === 'claude' ? 'claude-code' : provider;
-        recordSessionJoin(sessionId, name, squarePath, channel, { ...env, [providerEnv[provider]]: sessionId });
+        await recordSessionJoin(sessionId, name, squarePath, channel, { ...env, [providerEnv[provider]]: sessionId });
         return undefined;
     }
     finally {
@@ -47,8 +57,9 @@ export async function automaticSessionStart(provider, sessionId, cwd, env = proc
 export async function automaticSessionEnd(provider, sessionId, cwd, env = process.env) {
     const squarePath = publicSquarePath(cwd);
     const channel = provider === 'claude' ? 'claude-code' : provider;
-    const binding = lookupSessionBindings(sessionId).find((item) => canonicalSquarePath(item.squarePath) === canonicalSquarePath(squarePath) && item.channel === channel);
-    if (binding === undefined || !fs.existsSync(squarePath))
+    const canonicalPath = await canonicalSquarePath(squarePath);
+    const binding = (await lookupSessionBindings(sessionId)).find((item) => item.squarePath === canonicalPath && item.channel === channel);
+    if (binding === undefined || !await squareExists(squarePath))
         return;
     const reader = await openSquare(squarePath);
     const joined = await entryPresentation(reader, binding.name).finally(() => closeOpenSquare(reader));
@@ -62,5 +73,5 @@ export async function automaticSessionEnd(provider, sessionId, cwd, env = proces
     finally {
         await square.close();
     }
-    recordSessionDone(sessionId, binding.name, squarePath, channel, env);
+    await recordSessionDone(sessionId, binding.name, squarePath, channel, env);
 }

package/dist/boundary-presentation.d.ts

@@ -2,4 +2,4 @@ import type { InboxMembership } from './model.js';
 /** A fresh blocking catch owns only the notifications admitted by its filter. */
 export declare function pendingAtBoundary(inbox: InboxMembership[]): InboxMembership[];
 export declare function renderPendingAtBoundary(inbox: InboxMembership[]): string;
-export declare function presentPendingAtBoundary<T>(sessionId: string, present: (context: string) => T | Promise<T>, lookup?: (sessionId: string) => Promise<InboxMembership[]> | InboxMembership[], env?: NodeJS.ProcessEnv): Promise<T | undefined>;
+export declare function presentPendingAtBoundary<T>(sessionId: string, present: (context: string) => T | Promise<T>, lookup?: (sessionId: string) => Promise<InboxMembership[]> | InboxMembership[], env?: NodeJS.ProcessEnv, signal?: AbortSignal): Promise<T | undefined>;

package/dist/boundary-presentation.js

@@ -76,13 +76,13 @@ function renderBoundary(inbox) {
         complete,
     };
 }
-export async function presentPendingAtBoundary(sessionId, present, lookup = sessionInbox, env = process.env) {
+export async function presentPendingAtBoundary(sessionId, present, lookup = sessionInbox, env = process.env, signal) {
     const inbox = await lookup(sessionId);
     let delivered;
     const result = await presentOnce(sessionId, () => pendingAtBoundary(inbox), (inbox) => {
         delivered = renderBoundary(inbox);
         return present(delivered.context);
-    }, env);
+    }, env, Date.now(), signal);
     if (result !== undefined && delivered !== undefined) {
         for (const entry of delivered.complete) {
             await markBoundarySeen(entry.membership.squarePath, entry.membership.name, entry.membership.ownerId, entry.actIndexes);

package/dist/cli/context.d.ts

@@ -10,9 +10,9 @@ export interface CommandSpec<Intent = unknown, Result = void> {
     execute(intent: Intent, context: CommandContext): Promise<Result> | Result;
     present(result: Result, context: CommandContext): void;
 }
-export declare function readStdinSync(): string;
-export declare function resolveBody(arg: string): string;
-export declare function readPipedBodyFallback(): string | undefined;
+export declare function readStdin(): Promise<string>;
+export declare function resolveBody(arg: string): Promise<string>;
+export declare function readPipedBodyFallback(): Promise<string | undefined>;
 export declare function fail(message: string, exitCode?: number): never;
 export declare function usage(command: string): never;
 export declare function requireValue(args: string[], index: number, flag: string): string;
@@ -29,7 +29,7 @@ export interface ParsedGlobalArgs {
     name?: string;
     args: string[];
 }
-export declare function parseGlobalArgs(rawArgs: string[]): ParsedGlobalArgs;
+export declare function parseGlobalArgs(rawArgs: string[]): Promise<ParsedGlobalArgs>;
 export declare function locationIsRequired(command: string): boolean;
 export declare function defaultContext(command: string, squarePath?: string, name?: string): CommandContext;
 export declare function requireSquarePath(context: CommandContext): string;

package/dist/cli/context.js

@@ -1,23 +1,25 @@
-import fs from 'node:fs';
 import os from 'node:os';
 import { commandUsageHint } from '../help.js';
 import { parseParticipantList, validateName } from '../model.js';
 import { localParticipantName } from '../registry.js';
-export function readStdinSync() {
+export async function readStdin() {
     try {
-        return fs.readFileSync(0, 'utf8');
+        let content = '';
+        for await (const chunk of process.stdin.setEncoding('utf8'))
+            content += chunk;
+        return content;
     }
     catch {
         return '';
     }
 }
-export function resolveBody(arg) {
-    return arg === '-' ? readStdinSync() : arg;
+export async function resolveBody(arg) {
+    return arg === '-' ? readStdin() : arg;
 }
-export function readPipedBodyFallback() {
+export async function readPipedBodyFallback() {
     if (process.stdin.isTTY)
         return undefined;
-    const content = readStdinSync();
+    const content = await readStdin();
     return content.trim() === '' ? undefined : content;
 }
 export function fail(message, exitCode = 2) {
@@ -114,7 +116,7 @@ function configuredName() {
     validateName(value);
     return value;
 }
-export function parseGlobalArgs(rawArgs) {
+export async function parseGlobalArgs(rawArgs) {
     const args = [...rawArgs];
     let requestedPath;
     let name;
@@ -142,7 +144,7 @@ export function parseGlobalArgs(rawArgs) {
     }
     const squarePath = requestedPath ?? configured;
     if (name === undefined && squarePath !== undefined && command !== undefined && locationIsRequired(command)) {
-        name = localParticipantName(squarePath);
+        name = await localParticipantName(squarePath);
     }
     return { squarePath, explicitSquarePath: explicitSquarePath || configured !== undefined, multipleSquares: false, name, args };
 }

package/dist/cli/maintenance-commands.js

@@ -8,9 +8,9 @@ export const doctorCommand = {
             usage(context.command);
         return undefined;
     },
-    execute(_intent, context) {
+    async execute(_intent, context) {
         const squarePath = requireSquarePath(context);
-        const diagnosis = diagnoseSquareFile(squarePath);
+        const diagnosis = await diagnoseSquareFile(squarePath);
         if (diagnosis.unfixable !== undefined || diagnosis.state === undefined) {
             return {
                 output: withPathOutput(squarePath, renderDoctorUnfixable(diagnosis.unfixable ?? 'the snapshot could not be decoded')),

package/dist/cli/observation-commands.js

@@ -12,7 +12,7 @@ import { cmdWatch } from '../watch.js';
 import { openSquare } from '../square-file-adapter.js';
 import { closeOpenSquare } from '../open-square.js';
 import { historyPresentation, participantsPresentation, statusPresentation } from '../views.js';
-import { fail, parseDurationMs, parseNameList, parseNonNegativeInteger, readStdinSync, requireParticipant, requireSquarePath, requireValue, usage, } from './context.js';
+import { fail, parseDurationMs, parseNameList, parseNonNegativeInteger, readStdin, requireParticipant, requireSquarePath, requireValue, usage, } from './context.js';
 const STATUS_PARTICIPANT_PREVIEW_LIMIT = 10;
 export const listCommand = {
     parse: (argv) => argv,
@@ -470,7 +470,7 @@ function hookCommand(runHook) {
     return {
         parse(argv, context) { if (argv.length > 0)
             usage(context.command); return undefined; },
-        execute: () => runHook(readStdinSync()),
+        execute: async () => runHook(await readStdin()),
         present: (result) => process.stdout.write(result),
     };
 }

package/dist/cli/program.js

@@ -17,7 +17,7 @@ export async function runCli(rawArgs = process.argv.slice(2)) {
             await executeRegisteredCommand('help', requestedHelp.command === undefined ? [] : [requestedHelp.command], defaultContext('help'));
             return;
         }
-        const parsed = parseGlobalArgs(rawArgs);
+        const parsed = await parseGlobalArgs(rawArgs);
         if (parsed.args.length === 0 || parsed.args[0] === '--help' || parsed.args[0] === '-h') {
             await executeRegisteredCommand('help', [], defaultContext('help', parsed.squarePath, parsed.name));
             return;

package/dist/cli/square-commands.js

@@ -8,7 +8,7 @@ import { createSquare, openSquare } from '../square-file-adapter.js';
 import { closeOpenSquare } from '../open-square.js';
 import { openParticipant, Square } from '../square-wiring.js';
 import { entryPresentation, eventPresentation } from '../views.js';
-import { fail, parseHardCap, parsePositiveInteger, readPipedBodyFallback, readStdinSync, requireParticipant, requireSquarePath, requireValue, resolveBody, usage, } from './context.js';
+import { fail, parseHardCap, parsePositiveInteger, readStdin, requireParticipant, requireSquarePath, requireValue, resolveBody, usage, } from './context.js';
 function parseBuild(argv) {
     const options = { force: false, hardCap: null };
     for (let index = 0; index < argv.length; index++) {
@@ -41,16 +41,16 @@ function parseBuild(argv) {
     if (options.throttlePerMinute !== undefined && options.throttlePerMinute <= 0) {
         fail('Invalid build option: --throttle must be a positive integer.');
     }
-    const snippet = readStdinSync();
-    if (snippet.trim() === '')
-        fail('Missing Markdown body snippet on stdin.');
-    return { options, snippet };
+    return { options, snippet: '' };
 }
 export const buildCommand = {
     parse: (argv) => parseBuild(argv),
     async execute(intent, context) {
         const squarePath = requireSquarePath(context);
-        await createSquare(squarePath, intent.options, intent.snippet);
+        const snippet = await readStdin();
+        if (snippet.trim() === '')
+            fail('Missing Markdown body snippet on stdin.');
+        await createSquare(squarePath, intent.options, snippet);
         const cap = intent.options.hardCap === null ? 'unlimited' : formatHardCap(intent.options.hardCap);
         const throttle = intent.options.throttlePerMinute === undefined ? [] : [`  · throttle ${intent.options.throttlePerMinute}/min`];
         return withPathOutput(squarePath, ['✓ built', `  · cap ${cap}`, ...throttle, '  · participants (none seeded — first join adds names)'].join('\n'), { participantCount: 0 });
@@ -90,7 +90,7 @@ export const joinCommand = {
             const joinedName = participant.name;
             const isRejoin = before.joined;
             const reconnect = isRejoin
-                && localParticipantOwner(squarePath, joinedName) !== undefined;
+                && await localParticipantOwner(squarePath, joinedName) !== undefined;
             if (isRejoin && !intent.kick && !reconnect) {
                 fail([
                     `✕ ${participantIdentity(joinedName)} shoos you out of the square`,
@@ -102,7 +102,7 @@ export const joinCommand = {
             const afterSquare = await openSquare(squarePath, { clock: nowMs });
             const after = await entryPresentation(afterSquare, joinedName, intent.lastN);
             await closeOpenSquare(afterSquare);
-            recordLocalJoin(joinedName, squarePath);
+            await recordLocalJoin(joinedName, squarePath);
             await sweepPendingNotifications(squarePath);
             const activities = after.recentActivities.map((event) => renderAmbientEvent(event, joinedName, {
                 now: nowMs(),
@@ -164,9 +164,8 @@ function parseActivity(argv, context) {
     const reach = bell ? 'bell' : undefined;
     if (bodyArgs.length !== 1) {
         if (bodyArgs.length === 0) {
-            const piped = readPipedBodyFallback();
-            if (piped !== undefined)
-                return { name: requireParticipant(context.name), activity: piped, force, noWait, reach, reply };
+            if (!process.stdin.isTTY)
+                return { name: requireParticipant(context.name), activity: '-', force, noWait, reach, reply };
         }
         fail("express requires a body argument (a quoted string or '-' with piped stdin)");
     }
@@ -177,7 +176,7 @@ export const expressCommand = {
     async execute(intent, context) {
         const squarePath = requireSquarePath(context);
         await sweepPendingNotifications(squarePath);
-        const body = resolveBody(intent.activity);
+        const body = await resolveBody(intent.activity);
         const reachArg = intent.reach === 'bell' ? ' --bell' : '';
         await cmdActivity(squarePath, intent.name, body, (value) => value, {
             force: intent.force,
@@ -269,19 +268,19 @@ export const listeningCommand = {
 function parseDone(argv, context) {
     if (argv.length > 1)
         usage(context.command);
-    return { name: requireParticipant(context.name), body: argv.length === 1 ? argv[0] : readPipedBodyFallback() };
+    return { name: requireParticipant(context.name), body: argv.length === 1 ? argv[0] : undefined };
 }
 export const doneCommand = {
     parse: parseDone,
     async execute(intent, context) {
         const squarePath = requireSquarePath(context);
-        const body = resolveBody(intent.body ?? '').replace(/\r\n/g, '\n').trim();
+        const body = (await resolveBody(intent.body ?? (process.stdin.isTTY ? '' : '-'))).replace(/\r\n/g, '\n').trim();
         const square = await Square.at({ path: squarePath, clock: nowMs, notifier: wakeNotifierForSquare(squarePath) });
         const participant = await square.join(intent.name);
         const result = await participant.done(body);
         await square.close();
         const name = result.activity.actor;
-        recordLocalDone(name, squarePath);
+        await recordLocalDone(name, squarePath);
         const presentation = await openSquare(squarePath, { clock: nowMs });
         const participantCount = (await entryPresentation(presentation, name).finally(() => closeOpenSquare(presentation))).participantCount;
         return withPathOutput(squarePath, `○ ${participantIdentity(name)} steps out of the square — done · just now`, { participantCount });
@@ -300,7 +299,7 @@ export const holdCommand = {
         const square = await Square.at({ path: squarePath, clock: nowMs, notifier: wakeNotifierForSquare(squarePath) });
         try {
             const participant = await square.join(intent.name);
-            const result = await participant.hold(resolveBody(intent.body ?? '').replace(/\r\n/g, '\n').trim());
+            const result = await participant.hold((await resolveBody(intent.body ?? '')).replace(/\r\n/g, '\n').trim());
             await square.close();
             const presentationSquare = await openSquare(squarePath, { clock: nowMs });
             const presentation = await eventPresentation(presentationSquare, result.activity.id);

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

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

package/dist/codex-boundary-state.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { withFileLockSync } from './file-lock.js';
+import { withFileLock } from './file-lock.js';
 function statePath(env = process.env) {
     return env.SQUARE_CODEX_BOUNDARIES || path.join(os.homedir(), '.square', 'codex-boundaries.json');
 }
@@ -11,10 +11,10 @@ function lockPath(filePath) {
 function emptyFile() {
     return { v: 1, nextSequence: 0, threads: {} };
 }
-function readFile(filePath) {
+async function readFile(filePath) {
     let raw;
     try {
-        raw = fs.readFileSync(filePath, 'utf8');
+        raw = await fs.promises.readFile(filePath, 'utf8');
     }
     catch (error) {
         if (error.code === 'ENOENT')
@@ -43,45 +43,45 @@ function readFile(filePath) {
         return emptyFile();
     }
 }
-function writeFile(filePath, value) {
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+async function writeFile(filePath, value) {
+    await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
     const temporary = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-    fs.writeFileSync(temporary, `${JSON.stringify(value)}\n`, { mode: 0o600 });
-    fs.renameSync(temporary, filePath);
+    await fs.promises.writeFile(temporary, `${JSON.stringify(value)}\n`, { mode: 0o600 });
+    await fs.promises.rename(temporary, filePath);
 }
-export function readCodexBoundary(threadId, env = process.env) {
+export async function readCodexBoundary(threadId, env = process.env) {
     if (!threadId)
         return undefined;
     const filePath = statePath(env);
-    return readFile(filePath).threads[threadId];
+    return (await readFile(filePath)).threads[threadId];
 }
-export function codexQueueEligible(threadId, env = process.env) {
-    const boundary = readCodexBoundary(threadId, env);
+export async function codexQueueEligible(threadId, env = process.env) {
+    const boundary = await readCodexBoundary(threadId, env);
     return boundary !== undefined && boundary.lastStop > boundary.lastNonStop;
 }
-export function recordCodexBoundary(threadId, event, env = process.env) {
+export async function recordCodexBoundary(threadId, event, env = process.env) {
     if (!threadId)
         return;
     const filePath = statePath(env);
-    withFileLockSync(lockPath(filePath), { retryMs: 10, staleMs: 30_000 }, () => {
-        const value = readFile(filePath);
+    await withFileLock(lockPath(filePath), { retryMs: 10, staleMs: 30_000 }, 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 };
-        writeFile(filePath, value);
+        await writeFile(filePath, value);
     });
 }
-export function clearCodexBoundary(threadId, env = process.env) {
+export async function clearCodexBoundary(threadId, env = process.env) {
     if (!threadId)
         return;
     const filePath = statePath(env);
-    withFileLockSync(lockPath(filePath), { retryMs: 10, staleMs: 30_000 }, () => {
-        const value = readFile(filePath);
+    await withFileLock(lockPath(filePath), { retryMs: 10, staleMs: 30_000 }, async () => {
+        const value = await readFile(filePath);
         if (!(threadId in value.threads))
             return;
         delete value.threads[threadId];
-        writeFile(filePath, value);
+        await writeFile(filePath, value);
     });
 }

package/dist/codex-hook.js

@@ -14,7 +14,7 @@ export async function codexHookResponse(input, lookup = sessionInbox, env = proc
     const hookEventName = CODEX_HOOK_EVENTS[input.hook_event_name];
     if (hookEventName === undefined)
         return undefined;
-    recordCodexBoundary(input.session_id, hookEventName === 'Stop' ? 'Stop' : 'non-stop', env);
+    await recordCodexBoundary(input.session_id, hookEventName === 'Stop' ? 'Stop' : 'non-stop', env);
     return presentPendingAtBoundary(input.session_id, (context) => hookEventName === 'Stop'
         ? { systemMessage: context }
         : { hookSpecificOutput: { hookEventName: 'PostToolUse', additionalContext: context } }, lookup, env);
@@ -46,7 +46,7 @@ export async function runCodexHookAsync(inputText, env = process.env) {
     if (typeof value.session_id !== 'string')
         return runCodexHook(inputText, env);
     if (value.hook_event_name === 'SessionStart' || value.hook_event_name === 'SessionResume') {
-        recordCodexBoundary(value.session_id, 'non-stop', env);
+        await recordCodexBoundary(value.session_id, 'non-stop', env);
         const cwd = typeof value.cwd === 'string' ? value.cwd : process.cwd();
         try {
             const context = await automaticSessionStart('codex', value.session_id, cwd, env);
@@ -57,7 +57,7 @@ export async function runCodexHookAsync(inputText, env = process.env) {
         }
     }
     if (value.hook_event_name === 'SessionEnd') {
-        clearCodexBoundary(value.session_id, env);
+        await clearCodexBoundary(value.session_id, env);
         const cwd = typeof value.cwd === 'string' ? value.cwd : process.cwd();
         try {
             await automaticSessionEnd('codex', value.session_id, cwd, env);

package/dist/codex-queue.js

@@ -39,7 +39,7 @@ export class CodexQueueAdapter {
             return { outcome: 'unavailable', signature: 'invalid_address', message: 'Codex route has no thread id.' };
         }
         const env = this.opts.env ?? process.env;
-        if (!codexQueueEligible(threadId, env)) {
+        if (!await codexQueueEligible(threadId, env)) {
             return {
                 outcome: 'unavailable',
                 signature: 'boundary_not_stopped',
@@ -49,7 +49,7 @@ export class CodexQueueAdapter {
         }
         if (!(await beforeSend()))
             return { outcome: 'cancelled' };
-        if (!codexQueueEligible(threadId, env)) {
+        if (!await codexQueueEligible(threadId, env)) {
             return {
                 outcome: 'unavailable',
                 signature: 'boundary_not_stopped',

package/dist/file-lock.d.ts

@@ -1,6 +1,6 @@
 export interface FileLockOptions {
     retryMs: number;
     staleMs: number;
+    signal?: AbortSignal;
 }
-export declare function withFileLockSync<T>(lockPath: string, options: FileLockOptions, fn: () => T): T;
 export declare function withFileLock<T>(lockPath: string, options: FileLockOptions, fn: () => T | Promise<T>): Promise<T>;