@astrosheep/square 0.3.63 → 0.3.65

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

@@ -1,7 +1,8 @@
 {
   "name": "square",
-  "version": "0.3.63",
-  "description": "Native Claude Code turn-boundary delivery for Square participants",
+  "version": "0.3.65",
+  "description": "Native Claude Code inbox delivery for Square participants",
+  "types": "./types.d.ts",
   "author": {
     "name": "Square"
   }

package/claude-plugin/hooks/hooks.json

@@ -1,22 +1 @@
-{
-  "description": "Bounded Square inbox admission between Claude Code agent steps",
-  "hooks": {
-    "SessionStart": [
-      { "hooks": [{ "type": "command", "command": "square claude-hook", "timeout": 5 }] }
-    ],
-    "SessionEnd": [
-      { "hooks": [{ "type": "command", "command": "square claude-hook", "timeout": 5 }] }
-    ],
-    "PostToolBatch": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "command": "square claude-hook",
-            "timeout": 5
-          }
-        ]
-      }
-    ]
-  }
-}
+{"modules":["./register.js"]}

package/claude-plugin/hooks/register.js

@@ -0,0 +1,119 @@
+// Claude Code 2.1.295 mod. No Node imports, shell interpolation, or child credentials.
+const hasToken = (text) => typeof text === 'string' && /(?:^|\n)\[square-inbox:[a-zA-Z0-9-]+\](?:\n|$)/.test(text);
+
+async function coordinate($) {
+  return { sessionId: await $.session.id(), cwd: await $.session.cwd(), version: (await $.session.version()).version, endpoint: await $.env.get('CLAUDE_CODE_MESSAGING_SOCKET') };
+}
+async function bridge($, value, budget = 2800) {
+  const result = await $.process.run(['square', 'claude-mod'], { cwd: value.cwd, stdin: JSON.stringify(value), timeoutMs: Math.max(1, Math.min(2800, budget)) });
+  if (result.exitCode !== 0 || result.isStdoutTruncated) throw new Error('Square native inbox bridge unavailable');
+  return JSON.parse(result.stdout);
+}
+async function snapshot($, id) { return (await $.state.get({ plugin: 'square', key: 'inbox', id })).value; }
+async function cancellation($, id) { return (await $.state.get({ plugin: 'square', key: 'cancelAt', id })).value; }
+function confirmLater($, c, operation, text) {
+  // State reads are dispatch snapshots. This ONE fresh timer dispatch is not polling.
+  // Reload cancels it; lost evidence stays unknown and is never blindly replayed.
+  try { $.clock.after(0, () => {
+    (async () => {
+      if (await $.session.id() !== c.sessionId) return;
+      const old = await snapshot($, c.sessionId);
+      const cancelled = await cancellation($, c.sessionId);
+      await bridge($, { ...c, cancelAt: cancelled?.at, cancelledBindings: cancelled?.bindings, bindings: old?.bindings, operation, text });
+    })().catch(() => undefined);
+  }); } catch { /* denied scheduling leaves evidence unknown, never a second next */ }
+}
+async function save($, id, update, version) {
+  return $.state.set({ plugin: 'square', key: 'inbox', id }, update, version === undefined ? undefined : { ifVersion: version });
+}
+async function reconcile($, sessionId, operation = 'start', resume = false) {
+  const read = await coordinate($);
+  const c = sessionId ? { ...read, sessionId } : read;
+  const held = await $.state.get({ plugin: 'square', key: 'inbox', id: c.sessionId });
+  const old = held.value;
+  const cancelled = await cancellation($, c.sessionId);
+  const result = await bridge($, { ...c, operation, cancelAt: cancelled?.at, cancelledBindings: cancelled?.bindings, bindings: old?.bindings, resume });
+  // A concurrent abort must win over a stale reconciliation write.
+  await save($, c.sessionId, { coordinate: c, bindings: result.bindings }, held.version);
+  if (!result.available) await $.ui.log(result.diagnostic);
+}
+
+async function cancel($) {
+  const c = await coordinate($);
+  const old = await snapshot($, c.sessionId);
+  const cancelAt = await $.clock.now();
+  const captured = old?.bindings ?? [];
+  await $.state.set({ plugin: 'square', key: 'cancelAt', id: c.sessionId }, { at: cancelAt, bindings: captured });
+  const result = await bridge($, { ...c, bindings: captured, cancelAt, cancelledBindings: captured, operation: 'cancel' });
+  try { $.clock.after(0, () => {
+    (async () => {
+      const held = await $.state.get({ plugin: 'square', key: 'cancelAt', id: c.sessionId });
+      if (held.value?.at === cancelAt) await $.state.set({ plugin: 'square', key: 'cancelAt', id: c.sessionId }, { at: cancelAt, bindings: result.cancelledBindings }, { ifVersion: held.version });
+    })().catch(() => undefined);
+  }); } catch { /* captured cancellation remains engine-owned */ }
+}
+
+export function register(on) {
+  on('session.start', async ($, e, next) => {
+    await reconcile($).catch(() => undefined);
+    return next(e);
+  });
+  on('classic.SessionStart', async ($, e, next) => {
+    await reconcile($, e.session_id, 'start', e.source === 'resume').catch(() => undefined);
+    return next(e);
+  });
+  on('tool.call', async ($, e, next) => {
+    try { return await next(e); }
+    finally { if (!e.agentId) await reconcile($, undefined, 'reconcile').catch(() => undefined); }
+  });
+  on('turn.start', async ($, e, next) => {
+    if (!e.agentId) await reconcile($, undefined, 'reconcile').catch(() => undefined);
+    return next(e);
+  });
+  on('session.end', async ($, e, next) => {
+    // Pinned old ID and captured ownership epochs, never a later current coordinate.
+    const endedAt = await $.clock.now().catch(() => undefined);
+    const held = await $.state.get({ plugin: 'square', key: 'inbox', id: e.sessionId }).catch(() => undefined);
+    const old = held?.value;
+    const c = old?.coordinate ?? await coordinate($).catch(() => undefined);
+    if (c) {
+      const result = await bridge($, { ...c, sessionId: e.sessionId, bindings: old?.bindings, endedAt, operation: 'end' }, next.budget.remainingMs).catch(() => undefined);
+      // Retired membership lives in the host ledger; conversation state may be cleared.
+      if (result) await save($, e.sessionId, { coordinate: { ...c, sessionId: e.sessionId }, bindings: [] }, held?.version).catch(() => undefined);
+    }
+    return next(e);
+  });
+  on('turn.abort', async ($, e, next) => {
+    await cancel($).catch(() => undefined);
+    return next(e);
+  });
+  on('turn.complete', async ($, e, next) => {
+    // Terminal Esc aborts are reported here, not through the plugin's turn.abort op.
+    if (!e.agentId && e.reason === 'aborted') await cancel($).catch(() => undefined);
+    return next(e);
+  });
+  on('session.receive', async ($, e, next) => {
+    if (e.agentId || e.origin?.kind !== 'peer' || !hasToken(e.text)) return next(e);
+    const c = await coordinate($).catch(() => undefined);
+    if (!c) return next(e);
+    const old = await snapshot($, c.sessionId).catch(() => undefined);
+    const cancelled = await cancellation($, c.sessionId).catch(() => undefined);
+    const guard = await bridge($, { ...c, cancelAt: cancelled?.at, cancelledBindings: cancelled?.bindings, bindings: old?.bindings, operation: 'guard', text: e.text }).catch(() => undefined);
+    if (guard?.recognized && !guard.current) return { consumed: 'Square delivery is stale or cancelled' };
+    // Preserve native policy: hold/refuse reject this gate; never call next twice.
+    const result = await next(e);
+    if (guard?.current && result.text === e.text) confirmLater($, c, 'admitted', result.text);
+    return result;
+  });
+  on('session.append', async ($, e, next) => {
+    if (e.agentId || e.origin?.kind !== 'peer') return next(e);
+    const c = await coordinate($).catch(() => undefined);
+    const result = await next(e);
+    if (!c || result.message?.role !== 'user') return result;
+    // Match a complete payload inside one returned stored text block, not entry text.
+    for (const block of result.message.content ?? []) {
+      if (block.type === 'text' && hasToken(block.text)) confirmLater($, c, 'stored', block.text);
+    }
+    return result;
+  });
+}

