@astrosheep/square 0.3.5 → 0.3.7

package/dist/wake-sink.js

@@ -1,219 +1,8 @@
-/**
- * wake-sink.ts — shared paseo wake dispatch.
- *
- * This is the single canonical implementation of "wake a paseo agent
- * when they receive an undelivered @mention or --bell in a square."
- *
- * The detached one-shot notification worker uses this module after the
- * natural-delivery grace period. The WakeSink is stateless; the worker owns
- * receipt checks, timing, and failure isolation.
- */
-import { execSync, spawnSync } from 'node:child_process';
-import { setTimeout as sleep } from 'node:timers/promises';
-import { homedir } from 'node:os';
-import { loadSquare } from './artifact.js';
-import { SquareError } from './model.js';
-import { leaseOwnsNotification } from './delivery.js';
-import { sessionInbox } from './inbox.js';
-import { waitForPaseoToolBoundary } from './paseo-timeline.js';
-import { hasPresentedAttention, presentOnce } from './presented.js';
-import { lookupParticipant } from './registry.js';
-import { quoteShell } from './presentation.js';
-import { isDeliveryDelivered, resolveRosterName } from './runtime.js';
-async function waitForCatchDelivery(squarePath, recipient, notification, ownerId) {
-    const deadline = Date.now() + 180_000;
-    while (Date.now() < deadline) {
-        const doc = loadSquare(squarePath);
-        const known = resolveRosterName(doc, recipient) ?? recipient;
-        if (isDeliveryDelivered(doc, known, notification.item.index))
-            return true;
-        const lease = lookupParticipant(squarePath, known).find((binding) => binding.ownerId === ownerId);
-        const activeLease = lease === undefined
-            ? undefined
-            : sessionInbox(lease.sessionId).find((membership) => membership.name === known)?.catchLease;
-        if (activeLease === undefined || activeLease.expiresAt <= Date.now())
-            return false;
-        await sleep(Math.min(250, Math.max(1, activeLease.expiresAt - Date.now())));
-    }
-    return false;
-}
-const DEFAULT_PASEO_WAKE_TIMEOUT_MS = 90_000;
-function paseoWakeTimeoutMs() {
-    const raw = process.env['SQUARE_PASEO_WAKE_TIMEOUT_MS'];
-    if (raw === undefined)
-        return DEFAULT_PASEO_WAKE_TIMEOUT_MS;
-    const value = Number.parseInt(raw, 10);
-    if (!Number.isFinite(value) || value <= 0) {
-        throw new SquareError('invalid_args', 'Invalid SQUARE_PASEO_WAKE_TIMEOUT_MS: expected a positive integer.');
-    }
-    return value;
-}
-// ── helpers ──────────────────────────────────────────────────────
-function previewBody(body) {
-    return body.length > 200 ? body.slice(0, 197) + '...' : body;
-}
-function wakeNowCommand(squarePath, recipient) {
-    return `square --as ${quoteShell(recipient)} --square-path ${quoteShell(squarePath)} catch --now`;
-}
-function nativeWakePrompt(squarePath, recipient) {
-    return [
-        '<system-reminder source="square">',
-        `Square activity is waiting for @${recipient} in ${squarePath}.`,
-        'The native adapter will present it at the next boundary. If it does not:',
-        `\`${wakeNowCommand(squarePath, recipient)}\``,
-        '</system-reminder>',
-    ].join('\n');
-}
-function fullWakePrompt(notification, squarePath) {
-    const { item, recipient } = notification;
-    const home = homedir();
-    const displayPath = squarePath.startsWith(home) ? `~${squarePath.slice(home.length)}` : squarePath;
-    return [
-        '<system-reminder source="square">',
-        `Mentioned by @${item.act.actor} in \`${displayPath}\``,
-        '',
-        `> ${previewBody(item.act.body).replace(/\n/g, '\n> ')}`,
-        '',
-        'To catch up and keep presence current:',
-        `\`${wakeNowCommand(squarePath, recipient)}\``,
-        '',
-        '*(Async notification from Square.)*',
-        '</system-reminder>',
-    ].join('\n');
-}
-function hasNativeGuarantee(bindings, ownerId) {
-    return bindings.some((binding) => binding.ownerId === ownerId &&
-        (binding.channel === 'claude-code' ||
-            binding.channel === 'codex' ||
-            binding.channel === 'opencode' ||
-            binding.channel === 'pi'));
-}
-function sendPaseoPrompt(agentId, prompt) {
-    const result = spawnSync('paseo', ['send', agentId, '--prompt', prompt, '--no-wait'], {
-        stdio: 'ignore',
-        timeout: 5000,
-    });
+import { spawnSync } from 'node:child_process';
+export function sendPaseoWake({ agentId, prompt }) {
+    const result = spawnSync(process.env.SQUARE_PASEO_BIN || 'paseo', ['send', agentId, '--prompt', prompt, '--no-wait'], { stdio: 'ignore', timeout: 5000, env: process.env });
     if (result.error)
         throw result.error;
     if (result.status !== 0)
         throw new Error(`paseo send exited with ${result.status ?? 'no status'}`);
 }
-// ── paseo agent discovery ────────────────────────────────────────
-/** List all paseo agents. Returns empty array if paseo is unavailable. */
-export function listPaseoAgents() {
-    try {
-        return JSON.parse(execSync('paseo ls --json', {
-            encoding: 'utf8',
-            stdio: ['ignore', 'pipe', 'ignore'],
-        }));
-    }
-    catch {
-        return [];
-    }
-}
-/**
- * Wait for the tool calls that are running now to finish. Calls that start
- * afterward are deliberately ignored: the transitional wake policy allows
- * `paseo send` to replace the next call.
- */
-export async function waitForToolEnd(agentId, timeoutMs) {
-    return waitForPaseoToolBoundary(agentId, {
-        timeoutMs: timeoutMs ?? paseoWakeTimeoutMs(),
-    });
-}
-// ── paseo wake dispatch ──────────────────────────────────────────
-/**
- * Dispatch a paseo send wake prompt for a single notification.
- *
- * Resolves exact Paseo agent ids from the machine-local participant registry.
- * Idle agents receive the wake immediately. Running agents wait for the
- * current tool call boundary; the following `paseo send` may replace the next
- * call by design.
- */
-export function selectPaseoWakeAgents(squarePath, recipient, agents = listPaseoAgents()) {
-    const ids = new Set(lookupParticipant(squarePath, recipient)
-        .map((binding) => binding.paseoAgentId)
-        .filter((id) => id !== undefined));
-    return agents.filter((agent) => ids.has(agent.id) && (agent.status === 'running' || agent.status === 'idle'));
-}
-export async function dispatchPaseoWake(notification, ctx) {
-    const { item, recipient } = notification;
-    const bindings = lookupParticipant(ctx.squarePath, recipient);
-    const activeAgents = selectPaseoWakeAgents(ctx.squarePath, recipient);
-    if (activeAgents.length === 0)
-        return;
-    const wokenOwners = new Set();
-    for (const active of activeAgents) {
-        if (active.status === 'running') {
-            const reachedBoundary = await waitForToolEnd(active.id);
-            if (!reachedBoundary)
-                continue;
-        }
-        // Re-read after the tool wait: harness inject may have presented during the wait.
-        try {
-            const doc = loadSquare(ctx.squarePath);
-            const known = resolveRosterName(doc, recipient) ?? recipient;
-            if (isDeliveryDelivered(doc, known, item.index))
-                return;
-            if (hasPresentedAttention(ctx.squarePath, known, item.index))
-                return;
-        }
-        catch {
-            // Receipt re-read failure fails open toward wake.
-        }
-        const binding = bindings.find((candidate) => candidate.paseoAgentId === active.id);
-        if (binding === undefined || wokenOwners.has(binding.ownerId))
-            continue;
-        try {
-            const catchMembership = sessionInbox(binding.sessionId).find((membership) => membership.name === (resolveRosterName(loadSquare(ctx.squarePath), recipient) ?? recipient) &&
-                membership.catchLease !== undefined &&
-                leaseOwnsNotification(membership.catchLease, {
-                    actor: item.act.actor,
-                    body: item.act.body,
-                    via: notification.via === 'bell' ? 'bell' : 'mention',
-                }));
-            if (catchMembership?.catchLease !== undefined) {
-                if (await waitForCatchDelivery(ctx.squarePath, recipient, notification, binding.ownerId))
-                    return;
-                const current = lookupParticipant(ctx.squarePath, recipient).find((candidate) => candidate.paseoAgentId === active.id);
-                if (current?.ownerId !== binding.ownerId)
-                    continue;
-                const doc = loadSquare(ctx.squarePath);
-                const known = resolveRosterName(doc, recipient) ?? recipient;
-                if (isDeliveryDelivered(doc, known, item.index) ||
-                    hasPresentedAttention(ctx.squarePath, known, item.index)) {
-                    return;
-                }
-            }
-            if (hasNativeGuarantee(bindings, binding.ownerId)) {
-                sendPaseoPrompt(active.id, nativeWakePrompt(ctx.squarePath, recipient));
-                wokenOwners.add(binding.ownerId);
-                continue;
-            }
-            presentOnce(binding.sessionId, (sessionId) => sessionInbox(sessionId)
-                .map((membership) => ({
-                ...membership,
-                notifications: membership.notifications.filter((candidate) => candidate.actIndex === item.index),
-            }))
-                .filter((membership) => membership.notifications.length > 0), () => sendPaseoPrompt(active.id, fullWakePrompt(notification, ctx.squarePath)));
-            wokenOwners.add(binding.ownerId);
-        }
-        catch {
-            // Paseo unavailable: notification remains unpresented for a later retry.
-        }
-    }
-}
-// ── WakeSink factory ─────────────────────────────────────────────
-/** Create the default paseo WakeSink used by both sync and async paths. */
-export function paseoWakeSink() {
-    return {
-        name: 'paseo',
-        dispatch: dispatchPaseoWake,
-    };
-}
-/** Default sink list, respecting SQUARE_DISABLE_PASEO_WAKE. */
-export function defaultWakeSinks() {
-    if (process.env.SQUARE_DISABLE_PASEO_WAKE === '1')
-        return [];
-    return [paseoWakeSink()];
-}

package/dist/watch.js

@@ -1,23 +1,16 @@
 import { setTimeout as sleep } from 'node:timers/promises';
 import { loadSquare } from './artifact.js';
 import { SquareError, nameKey, } from './model.js';
-import { deriveDeliveryModel } from './delivery.js';
-import { SLEEP_MS, STALE_MS, WATCH_HEARTBEAT_MS, WATCH_STALE_MS, countSays, currentHold, doneNames, freshWatchLease, hasQuorum, inSquareCount, markDeliveredMentions, nowMs, readCursor, touchPresenceCursor, } from './runtime.js';
-import { withSquareLock, writeSquareDoc } from './square-store.js';
-import { renderWatchForceTakeover, renderWatchAlreadyActive, renderWatchInterrupted, renderWatchOutput, renderWatchReplaced, renderWatchStatus, participantCommandPrefix, withPathOutput, withWatchNextOutput, } from './presentation.js';
-import { ackPeerDelta, filteredPeerActivities, filteredRoomChanges, indexedDelta, matchesFeedFilter, peerPublicActs, peerRoomChanges, } from './activity-feed.js';
+import { markDeliveredNotifications } from './delivery.js';
+import { SLEEP_MS, STALE_MS, WATCH_HEARTBEAT_MS, WATCH_STALE_MS, countSays, currentHold, doneNames, freshWatchLease, hasQuorum, inSquareCount, nowMs, touchPresenceCursor, writeWatchLease, } from './runtime.js';
+import { withSquareLock, writeSquareDoc } from './square-application.js';
+import { renderWatchForceTakeover, renderWatchAlreadyActive, renderWatchOutput, renderWatchReplaced, renderWatchStatus, participantCommandPrefix, withPathOutput, } from './presentation.js';
+import { ackPeerDelta, deliveryDelta, filteredPeerActivities, filteredRoomChanges, matchesFeedFilter, peerPublicActs, peerRoomChanges, } from './activity-feed.js';
 import { coreParticipants, resolveKnownName } from './decisions.js';
-import { hasAutomaticDeliveryIdentity } from './registry.js';
+import { hasAutomaticDeliveryIdentity, localParticipantOwner } from './registry.js';
 import { execute } from './square-application.js';
-/** Notification receipts are stronger than the public-feed cursor, which self activity may advance. */
 function catchDelta(doc, name) {
-    const items = indexedDelta(doc.acts, readCursor(doc, name));
-    const seen = new Set(items.map((item) => item.index));
-    for (const notification of deriveDeliveryModel(doc).pendingFor(name)) {
-        if (!seen.has(notification.item.index))
-            items.push(notification.item);
-    }
-    return items.sort((a, b) => a.index - b.index);
+    return deliveryDelta(doc, name);
 }
 function watchStatusExitCode(status) {
     return status === 'capped' ? 1 : 0;
@@ -32,21 +25,22 @@ function leaseFilter(opts) {
     };
     return Object.keys(filter).length === 0 ? undefined : filter;
 }
-function setLease(doc, name, id, at, opts) {
+function setLease(doc, name, id, at, opts, ownerId) {
     const filter = leaseFilter(opts);
-    doc.runtime.leases[name] = {
+    writeWatchLease(doc, name, {
         leaseId: id,
+        ...(ownerId === undefined ? {} : { ownerId }),
         heartbeatAt: at,
         expiresAt: at + WATCH_STALE_MS,
         ...(filter ? { filter } : {}),
-    };
+    });
 }
 function sameLease(doc, name, id, at = nowMs()) {
     return freshWatchLease(doc, name, at)?.leaseId === id;
 }
 function consumeDelta(doc, name, delta, delivered, at) {
     const consumed = ackPeerDelta(doc, name, delta);
-    const receipts = markDeliveredMentions(doc, name, delivered, at);
+    const receipts = markDeliveredNotifications(doc, name, delivered, at);
     return consumed || receipts;
 }
 function watchOutputResult(squarePath, doc, name, delta, opts = {}) {
@@ -69,7 +63,7 @@ function loadPresence(squarePath) {
     try {
         const doc = loadSquare(squarePath);
         const now = nowMs();
-        return { participants: coreParticipants(doc, now).participants, now };
+        return { participants: coreParticipants(doc, now), now };
     }
     catch {
         return undefined;
@@ -94,18 +88,54 @@ function writeWatchOutput(squarePath, name, stdout, status, idleMs) {
     const fallback = showCatchHint
         ? `» ${participantCommandPrefix(squarePath, name)} catch --idle 30m\n  stay available for new activity`
         : '';
-    process.stdout.write(withWatchNextOutput(squarePath, [stdout.trimEnd(), fallback].filter(Boolean).join('\n\n'), headerOpts));
+    process.stdout.write(withPathOutput(squarePath, [stdout.trimEnd(), fallback].filter(Boolean).join('\n\n').trimEnd(), headerOpts));
+}
+function writeWatchTerminal(squarePath, name, status, idleMs) {
+    const presence = loadPresence(squarePath);
+    process.stdout.write(withPathOutput(squarePath, renderWatchStatus({
+        status,
+        squarePath,
+        name,
+        ...(idleMs === undefined ? {} : { idleMs }),
+        presence,
+        showCatchHint: !hasAutomaticDeliveryIdentity(),
+    }), { participantCount: loadHeaderCount(squarePath) }));
+}
+function writeWatchReplaced(squarePath, name) {
+    process.stdout.write(withPathOutput(squarePath, renderWatchReplaced({ squarePath, name }), { participantCount: loadHeaderCount(squarePath) }));
+}
+async function finishWatchResult(squarePath, name, result, leaseId, idleMs) {
+    if (result.type === 'output') {
+        await endWatch(squarePath, name, leaseId);
+        writeWatchOutput(squarePath, name, result.stdout, result.status);
+        process.exitCode = watchStatusExitCode(result.status);
+        return true;
+    }
+    if (result.type === 'terminal') {
+        await endWatch(squarePath, name, leaseId);
+        writeWatchTerminal(squarePath, name, result.status, idleMs);
+        process.exitCode = watchStatusExitCode(result.status);
+        return true;
+    }
+    if (result.type === 'replaced') {
+        writeWatchReplaced(squarePath, name);
+        process.exitCode = 0;
+        return true;
+    }
+    return false;
 }
 async function beginWatch(squarePath, name, opts) {
     const at = nowMs();
     const id = leaseId();
+    const ownerId = localParticipantOwner(squarePath, name);
     const committed = await execute(squarePath, {
         type: 'lease',
         name,
         leaseId: id,
+        ...(ownerId === undefined ? {} : { ownerId }),
         at,
         expiresAt: at + WATCH_STALE_MS,
-        force: opts.force,
+        force: opts.replace,
         filter: leaseFilter(opts),
     });
     if (committed.result.type === 'active')
@@ -121,7 +151,7 @@ function installWatchInterruptHandler(squarePath, name, currentLeaseId) {
     const onInterrupt = () => {
         void (async () => {
             await endWatch(squarePath, name, currentLeaseId());
-            process.stdout.write(withPathOutput(squarePath, renderWatchInterrupted({ squarePath, name })));
+            process.stdout.write(withPathOutput(squarePath, '✕ catch stopped'));
             process.exit(130);
         })().catch((error) => {
             process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
@@ -147,7 +177,7 @@ async function cmdWatchNow(squarePath, name, opts) {
     const result = await withSquareLock(squarePath, () => {
         const doc = loadSquare(squarePath);
         const at = nowMs();
-        const touched = touchPresenceCursor(doc, name, at, 'watch');
+        const touched = touchPresenceCursor(doc, name, at);
         const delta = catchDelta(doc, name);
         const peerPublic = peerPublicActs(delta, name);
         const roomChanges = peerRoomChanges(delta, name);
@@ -175,25 +205,7 @@ async function cmdWatchNow(squarePath, name, opts) {
             return { type: 'terminal', status };
         return { type: 'terminal', status: 'empty-now' };
     });
-    if (result.type === 'output') {
-        writeWatchOutput(squarePath, name, result.stdout, result.status);
-        process.exitCode = watchStatusExitCode(result.status);
-        return;
-    }
-    if (result.type === 'terminal') {
-        const presence = loadPresence(squarePath);
-        process.stdout.write(withPathOutput(squarePath, renderWatchStatus({
-            status: result.status,
-            squarePath,
-            name,
-            presence,
-            showCatchHint: !hasAutomaticDeliveryIdentity(),
-        }), {
-            participantCount: loadHeaderCount(squarePath),
-        }));
-        process.exitCode = watchStatusExitCode(result.status);
-        return;
-    }
+    await finishWatchResult(squarePath, name, result, undefined);
 }
 export async function cmdWatch(squarePath, name, opts) {
     let initialDoc;
@@ -214,14 +226,11 @@ export async function cmdWatch(squarePath, name, opts) {
         throw err;
     }
     if (opts.now) {
-        if (opts.activityCount !== 1)
-            process.stderr.write('--count is ignored with --now\n');
         await cmdWatchNow(squarePath, name, opts);
         return;
     }
     const start = await beginWatch(squarePath, name, opts);
     if (start.type === 'active') {
-        const presence = loadPresence(squarePath);
         process.stdout.write(withPathOutput(squarePath, renderWatchAlreadyActive({ squarePath, name }), { participantCount: loadHeaderCount(squarePath) }));
         process.exit(1);
     }
@@ -229,7 +238,6 @@ export async function cmdWatch(squarePath, name, opts) {
     let currentLeaseId = start.leaseId;
     let nextHeartbeatAt = start.heartbeatAt + WATCH_HEARTBEAT_MS;
     if (start.replaced) {
-        const presence = loadPresence(squarePath);
         process.stdout.write(withPathOutput(squarePath, renderWatchForceTakeover({ squarePath, name }), { participantCount: loadHeaderCount(squarePath) }));
     }
     const idleMs = opts.idleMs ?? STALE_MS;
@@ -239,12 +247,13 @@ export async function cmdWatch(squarePath, name, opts) {
             const result = await withSquareLock(squarePath, () => {
                 const doc = loadSquare(squarePath);
                 const at = nowMs();
-                if (!sameLease(doc, name, currentLeaseId, at))
+                const lease = freshWatchLease(doc, name, at);
+                if (lease === undefined || lease.leaseId !== currentLeaseId)
                     return { type: 'replaced' };
                 let mutated = false;
                 if (at >= nextHeartbeatAt) {
-                    setLease(doc, name, currentLeaseId, at, opts);
-                    mutated = touchPresenceCursor(doc, name, at, 'watch') || mutated;
+                    setLease(doc, name, currentLeaseId, at, opts, lease.ownerId);
+                    mutated = touchPresenceCursor(doc, name, at) || mutated;
                     nextHeartbeatAt = at + WATCH_HEARTBEAT_MS;
                     mutated = true;
                 }
@@ -263,7 +272,7 @@ export async function cmdWatch(squarePath, name, opts) {
                 }
                 if (hasDeliverable &&
                     hasFilteredDeliverable &&
-                    (filteredActivities.length >= opts.activityCount || matchingRoomChanges.length > 0 || status !== undefined)) {
+                    (filteredActivities.length > 0 || matchingRoomChanges.length > 0 || status !== undefined)) {
                     return watchOutputResult(squarePath, doc, name, delta, {
                         participants: opts.participants,
                         mention: opts.mention,
@@ -281,49 +290,12 @@ export async function cmdWatch(squarePath, name, opts) {
                     writeSquareDoc(squarePath, doc);
                 return { type: 'sleep' };
             });
-            switch (result.type) {
-                case 'output': {
-                    const status = result.status;
-                    if (opts.follow === true && status === undefined) {
-                        writeWatchOutput(squarePath, name, result.stdout);
-                        staleSince = nowMs();
-                        break;
-                    }
-                    await endWatch(squarePath, name, currentLeaseId);
-                    currentLeaseId = undefined;
-                    writeWatchOutput(squarePath, name, result.stdout, status);
-                    process.exitCode = watchStatusExitCode(status);
-                    return;
-                }
-                case 'terminal':
-                    await endWatch(squarePath, name, currentLeaseId);
-                    currentLeaseId = undefined;
-                    const presence = loadPresence(squarePath);
-                    process.stdout.write(withPathOutput(squarePath, renderWatchStatus({
-                        status: result.status,
-                        squarePath,
-                        name,
-                        presence,
-                        showCatchHint: !hasAutomaticDeliveryIdentity(),
-                    }), {
-                        participantCount: loadHeaderCount(squarePath),
-                    }));
-                    process.exitCode = watchStatusExitCode(result.status);
-                    return;
-                case 'replaced':
-                    currentLeaseId = undefined;
-                    {
-                        const presence = loadPresence(squarePath);
-                        process.stdout.write(withPathOutput(squarePath, renderWatchReplaced({ squarePath, name }), { participantCount: loadHeaderCount(squarePath) }));
-                    }
-                    process.exitCode = 0;
-                    return;
-                case 'sleep':
-                    break;
-                case 'held':
-                    staleSince = nowMs();
-                    break;
+            if (await finishWatchResult(squarePath, name, result, currentLeaseId)) {
+                currentLeaseId = undefined;
+                return;
             }
+            if (result.type === 'held')
+                staleSince = nowMs();
             if (nowMs() - staleSince >= idleMs) {
                 const result = await withSquareLock(squarePath, () => {
                     const doc = loadSquare(squarePath);
@@ -341,37 +313,8 @@ export async function cmdWatch(squarePath, name, opts) {
                     }
                     return { type: 'terminal', status: 'stale' };
                 });
-                if (result.type === 'replaced') {
-                    currentLeaseId = undefined;
-                    {
-                        const presence = loadPresence(squarePath);
-                        process.stdout.write(withPathOutput(squarePath, renderWatchReplaced({ squarePath, name }), { participantCount: loadHeaderCount(squarePath) }));
-                    }
-                    process.exitCode = 0;
-                    return;
-                }
-                if (result.type === 'output') {
-                    await endWatch(squarePath, name, currentLeaseId);
-                    currentLeaseId = undefined;
-                    writeWatchOutput(squarePath, name, result.stdout, result.status);
-                    process.exitCode = 0;
-                    return;
-                }
-                if (result.type === 'terminal') {
-                    await endWatch(squarePath, name, currentLeaseId);
+                if (await finishWatchResult(squarePath, name, result, currentLeaseId, idleMs)) {
                     currentLeaseId = undefined;
-                    const presence = loadPresence(squarePath);
-                    process.stdout.write(withPathOutput(squarePath, renderWatchStatus({
-                        status: result.status,
-                        squarePath,
-                        name,
-                        idleMs,
-                        presence,
-                        showCatchHint: !hasAutomaticDeliveryIdentity(),
-                    }), {
-                        participantCount: loadHeaderCount(squarePath),
-                    }));
-                    process.exitCode = watchStatusExitCode(result.status);
                     return;
                 }
             }

package/extensions/square-opencode.js

@@ -1,87 +1,22 @@
-import {
-  deferToActiveCatch,
-  opencodeHookResponse,
-  renderClaudeInboxContext,
-} from '../dist/claude-hook.js';
-import { sessionInbox } from '../dist/inbox.js';
-import { presentOnce } from '../dist/presented.js';
-
-function pendingSignature(sessionId) {
-  const keys = sessionInbox(sessionId).flatMap((membership) =>
-    membership.notifications.map(
-      (notification) =>
-        `${membership.squarePath}\u0000${membership.name.toLocaleLowerCase()}\u0000${notification.actIndex}`
-    )
-  );
-  return keys.sort().join('\n');
-}
-
-const IDLE_WAKE = [
-  '<system-reminder source="square">',
-  'Square activity is waiting. Process the Square context injected into this turn, then run its catch command.',
-  '</system-reminder>',
-].join('\n');
-
-export default async function squareOpenCodePlugin({ client }) {
-  const handledAtIdle = new Map();
+import { presentPendingAtBoundary } from '../dist/boundary-presentation.js';
 
+export default async function squareOpenCodePlugin() {
   return {
     'shell.env': async (input, output) => {
       if (input.sessionID) output.env.OPENCODE_SESSION_ID = input.sessionID;
     },
 
-    'experimental.chat.system.transform': async (input, output) => {
-      if (!input.sessionID) return;
+    'tool.execute.after': async (input, output) => {
       try {
-        // Membership comes only from explicit join/act/catch claims, never env inheritance.
-        presentOnce(
+        presentPendingAtBoundary(
           input.sessionID,
-          (sessionId) => deferToActiveCatch(sessionInbox(sessionId)),
-          (inbox) => output.system.push(renderClaudeInboxContext(inbox))
+          (context) => {
+            output.output = `${output.output}${output.output === '' ? '' : '\n\n'}${context}`;
+          }
         );
-
-        const signature = pendingSignature(input.sessionID);
-        if (signature === '') handledAtIdle.delete(input.sessionID);
-        else handledAtIdle.set(input.sessionID, signature);
-      } catch {
-        // Adapter failures leave attention unpresented for a later boundary.
-      }
-    },
-
-    event: async ({ event }) => {
-      if (event.type !== 'session.idle') return;
-      const sessionId = event.properties.sessionID;
-      try {
-        const signature = pendingSignature(sessionId);
-        if (signature === '') {
-          handledAtIdle.delete(sessionId);
-          return;
-        }
-        if (handledAtIdle.get(sessionId) === signature) return;
-
-        const response = opencodeHookResponse({
-          session_id: sessionId,
-          hook_event_name: 'Stop',
-          stop_hook_active: false,
-        });
-        if (response?.decision !== 'block') return;
-
-        handledAtIdle.set(sessionId, signature);
-        try {
-          await client.session.promptAsync({
-            path: { id: sessionId },
-            body: { parts: [{ type: 'text', text: IDLE_WAKE }] },
-          });
-        } catch {
-          handledAtIdle.delete(sessionId);
-        }
       } catch {
-        // Idle acceleration is best-effort and must not break the host session.
+        // A failed admission remains available at a later boundary.
       }
     },
-
-    dispose: async () => {
-      handledAtIdle.clear();
-    },
   };
 }