package/claude-plugin/types.d.ts

@@ -0,0 +1,7 @@
+export type SquareInboxBinding = { location: string; participant: string; session: string; epoch?: number };
+export type SquareInboxCoordinate = { sessionId: string; cwd: string; version: string; endpoint?: string };
+export type SquareInboxCancellation = { at: number; bindings?: SquareInboxBinding[] };
+export type SquareInboxState = { coordinate: SquareInboxCoordinate; bindings?: SquareInboxBinding[] };
+declare module 'claude-code' {
+  interface PluginState { square: { inbox: StateFamily<SquareInboxState>; cancelAt: StateFamily<SquareInboxCancellation> } }
+}

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

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

package/dist/activity-feed.d.ts

@@ -1,16 +1,7 @@
-import { type StoredAct, type SquareState, type PublicAct, type RoomChangeAct } from './model.js';
-export interface ActivityFeedFilter {
-    participants?: string[];
-    mention?: string;
-}
+import { type StoredAct, type SquareState } from './model.js';
 export declare function actDelta(acts: StoredAct[], cursor: number): StoredAct[];
 /** Visible activities after the participant's derived continuous-seen prefix. */
 export declare function deliveryDelta(squareState: SquareState, name: string, delivery?: import("./delivery.js").DeliveryModel): StoredAct[];
-export declare function peerRoomChanges(delta: StoredAct[], name: string): RoomChangeAct[];
-export declare function peerPublicActs(delta: StoredAct[], name: string): PublicAct[];
 export declare function directedPeerSays(squareState: SquareState, delta: StoredAct[], name: string, delivery?: import("./delivery.js").DeliveryModel): Extract<StoredAct, {
     kind: 'say';
 }>[];
-export declare function matchesFeedFilter(act: StoredAct, filter: ActivityFeedFilter, recipients?: readonly string[]): boolean;
-export declare function filteredPeerActivities(delta: StoredAct[], name: string, filter: ActivityFeedFilter): PublicAct[];
-export declare function filteredRoomChanges(delta: StoredAct[], name: string, filter: ActivityFeedFilter): RoomChangeAct[];

package/dist/activity-feed.js

@@ -1,5 +1,4 @@
-import { sameName } from './model.js';
-import { deriveDeliveryModel, matchesCatchFilter } from './delivery.js';
+import { deriveDeliveryModel } from './delivery.js';
 export function actDelta(acts, cursor) {
     return acts.filter((act) => act.index > cursor);
 }
@@ -7,31 +6,6 @@ export function actDelta(acts, cursor) {
 export function deliveryDelta(squareState, name, delivery = deriveDeliveryModel(squareState)) {
     return actDelta(squareState.acts, delivery.cursorFor(name));
 }
-export function peerRoomChanges(delta, name) {
-    return delta.filter((act) => act.actor !== undefined && !sameName(act.actor, name) && act.kind !== 'say' && act.kind !== 'read');
-}
-export function peerPublicActs(delta, name) {
-    return delta.filter((act) => act.actor !== undefined && !sameName(act.actor, name) && (act.kind === 'say' || act.kind === 'done'));
-}
 export function directedPeerSays(squareState, delta, name, delivery = deriveDeliveryModel(squareState)) {
     return delta.filter((act) => delivery.directedTo(act, name));
 }
-function matchesParticipants(act, participants) {
-    return participants === undefined || (act.actor !== undefined && participants.some((participant) => sameName(participant, act.actor)));
-}
-export function matchesFeedFilter(act, filter, recipients) {
-    if (act.kind === 'say') {
-        return matchesCatchFilter({ actor: act.actor, body: act.body, mentions: act.mentions, reach: act.reach, ...(recipients === undefined ? {} : { recipients }) }, filter);
-    }
-    return filter.mention === undefined && matchesParticipants(act, filter.participants);
-}
-export function filteredPeerActivities(delta, name, filter) {
-    return peerPublicActs(delta, name)
-        .filter((act) => act.kind === 'say')
-        .filter((act) => matchesFeedFilter(act, filter));
-}
-export function filteredRoomChanges(delta, name, filter) {
-    if (filter.mention !== undefined)
-        return [];
-    return peerRoomChanges(delta, name).filter((act) => matchesParticipants(act, filter.participants));
-}

package/dist/activity.js

@@ -14,20 +14,13 @@ import { formatDuration } from './time.js';
 import { style } from './tty-style.js';
 import { hostLedgerForEnv } from './registry.js';
 import { createDefaultWakeTransport } from './notifications.js';
-function draftDirFor(squarePath) {
-    return path.join(path.dirname(squarePath), 'drafts');
-}
-function draftTimestamp(at) {
-    return new Date(at).toISOString().replace(/\.\d{3}Z$/, 'Z').replace(/[:.]/g, '-');
-}
-function draftNamePart(name) {
-    return name.replace(/[^\p{L}\p{N}_-]+/gu, '-').replace(/^-+|-+$/g, '') || 'participant';
-}
 export function saveActivityDraft(squarePath, name, body) {
-    const draftDir = draftDirFor(squarePath);
+    const draftDir = path.join(path.dirname(squarePath), 'drafts');
     fs.mkdirSync(draftDir, { recursive: true });
     const hash = crypto.createHash('sha256').update(body).digest('hex').slice(0, 8);
-    const base = `${draftTimestamp(nowMs())}-${draftNamePart(name)}-${hash}`;
+    const stamp = new Date(nowMs()).toISOString().replace(/\.\d{3}Z$/, 'Z').replace(/[:.]/g, '-');
+    const namePart = name.replace(/[^\p{L}\p{N}_-]+/gu, '-').replace(/^-+|-+$/g, '') || 'participant';
+    const base = `${stamp}-${namePart}-${hash}`;
     for (let i = 0;; i++) {
         const filename = `${base}${i === 0 ? '' : `-${i}`}.md`;
         const target = path.join(draftDir, filename);
@@ -51,6 +44,20 @@ export function activityRetryCommand(squarePath, name, opts, force = opts.force
     const reply = opts.reply === undefined ? '' : ` --reply ${replyIndex === undefined ? quoteShell(opts.reply) : formatActivityId(replyIndex)}`;
     return `${participantCommandPrefix(squarePath, name)} express${force ? ' --force' : ''}${opts.noWait ? ' --no-wait' : ''}${reach}${reply} -`;
 }
+/**
+ * A recipient conflict is the speaker's to edit: the printed recovery drops every
+ * mention flag (or keeps the bell) so the retry never repeats the rejected target.
+ */
+function mentionRepairCommand(squarePath, name, opts, bell) {
+    const replyIndex = opts.reply === undefined ? undefined : parseActivityId(opts.reply);
+    const reply = opts.reply === undefined ? '' : ` --reply ${replyIndex === undefined ? quoteShell(opts.reply) : formatActivityId(replyIndex)}`;
+    const reach = bell ? ' --bell' : ' --no-mention';
+    return `${participantCommandPrefix(squarePath, name)} express${opts.force ? ' --force' : ''}${opts.noWait ? ' --no-wait' : ''}${reach}${reply} -`;
+}
+/** A body that is nothing but *gestures* reads as an action, not as speech. */
+function isGestureOnly(body) {
+    return /\*[^*]*\*/.test(body) && body.replace(/\*[^*]*\*/g, '').trim() === '';
+}
 export async function cmdActivity(squarePath, name, activity, resolveBody, opts) {
     const rawInput = String(resolveBody(activity));
     const env = { ...(opts.env ?? process.env) };
@@ -99,7 +106,6 @@ export async function cmdActivity(squarePath, name, activity, resolveBody, opts)
         const reentered = entry.kind === 'joined' && entry.activity !== null;
         const before = await presentation();
         const pendingPublic = before.pendingPublic;
-        const pendingRoomChanges = before.pendingRoomChanges;
         expressAttempted = true;
         const landed = await application.express(rawInput.replace(/\r\n/g, '\n').trim(), {
             force: opts.force ?? false,
@@ -128,18 +134,28 @@ export async function cmdActivity(squarePath, name, activity, resolveBody, opts)
         const headerCount = fresh.participantCount;
         const held = fresh.held;
         const ownActCount = fresh.ownActivityCount;
-        const hasPending = pendingPublic.length > 0 || pendingRoomChanges.length > 0;
-        const pending = hasPending ? `\n\n${renderPendingFeed([...fresh.activities], [...pendingPublic], [...pendingRoomChanges], knownName, fresh.state)}` : '';
+        const hasPending = pendingPublic.length > 0;
+        const pendingSpeaker = pendingPublic[0]?.actor;
+        const pendingLead = pendingSpeaker === undefined
+            ? ''
+            : `▲ while you spoke, ${participantIdentity(pendingSpeaker)} said something behind you\n\n`;
+        const pending = hasPending ? `\n\n${pendingLead}${renderPendingFeed([...fresh.activities], [...pendingPublic], knownName, fresh.state)}` : '';
         const hint = expressHintLine(ownActCount);
-        const reachEcho = landed.activity.reach === 'bell'
-            ? ' · to everyone (bell)'
-            : landed.activity.mentions.length > 0
-                ? ` · to ${landed.activity.mentions.map((target) => participantIdentity(target)).join(', ')}`
-                : '';
-        const confirmation = `● your activity lands${style('dim', ` — #${ownActCount} · ${landed.activity.id}${reachEcho}`)}`;
+        const receiptId = landed.activity.id;
+        const capCount = fresh.hardCap === null ? '' : ` · ${ownActCount}/${fresh.hardCap}`;
+        const confirmation = landed.activity.reach === 'bell'
+            ? `● you ring the bell — everyone turns · ${receiptId}${style('dim', capCount)}`
+            : `● ${landed.activity.mentions.length > 0
+                ? `you walk over to ${landed.activity.mentions.map((target) => participantIdentity(target)).join(', ')}`
+                : isGestureOnly(landed.activity.body ?? '')
+                    ? 'your gesture lands'
+                    : 'your words land'} — ${receiptId}${style('dim', capCount)}`;
         const withHint = hint ? `${confirmation}\n${style('dim', hint)}` : confirmation;
+        const replyNotice = landed.replyAuthorNotHere === undefined
+            ? ''
+            : `\n○ ${participantIdentity(landed.replyAuthorNotHere)} isn't in the square right now — the reply landed without reaching them`;
         const reentry = reentered ? '● you stepped back into the square\n' : '';
-        process.stdout.write(withPathOutput(squarePath, reentry + withHint + pending, { participantCount: headerCount, held }));
+        process.stdout.write(withPathOutput(squarePath, reentry + withHint + replyNotice + pending, { participantCount: headerCount, held }));
     }
     catch (error) {
         // Save before any recovery read: even a broken artifact must not eat the body.
@@ -159,7 +175,6 @@ export async function cmdActivity(squarePath, name, activity, resolveBody, opts)
                     retryCommand,
                     forceCommand,
                     activitySummaries: unreadActivitySummaries(fresh.state, knownName, nowMs()),
-                    unreadRoomChanges: [],
                 }));
                 process.exit(1);
                 return;
@@ -178,7 +193,8 @@ export async function cmdActivity(squarePath, name, activity, resolveBody, opts)
                     ...output,
                     reason: error.code,
                     delayMs: error.facts?.retryAfterMs ?? SLEEP_MS,
-                    holdReason: fresh.holdReason,
+                    ...(error.facts?.holder === undefined ? {} : { holder: error.facts.holder }),
+                    ...(error.facts?.holdReason === undefined ? {} : { holdReason: error.facts.holdReason }),
                     retryCommand,
                 }));
                 process.exit(1);
@@ -197,19 +213,35 @@ export async function cmdActivity(squarePath, name, activity, resolveBody, opts)
             }
         }
         const lines = [error instanceof Error ? error.message : String(error), `· draft kept: ${draftPath}`];
+        const reason = isSquareError(error) ? error.facts?.reason : undefined;
+        // `not_standing` is a flag mention; the body-scan and bell conflicts carry an @name in the draft.
+        const mentionRepair = reason === 'bell_mention_conflict' ? { bell: true, fromBody: true }
+            : reason === 'unmatched_mention' ? { bell: false, fromBody: true }
+                : reason === 'not_standing' ? { bell: false, fromBody: false }
+                    : undefined;
         if (isSquareError(error)) {
             if (callerMissing || error.code === 'unknown_participant' || error.code === 'not_joined')
                 lines.push(joinRecoveryCommand(squarePath, name));
             if (error.code === 'already_joined')
                 lines.push(...takeoverRecoveryLines(squarePath, name));
-            if (error.code === 'invalid_args' || error.code === 'invalid_name') {
+            if (mentionRepair !== undefined) {
+                // The draft stays, but the retry no longer carries the target that was refused.
+                lines.push(participantsRecoveryCommand(squarePath));
+                lines.push(mentionRepair.fromBody
+                    ? "  · edit the draft first — the body's @name must be removed or wrapped in backticks:"
+                    : '  · pick someone standing here, or land it bare:');
+                lines.push(`${mentionRepairCommand(squarePath, name, opts, mentionRepair.bell)} < ${quoteShell(draftPath)}`);
+            }
+            else if (error.code === 'invalid_args' || error.code === 'invalid_name') {
                 if (opts.mentions?.length)
                     lines.push(participantsRecoveryCommand(squarePath));
                 if (opts.reply !== undefined)
                     lines.push(`${commandPrefix(squarePath)} history --limit 10`);
             }
         }
-        lines.push('  · correct the problem above before retrying; keep your intended recipients and reply:', `${retryCommand} < ${quoteShell(draftPath)}`);
+        if (mentionRepair === undefined) {
+            lines.push('  · correct the problem above before retrying; keep your intended recipients and reply:', `${retryCommand} < ${quoteShell(draftPath)}`);
+        }
         process.stderr.write(formatRefusal(squarePath, lines, output));
         process.exit(2);
     }

package/dist/artifact.d.ts

@@ -23,7 +23,7 @@ export declare function readSquareSnapshot(squarePath: string, signal?: AbortSig
 /** Check the artifact revision without loading or parsing the historical state. */
 export declare function readSquareRevision(squarePath: string, signal?: AbortSignal): Promise<number>;
 /** One reference-counted revision detector per canonical artifact in this process. */
-export declare function observeSquareRevision(squarePath: string): Promise<import('./file-changes.js').VersionObserver<number>>;
+export declare function observeSquareRevision(squarePath: string): Promise<import('./file-changes.js').VersionObserver<number | null>>;
 export type SquareTransition<R> = (state: SquareState, revision: number) => {
     state?: SquareState;
     result: R;

package/dist/artifact.js

@@ -31,14 +31,11 @@ function isNotFound(error) {
 function isNotADatabase(error) {
     return error instanceof Error && /not a database|file is not a database|SQLITE_NOTADB/i.test(error.message);
 }
-function existingDatabaseUri(squarePath) {
+function openExistingDatabase(squarePath) {
     const uri = pathToFileURL(path.resolve(squarePath));
     uri.searchParams.set('mode', 'rw');
-    return uri.href;
-}
-function openExistingDatabase(squarePath) {
     try {
-        return new DatabaseSync(existingDatabaseUri(squarePath));
+        return new DatabaseSync(uri.href);
     }
     catch (error) {
         if (isNotFound(error))
@@ -116,9 +113,6 @@ function validateDatabase(database) {
         throw error;
     }
 }
-function configureDatabase(database) {
-    database.exec('PRAGMA busy_timeout = 0; PRAGMA journal_mode = DELETE; PRAGMA synchronous = FULL;');
-}
 /** Opens an existing artifact without permitting SQLite to create a missing path. */
 function readExistingArtifact(squarePath, read) {
     requireSquareExtension(squarePath);
@@ -143,13 +137,6 @@ function readExistingArtifact(squarePath, read) {
 function readSquareSnapshotOnce(squarePath) {
     return readExistingArtifact(squarePath, validateDatabase);
 }
-function readSquareRevisionOnce(squarePath) {
-    return readExistingArtifact(squarePath, (database) => {
-        validateDatabaseHeader(database);
-        const rows = database.prepare(`SELECT id, revision FROM ${SNAPSHOT_TABLE}`).all();
-        return validateSnapshotRevision(rows);
-    });
-}
 async function createTemporaryArtifact(squarePath) {
     const directory = path.dirname(squarePath);
     await fs.promises.mkdir(directory, { recursive: true });
@@ -177,12 +164,6 @@ async function syncTemporaryArtifact(temporary) {
         await handle.close();
     }
 }
-async function removeTemporaryArtifact(temporary) {
-    try {
-        await fs.promises.unlink(temporary);
-    }
-    catch { /* cleanup cannot invalidate a published artifact */ }
-}
 function initializeDatabase(squarePath, state) {
     const encoded = JSON.stringify(state);
     let database;
@@ -222,7 +203,10 @@ export async function createSquareFile(squarePath, state) {
         }
     }
     finally {
-        await removeTemporaryArtifact(temporary);
+        try {
+            await fs.promises.unlink(temporary);
+        }
+        catch { /* cleanup cannot invalidate a published artifact */ }
     }
 }
 function isBusy(error) {
@@ -259,11 +243,26 @@ export function readSquareSnapshot(squarePath, signal) {
 }
 /** Check the artifact revision without loading or parsing the historical state. */
 export function readSquareRevision(squarePath, signal) {
-    return readWithBusyRetry(() => readSquareRevisionOnce(squarePath), signal);
+    return readWithBusyRetry(() => readExistingArtifact(squarePath, (database) => {
+        validateDatabaseHeader(database);
+        const rows = database.prepare(`SELECT id, revision FROM ${SNAPSHOT_TABLE}`).all();
+        return validateSnapshotRevision(rows);
+    }), signal);
 }
 /** One reference-counted revision detector per canonical artifact in this process. */
 export function observeSquareRevision(squarePath) {
-    return observeFileVersion(squarePath, 'square-revision', readSquareRevision);
+    return observeFileVersion(squarePath, 'square-revision', async (file, signal) => {
+        try {
+            return await readSquareRevision(file, signal);
+        }
+        catch (error) {
+            if (signal?.aborted)
+                throw signal.reason ?? error;
+            if (error instanceof InternalSquareError && error.code === 'not_found')
+                return null;
+            throw error;
+        }
+    });
 }
 async function readWithBusyRetry(read, signal) {
     while (true) {
@@ -305,7 +304,7 @@ export async function transactSquareSnapshot(squarePath, fn, signal, forceCommit
             if (signal?.aborted)
                 throw signal.reason ?? closedError();
             try {
-                configureDatabase(database);
+                database.exec('PRAGMA busy_timeout = 0; PRAGMA journal_mode = DELETE; PRAGMA synchronous = FULL;');
                 database.exec('BEGIN IMMEDIATE;');
                 begun = true;
                 break;

package/dist/attention-presentation.js

@@ -19,6 +19,7 @@ export function displayAttentionPath(squarePath) {
 export function renderAttentionDescription({ actor, recipient, route }) {
     switch (route) {
         case 'mention': return `${actor} addressed you (${recipient})`;
+        case 'reply': return `${actor} replied to you (${recipient})`;
         case 'attention': return `${actor} spoke · you’re listening to ${actor}`;
         case 'bell': return `${actor} rang the bell · everyone’s attention`;
     }

package/dist/automatic-session.d.ts

@@ -1,5 +1,7 @@
-export type AutomaticProvider = 'codex' | 'claude' | 'opencode' | 'pi';
+import { type AutomaticProvider } from './participant-identity.js';
+export type { AutomaticProvider } from './participant-identity.js';
 export { automaticParticipant } from './participant-identity.js';
+export declare function operationEnv(provider: AutomaticProvider, sessionId: string, env: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
 export declare function publicSquarePath(cwd: string): string;
 export declare function automaticSessionStart(provider: AutomaticProvider, sessionId: string, cwd: string, env?: NodeJS.ProcessEnv): Promise<string | undefined>;
 export declare function automaticSessionEnd(provider: AutomaticProvider, sessionId: string, cwd: string, env?: NodeJS.ProcessEnv): Promise<void>;

package/dist/automatic-session.js

@@ -1,39 +1,26 @@
 import { promises as fs } from 'node:fs';
-import { hostLedgerRoot } from './host-ledger-root.js';
 import path from 'node:path';
 import { openSquare } from './square-file-adapter.js';
 import { closeOpenSquare } from './open-square.js';
 import { Square } from './square-wiring.js';
 import { entryPresentation } from './views.js';
-import { automaticParticipant } from './participant-identity.js';
+import { automaticParticipant, harnessSessionSources } from './participant-identity.js';
 import { SquareError } from './model.js';
-import { createHostLedgerPort } from './host-ledger-file-adapter.js';
 import { projectSessionBindings } from './square-projections.js';
-import { claimSessionParticipant, readParticipantOwner, releaseSessionParticipant } from './registry.js';
+import { claimSessionParticipant, hostLedgerForEnv, readParticipantOwner, releaseSessionParticipant } from './registry.js';
 import { publishWakeRoute, resolvePrimaryWakeRoute, defaultWakeRouteCapabilities } from './routes.js';
 export { automaticParticipant } from './participant-identity.js';
-const providerEnv = {
-    codex: 'CODEX_THREAD_ID',
-    claude: 'CLAUDE_CODE_SESSION_ID',
-    opencode: 'OPENCODE_SESSION_ID',
-    pi: 'PI_SESSION_ID',
-};
-function operationEnv(provider, sessionId, env) {
-    return {
-        ...env,
-        CLAUDE_CODE_SESSION_ID: '',
-        CLAUDE_CODE_CHILD_SESSION: '',
-        CODEX_THREAD_ID: '',
-        OPENCODE_SESSION_ID: '',
-        PI_SESSION_ID: '',
-        [providerEnv[provider]]: sessionId,
-    };
-}
-function hostLedgerForEnv(env) {
-    const root = hostLedgerRoot(env);
-    return createHostLedgerPort({
-        rootPath: root,
-    });
+export function operationEnv(provider, sessionId, env) {
+    const scoped = { ...env };
+    // Clear every native coordinate (and the Claude child flag); PASEO_AGENT_ID stays as it is.
+    for (const source of harnessSessionSources) {
+        if (source.provider === undefined)
+            continue;
+        scoped[source.variable] = source.provider === provider ? sessionId : '';
+        if (source.childVariable !== undefined)
+            scoped[source.childVariable] = '';
+    }
+    return scoped;
 }
 export function publicSquarePath(cwd) {
     return path.join(cwd, '.square', 'PUBLIC.square');
@@ -77,18 +64,18 @@ export async function automaticSessionStart(provider, sessionId, cwd, env = proc
         throw new SquareError('already_joined', `✕ ${name} already stands here — another session holds the name`);
     }
     const scopedEnv = operationEnv(provider, sessionId, env);
-    const claim = await claimSessionParticipant(squarePath, name, scopedEnv);
-    const square = await Square.at({ path: squarePath, hostLedger: hostLedgerForEnv(scopedEnv), env: scopedEnv });
+    const claim = await claimSessionParticipant(squarePath, name, hostLedger, scopedEnv);
+    const square = await Square.at({ path: squarePath, hostLedger, env: scopedEnv });
     try {
         const implicit = await square.implicitJoin(name);
         if (implicit.state === 'done') {
             if (claim?.status === 'acquired')
-                await releaseSessionParticipant(squarePath, name, scopedEnv);
+                await releaseSessionParticipant(squarePath, name, hostLedger, scopedEnv);
             return undefined;
         }
-        const route = resolvePrimaryWakeRoute({ location: squarePath, participant: name, sessionId, provider }, env, await defaultWakeRouteCapabilities(hostLedgerForEnv(env)));
+        const route = resolvePrimaryWakeRoute({ location: squarePath, participant: name, sessionId, provider }, env, await defaultWakeRouteCapabilities(hostLedger));
         if (route !== undefined) {
-            const publisher = await openSquare(squarePath, { hostLedger: hostLedgerForEnv(scopedEnv), env: scopedEnv });
+            const publisher = await openSquare(squarePath, { hostLedger, env: scopedEnv });
             try {
                 await publishWakeRoute(publisher.artifact, { ...route, ...(claim?.epoch === undefined || claim.epoch <= 0 ? {} : { epoch: claim.epoch }) }, { at: Date.now(), requireCurrentSession: true });
             }
@@ -96,7 +83,7 @@ export async function automaticSessionStart(provider, sessionId, cwd, env = proc
                 await closeOpenSquare(publisher);
             }
         }
-        await hostLedgerForEnv(env).ensurePresence({
+        await hostLedger.ensurePresence({
             location: squarePath,
             participant: name,
             session: sessionId,
@@ -108,7 +95,7 @@ export async function automaticSessionStart(provider, sessionId, cwd, env = proc
     }
     catch (error) {
         if (claim?.status === 'acquired')
-            await releaseSessionParticipant(squarePath, name, scopedEnv).catch(() => undefined);
+            await releaseSessionParticipant(squarePath, name, hostLedger, scopedEnv).catch(() => undefined);
         throw error;
     }
     finally {
@@ -129,7 +116,7 @@ export async function automaticSessionEnd(provider, sessionId, cwd, env = proces
     }))[0];
     const expectedEpoch = binding === undefined
         ? undefined
-        : (await readParticipantOwner(squarePath, binding.participant, scopedEnv))?.epoch;
+        : (await readParticipantOwner(squarePath, binding.participant, hostLedger))?.epoch;
     await closeOpenSquare(probe);
     const square = await Square.at({ path: squarePath, hostLedger, env: scopedEnv });
     try {