@astrosheep/square 0.3.6 → 0.3.8

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

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

package/codex-plugin/hooks/hooks.json

@@ -1,25 +1,14 @@
 {
   "hooks": {
-    "UserPromptSubmit": [
+    "PostToolUse": [
       {
         "hooks": [
           {
             "type": "command",
             "command": "square codex-hook",
             "timeout": 5,
-            "statusMessage": "square-codex-hook"
-          }
-        ]
-      }
-    ],
-    "Stop": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "command": "square codex-hook",
-            "timeout": 5,
-            "statusMessage": "square-codex-hook"
+            "statusMessage": "square-codex-hook",
+            "additionalContextLimit": 1200
           }
         ]
       }

package/dist/activity.js

@@ -75,6 +75,7 @@ export async function cmdActivity(squarePath, name, activity, resolveBody, opts)
             force,
             now: nowMs(),
             ...(reach === undefined ? {} : { reach }),
+            ...(opts.reply === undefined ? {} : { reply: opts.reply }),
         });
         const decision = committed.result;
         const freshDoc = loadSquare(squarePath);

package/dist/artifact.js

@@ -43,6 +43,7 @@ function renderActMarker(act) {
         actor: act.actor,
         at: act.at,
         ...(act.kind === 'say' && act.reach !== undefined ? { reach: act.reach } : {}),
+        ...(act.kind === 'say' && act.reply !== undefined ? { reply: act.reply } : {}),
     };
     return `${ACT_MARKER_PREFIX} ${JSON.stringify(marker)} -->`;
 }
@@ -410,8 +411,15 @@ export function parseActMarker(line) {
         ...(typeof parsed.actor === 'string' ? { actor: parsed.actor } : {}),
         ...(typeof parsed.at === 'number' && Number.isFinite(parsed.at) ? { at: parsed.at } : {}),
         ...(parsed.reach !== undefined ? { reach: parseReach(parsed.reach) } : {}),
+        ...(parsed.reply !== undefined ? { reply: parseReply(parsed.reply) } : {}),
     };
 }
+function parseReply(value) {
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 0) {
+        throw new SquareError('invalid_args', 'Invalid square: malformed act reply metadata.');
+    }
+    return value;
+}
 function normalizeActMeta(marker, kind, actor, head) {
     if (marker.kind === undefined || marker.actor === undefined) {
         throw new SquareError('invalid_args', 'Invalid square: act marker is missing kind/actor metadata.');
@@ -428,7 +436,10 @@ function normalizeActMeta(marker, kind, actor, head) {
     if (marker.at !== head.at) {
         throw new SquareError('invalid_args', `Invalid square: act marker timestamp does not match ${kind} ${actor}.`);
     }
-    return { index: marker.index, ...(marker.reach !== undefined ? { reach: marker.reach } : {}) };
+    if (marker.reply !== undefined && kind !== 'say') {
+        throw new SquareError('invalid_args', 'Invalid square: only say acts may reply to another activity.');
+    }
+    return { index: marker.index, ...(marker.reach !== undefined ? { reach: marker.reach } : {}), ...(marker.reply !== undefined ? { reply: marker.reply } : {}) };
 }
 export function activitiesSourceLines(text) {
     const lines = text.split('\n');
@@ -479,7 +490,7 @@ function parseActBlock(blockLines) {
             i++;
         body = unquoteBody(blockLines.slice(i));
     }
-    return { ...head, body, index: meta.index, ...(meta.reach !== undefined ? { reach: meta.reach } : {}) };
+    return { ...head, body, index: meta.index, ...(meta.reach !== undefined ? { reach: meta.reach } : {}), ...(meta.reply !== undefined ? { reply: meta.reply } : {}) };
 }
 function parseActs(text) {
     const lines = activitiesSourceLines(text);

package/dist/boundary-presentation.js

@@ -0,0 +1,77 @@
+import { leaseOwnsNotification, notificationMessageId } from './delivery.js';
+import { sessionInbox } from './inbox.js';
+import { participantCommandPrefix } from './presentation.js';
+import { presentOnce } from './presented.js';
+const BODY_MAX = 200;
+const CONTEXT_MAX = 1200;
+function pendingCount(inbox) {
+    return inbox.reduce((total, membership) => total + membership.notifications.length, 0);
+}
+/** A fresh blocking catch owns only the notifications admitted by its filter. */
+export function pendingAtBoundary(inbox) {
+    return inbox
+        .map((membership) => {
+        const lease = membership.catchLease;
+        if (lease === undefined)
+            return membership;
+        return {
+            ...membership,
+            notifications: membership.notifications.filter((notification) => !leaseOwnsNotification(lease, { ...notification, recipient: membership.name })),
+        };
+    })
+        .filter((membership) => membership.notifications.length > 0);
+}
+function bodyPreview(body) {
+    const compact = body.replace(/\r\n/g, '\n');
+    if (compact.length <= BODY_MAX)
+        return compact;
+    return `${compact.slice(0, BODY_MAX).trimEnd()}\n… [truncated; run catch --now]`;
+}
+export function renderPendingAtBoundary(inbox) {
+    const count = pendingCount(inbox);
+    const noun = count === 1 ? 'notification' : 'notifications';
+    const header = `<system-reminder source="square">You have ${count} unread Square ${noun}.`;
+    const footer = [
+        'Ids are stable across boundaries. If you already acted on an id, do not repeat the action; still run catch --now to mark delivered.',
+        'Read and respond in the square when appropriate.</system-reminder>',
+    ];
+    const queued = inbox.flatMap((membership) => membership.notifications.map((notification) => ({ membership, notification })));
+    const blocks = [];
+    let omitted = 0;
+    for (const [index, entry] of queued.entries()) {
+        const { membership, notification } = entry;
+        const command = `${participantCommandPrefix(membership.squarePath, membership.name)} catch --now`;
+        const id = notificationMessageId(membership.squarePath, notification.actIndex);
+        const block = [
+            `${id} · ${membership.squarePath}: @${membership.name} from @${notification.actor} (${notification.route})`,
+            bodyPreview(notification.body),
+            `Ack with: ${command}`,
+        ].join('\n');
+        const omittedAfter = omitted + queued.length - index - 1;
+        const prospective = [
+            header,
+            ...blocks,
+            block,
+            ...(omittedAfter > 0
+                ? [`… ${omittedAfter} unread ${omittedAfter === 1 ? 'notification' : 'notifications'} omitted. Run catch --now to receive them.`]
+                : []),
+            ...footer,
+        ].join('\n');
+        if (prospective.length > CONTEXT_MAX) {
+            omitted += 1;
+            continue;
+        }
+        blocks.push(block);
+    }
+    return [
+        header,
+        ...blocks,
+        ...(omitted > 0
+            ? [`… ${omitted} unread ${omitted === 1 ? 'notification' : 'notifications'} omitted. Run catch --now to receive them.`]
+            : []),
+        ...footer,
+    ].join('\n');
+}
+export function presentPendingAtBoundary(sessionId, present, lookup = sessionInbox, env = process.env) {
+    return presentOnce(sessionId, (id) => pendingAtBoundary(lookup(id)), (inbox) => present(renderPendingAtBoundary(inbox)), env);
+}

package/dist/claude-hook.js

@@ -1,112 +1,11 @@
-import { leaseOwnsNotification } from './delivery.js';
-import { notificationMessageId } from './delivery.js';
+import { presentPendingAtBoundary } from './boundary-presentation.js';
 import { sessionInbox } from './inbox.js';
-import { participantCommandPrefix } from './presentation.js';
-import { presentOnce } from './presented.js';
-function pendingCount(inbox) {
-    return inbox.reduce((total, membership) => total + membership.notifications.length, 0);
-}
-const INJECT_BODY_MAX = 200;
-const INJECT_TOTAL_MAX = 1200;
-/** Let a fresh blocking catch own notifications it can deliver; hook injection remains the fallback. */
-export function deferToActiveCatch(inbox) {
-    return inbox
-        .map((membership) => {
-        const lease = membership.catchLease;
-        if (lease === undefined)
-            return membership;
-        return {
-            ...membership,
-            notifications: membership.notifications.filter((notification) => !leaseOwnsNotification(lease, { ...notification, recipient: membership.name })),
-        };
-    })
-        .filter((membership) => membership.notifications.length > 0);
-}
-function injectBodyPreview(body) {
-    const compact = body.replace(/\r\n/g, '\n');
-    if (compact.length <= INJECT_BODY_MAX)
-        return compact;
-    return `${compact.slice(0, INJECT_BODY_MAX).trimEnd()}\n… [truncated; run catch --now]`;
-}
-export function renderClaudeInboxContext(inbox) {
-    const count = pendingCount(inbox);
-    const noun = count === 1 ? 'notification' : 'notifications';
-    const header = `<system-reminder source="square">You have ${count} unread Square ${noun}.`;
-    const footer = [
-        // Body here is a cache only. Delivered is written solely by catch.
-        'Ids are stable across turns. If you already acted on an id, do not repeat the action; still run catch --now to mark delivered.',
-        'Read and respond in the square before finishing the current turn.</system-reminder>',
-    ];
-    const queued = inbox.flatMap((membership) => membership.notifications.map((notification) => ({ membership, notification })));
-    const blocks = [];
-    let omitted = 0;
-    for (const [index, entry] of queued.entries()) {
-        const { membership, notification } = entry;
-        const command = `${participantCommandPrefix(membership.squarePath, membership.name)} catch --now`;
-        const id = notificationMessageId(membership.squarePath, notification.actIndex);
-        const block = [
-            `${id} · ${membership.squarePath}: @${membership.name} from @${notification.actor} (${notification.route})`,
-            injectBodyPreview(notification.body),
-            `Ack with: ${command}`,
-        ].join('\n');
-        const omittedAfter = omitted + queued.length - index - 1;
-        const prospective = [
-            header,
-            ...blocks,
-            block,
-            ...(omittedAfter > 0
-                ? [`… ${omittedAfter} unread ${omittedAfter === 1 ? 'notification' : 'notifications'} omitted. Run catch --now to receive them.`]
-                : []),
-            ...footer,
-        ].join('\n');
-        if (prospective.length > INJECT_TOTAL_MAX) {
-            omitted += 1;
-            continue;
-        }
-        blocks.push(block);
-    }
-    return [
-        header,
-        ...blocks,
-        ...(omitted > 0
-            ? [`… ${omitted} unread ${omitted === 1 ? 'notification' : 'notifications'} omitted. Run catch --now to receive them.`]
-            : []),
-        ...footer,
-    ].join('\n');
-}
-function nativeHookResponse(input, lookup, env) {
+export function claudeHookResponse(input, lookup = sessionInbox, env = process.env) {
     if (typeof input.session_id !== 'string' || input.session_id === '')
         return undefined;
-    if (input.hook_event_name !== 'UserPromptSubmit' && input.hook_event_name !== 'Stop') {
+    if (input.hook_event_name !== 'PostToolBatch')
         return undefined;
-    }
-    if (input.hook_event_name === 'Stop' && input.stop_hook_active === true)
-        return undefined;
-    // Delivery membership is only claimed by explicit participant actions (join/express/catch/...).
-    // Inherited PASEO_AGENT_ID proves process ancestry, not conversational ownership.
-    // Stop is the guaranteed "don't leave while undelivered" nudge; it does not consume presentation.
-    if (input.hook_event_name === 'Stop') {
-        const pending = lookup(input.session_id).filter((membership) => membership.notifications.length > 0);
-        if (pendingCount(pending) === 0)
-            return undefined;
-        return { decision: 'block', reason: renderClaudeInboxContext(pending) };
-    }
-    return presentOnce(input.session_id, (sessionId) => deferToActiveCatch(lookup(sessionId)), (inbox) => ({
-        hookSpecificOutput: {
-            hookEventName: 'UserPromptSubmit',
-            additionalContext: renderClaudeInboxContext(inbox),
-        },
-    }), env);
-}
-export function claudeHookResponse(input, lookup = sessionInbox, env = process.env) {
-    return nativeHookResponse(input, lookup, env);
-}
-/** Codex shares Claude's turn-boundary protocol; keep a dedicated command for churn isolation. */
-export function codexHookResponse(input, lookup = sessionInbox, env = process.env) {
-    return nativeHookResponse(input, lookup, env);
-}
-export function opencodeHookResponse(input, lookup = sessionInbox, env = process.env) {
-    return nativeHookResponse(input, lookup, env);
+    return presentPendingAtBoundary(input.session_id, (context) => ({ hookSpecificOutput: { hookEventName: 'PostToolBatch', additionalContext: context } }), lookup, env);
 }
 export function runClaudeHook(inputText, env = process.env) {
     let input;
@@ -121,16 +20,3 @@ export function runClaudeHook(inputText, env = process.env) {
     const response = claudeHookResponse(input, sessionInbox, env);
     return response === undefined ? '' : `${JSON.stringify(response)}\n`;
 }
-export function runCodexHook(inputText, env = process.env) {
-    let input;
-    try {
-        input = JSON.parse(inputText);
-    }
-    catch {
-        return '';
-    }
-    if (input === null || typeof input !== 'object')
-        return '';
-    const response = codexHookResponse(input, sessionInbox, env);
-    return response === undefined ? '' : `${JSON.stringify(response)}\n`;
-}

package/dist/cli/observation-commands.js

@@ -1,5 +1,6 @@
 import { loadSquare } from '../artifact.js';
-import { runClaudeHook, runCodexHook } from '../claude-hook.js';
+import { runClaudeHook } from '../claude-hook.js';
+import { runCodexHook } from '../codex-hook.js';
 import { coreActivities, coreParticipants, coreStatus } from '../decisions.js';
 import { sessionInbox } from '../inbox.js';
 import { cmdListSquares } from '../list.js';
@@ -263,6 +264,7 @@ function renderFields(doc, item, fields) {
             case 'kind': return item.kind;
             case 'body': return 'body' in item && typeof item.body === 'string' ? item.body.replace(/\s+/g, ' ').trim() : '';
             case 'number': return item.kind === 'say' ? String(sayNumberFor(doc.acts, item)) : '';
+            case 'reply': return item.kind === 'say' && item.reply !== undefined ? actId(item.reply) : '';
             default: return '';
         }
     }).join('\t');
@@ -279,6 +281,7 @@ function jsonLine(doc, item) {
         body: 'body' in act && typeof act.body === 'string' ? act.body : '',
         number: act.kind === 'say' ? sayNumberFor(doc.acts, act) : null,
         reach: act.kind === 'say' ? act.reach ?? null : null,
+        reply: act.kind === 'say' && act.reply !== undefined ? actId(act.reply) : null,
     });
 }
 export const historyCommand = {

package/dist/cli/square-commands.js

@@ -116,6 +116,7 @@ function parseActivity(argv, context) {
     let noWait = false;
     let beside;
     let bell = false;
+    let reply;
     const bodyArgs = [];
     for (let index = 0; index < argv.length; index++) {
         const argument = argv[index];
@@ -129,6 +130,13 @@ function parseActivity(argv, context) {
         }
         else if (argument === '--bell')
             bell = true;
+        else if (argument === '--reply') {
+            const value = requireValue(argv, index, argument).trim().match(/^(?:act_)?(\d+)$/i);
+            if (!value || !Number.isSafeInteger(Number(value[1])))
+                fail('Invalid --reply: expected an activity id like act_12 or 12.');
+            reply = Number(value[1]);
+            index += 1;
+        }
         else
             bodyArgs.push(argument);
     }
@@ -139,11 +147,11 @@ function parseActivity(argv, context) {
         if (bodyArgs.length === 0) {
             const piped = readPipedBodyFallback();
             if (piped !== undefined)
-                return { name: requireParticipant(context.name), activity: piped, force, noWait, reach };
+                return { name: requireParticipant(context.name), activity: piped, force, noWait, reach, reply };
         }
         fail("express requires a body argument (a quoted string or '-' with piped stdin)");
     }
-    return { name: requireParticipant(context.name), activity: bodyArgs[0], force, noWait, reach };
+    return { name: requireParticipant(context.name), activity: bodyArgs[0], force, noWait, reach, reply };
 }
 export const expressCommand = {
     parse: parseActivity,
@@ -153,7 +161,8 @@ export const expressCommand = {
             force: intent.force,
             noWait: intent.noWait,
             reach: intent.reach,
-            forceCommand: `${participantCommandPrefix(context.squarePath, intent.name)} express --force${reachArg} -`,
+            reply: intent.reply,
+            forceCommand: `${participantCommandPrefix(context.squarePath, intent.name)} express --force${reachArg}${intent.reply === undefined ? '' : ` --reply act_${intent.reply}`} -`,
         });
     },
     present: () => { },

package/dist/codex-hook.js

@@ -0,0 +1,22 @@
+import { presentPendingAtBoundary } from './boundary-presentation.js';
+import { sessionInbox } from './inbox.js';
+export function codexHookResponse(input, lookup = sessionInbox, env = process.env) {
+    if (typeof input.session_id !== 'string' || input.session_id === '')
+        return undefined;
+    if (input.hook_event_name !== 'PostToolUse')
+        return undefined;
+    return presentPendingAtBoundary(input.session_id, (context) => ({ hookSpecificOutput: { hookEventName: 'PostToolUse', additionalContext: context } }), lookup, env);
+}
+export function runCodexHook(inputText, env = process.env) {
+    let input;
+    try {
+        input = JSON.parse(inputText);
+    }
+    catch {
+        return '';
+    }
+    if (input === null || typeof input !== 'object')
+        return '';
+    const response = codexHookResponse(input, sessionInbox, env);
+    return response === undefined ? '' : `${JSON.stringify(response)}\n`;
+}

package/dist/decisions.js

@@ -38,9 +38,15 @@ export function decideAct(doc, input) {
     if (body.trim() === '')
         throw new SquareError('invalid_args', 'express body cannot be empty');
     const reach = input.reach;
+    const reply = input.reply;
+    if (reply !== undefined) {
+        if (!Number.isSafeInteger(reply) || reply < 0 || reply >= doc.runtime.nextActIndex) {
+            throw new SquareError('invalid_args', `Unknown reply activity: act_${reply}`);
+        }
+    }
     const state = foldedState(doc);
     const current = participantState(state, name);
-    const result = validate(state, { kind: 'say', actor: name, at: now, body, ...(reach !== undefined ? { reach } : {}) }, { hardCap: doc.hardCap, throttlePerMinute: doc.throttlePerMinute, throttleWindowMs: THROTTLE_WINDOW_MS });
+    const result = validate(state, { kind: 'say', actor: name, at: now, body, ...(reach !== undefined ? { reach } : {}), ...(reply !== undefined ? { reply } : {}) }, { hardCap: doc.hardCap, throttlePerMinute: doc.throttlePerMinute, throttleWindowMs: THROTTLE_WINDOW_MS });
     if (!result.ok) {
         if (result.reason === 'done')
             throw new SquareError('conflict', `${name} is done; rejoin to express again`);
@@ -95,7 +101,7 @@ export function decideAct(doc, input) {
     const ownActCount = (current?.activityCount ?? 0) + 1;
     return {
         type: 'sent',
-        act: { kind: 'say', actor: name, at: now, body, ...(reach !== undefined ? { reach } : {}) },
+        act: { kind: 'say', actor: name, at: now, body, ...(reach !== undefined ? { reach } : {}), ...(reply !== undefined ? { reply } : {}) },
         confirmation: `● heads turn your way — #${ownActCount}`,
         ownActCount,
         pendingPublic: unreadPublic,

package/dist/harness-claude.js

@@ -33,6 +33,7 @@ export async function installClaudePlugin(homeDir, run = runClaude) {
         fs.cpSync(fileURLToPath(new URL('../skills/square/', import.meta.url)), plugin, { recursive: true });
         writeJson(path.join(stage, '.claude-plugin', 'marketplace.json'), {
             name: CLAUDE_MARKETPLACE_NAME,
+            owner: { name: 'Square' },
             plugins: [{ name: SQUARE_IDENTITY.pluginName, source: './plugins/square' }],
         });
     });

package/dist/harness-codex.js

@@ -12,8 +12,33 @@ const LEGACY_MARKETPLACES = ['astrosheep-square'];
 export function codexMarketplaceRoot(homeDir) {
     return path.join(homeDir, '.square', 'codex', 'marketplaces', CODEX_MARKETPLACE_NAME);
 }
-export function codexPluginRoot(homeDir) { return path.join(codexMarketplaceRoot(homeDir), 'plugins', SQUARE_IDENTITY.pluginName); }
-export function codexPluginHooksPath(homeDir) { return path.join(codexPluginRoot(homeDir), 'hooks', 'hooks.json'); }
+function configuredMarketplaceRoot(homeDir, configText) {
+    const lines = configText.split('\n');
+    const header = `[marketplaces.${CODEX_MARKETPLACE_NAME}]`;
+    const start = lines.findIndex((line) => line.trim() === header);
+    if (start < 0)
+        return undefined;
+    const end = lines.findIndex((line, index) => index > start && /^\s*\[[^\]]+\]/.test(line));
+    const section = lines.slice(start + 1, end < 0 ? undefined : end);
+    const sourceType = section.find((line) => /^\s*source_type\s*=/.test(line));
+    if (sourceType && !/=\s*["']local["']\s*$/.test(sourceType))
+        return undefined;
+    const source = section.find((line) => /^\s*source\s*=/.test(line));
+    const match = source?.match(/^\s*source\s*=\s*("(?:\\.|[^"])*"|'[^']*')\s*$/);
+    if (!match)
+        return undefined;
+    const value = match[1].startsWith('"') ? JSON.parse(match[1]) : match[1].slice(1, -1);
+    return path.isAbsolute(value) ? value : path.resolve(codexHome(homeDir), value);
+}
+function activeMarketplaceRoot(homeDir, configText) {
+    return configuredMarketplaceRoot(homeDir, configText) ?? codexMarketplaceRoot(homeDir);
+}
+export function codexPluginRoot(homeDir, marketplaceRoot = codexMarketplaceRoot(homeDir)) {
+    return path.join(marketplaceRoot, 'plugins', SQUARE_IDENTITY.pluginName);
+}
+export function codexPluginHooksPath(homeDir, marketplaceRoot = codexMarketplaceRoot(homeDir)) {
+    return path.join(codexPluginRoot(homeDir, marketplaceRoot), 'hooks', 'hooks.json');
+}
 function codexHome(homeDir) { return path.join(homeDir, '.codex'); }
 export function codexHomeHooksPath(homeDir) { return path.join(codexHome(homeDir), 'hooks.json'); }
 export function codexConfigPath(homeDir) { return path.join(codexHome(homeDir), 'config.toml'); }
@@ -53,9 +78,9 @@ function writeAtomic(file, text) {
     fs.renameSync(temp, file);
 }
 export async function installCodexPlugin(homeDir, run = runCodex) {
-    const root = codexMarketplaceRoot(homeDir);
     const config = codexConfigPath(homeDir);
     const current = fs.existsSync(config) ? fs.readFileSync(config, 'utf8') : '';
+    const root = activeMarketplaceRoot(homeDir, current);
     const staged = stageReplacement(root, (stage) => {
         const plugin = path.join(stage, 'plugins', SQUARE_IDENTITY.pluginName);
         fs.cpSync(fileURLToPath(new URL('../codex-plugin/', import.meta.url)), plugin, { recursive: true });
@@ -88,7 +113,7 @@ export async function installCodexPlugin(homeDir, run = runCodex) {
             notes.push(`retired ${pluginId}`);
         }
         staged.finalize();
-        return { configPath: config, marketplaceRoot: root, pluginRoot: codexPluginRoot(homeDir), ...(installedPath ? { installedPath } : {}), notes };
+        return { configPath: config, marketplaceRoot: root, pluginRoot: codexPluginRoot(homeDir, root), ...(installedPath ? { installedPath } : {}), notes };
     }
     catch (error) {
         staged.rollback();
@@ -96,24 +121,27 @@ export async function installCodexPlugin(homeDir, run = runCodex) {
     }
 }
 export async function uninstallCodexPlugin(homeDir, run = runCodex) {
+    const config = codexConfigPath(homeDir);
+    const current = fs.existsSync(config) ? fs.readFileSync(config, 'utf8') : '';
+    const root = activeMarketplaceRoot(homeDir, current);
     requireSuccess(run(homeDir, ['plugin', 'remove', CODEX_PLUGIN_ID, '--json']), 'plugin removal', true);
     requireSuccess(run(homeDir, ['plugin', 'marketplace', 'remove', CODEX_MARKETPLACE_NAME, '--json']), 'marketplace removal', true);
     for (const marketplace of LEGACY_MARKETPLACES) {
         requireSuccess(run(homeDir, ['plugin', 'remove', `${SQUARE_IDENTITY.pluginName}@${marketplace}`, '--json']), 'legacy plugin removal', true);
         requireSuccess(run(homeDir, ['plugin', 'marketplace', 'remove', marketplace, '--json']), 'legacy marketplace removal', true);
     }
-    const root = codexMarketplaceRoot(homeDir);
     fs.rmSync(root, { recursive: true, force: true });
     fs.rmSync(codexHomeHooksPath(homeDir), { force: true });
     return { paths: [root, codexConfigPath(homeDir), codexHomeHooksPath(homeDir)], notes: [] };
 }
 export async function doctorCodexPlugin(homeDir, run = runCodex) {
-    const root = codexMarketplaceRoot(homeDir);
     const config = codexConfigPath(homeDir);
+    const current = fs.existsSync(config) ? fs.readFileSync(config, 'utf8') : '';
+    const root = activeMarketplaceRoot(homeDir, current);
     const listed = run(homeDir, ['plugin', 'list', '--json']);
     return [
-        /^hooks\s*=\s*true$/m.test(fs.existsSync(config) ? fs.readFileSync(config, 'utf8') : '') ? `✓ features.hooks=true in ${config}` : `○ features.hooks missing in ${config}`,
-        fs.existsSync(codexPluginHooksPath(homeDir)) ? `✓ Square plugin hooks ${codexPluginHooksPath(homeDir)}` : `○ Square plugin bundle missing ${root}`,
+        /^hooks\s*=\s*true$/m.test(current) ? `✓ features.hooks=true in ${config}` : `○ features.hooks missing in ${config}`,
+        fs.existsSync(codexPluginHooksPath(homeDir, root)) ? `✓ Square plugin hooks ${codexPluginHooksPath(homeDir, root)}` : `○ Square plugin bundle missing ${root}`,
         listed.status === 0 && listed.stdout.includes(CODEX_PLUGIN_ID) ? `✓ ${CODEX_PLUGIN_ID} installed` : `○ ${CODEX_PLUGIN_ID} unavailable`,
     ];
 }

package/dist/help.js

@@ -16,9 +16,9 @@ const COMMANDS = [
         details: ['Options:', '  --last <N>  Show the last N public activities (default 10).', '  --all       Show the complete history.'],
     },
     {
-        names: ['express'], usage: '--as <name> express [-f|--force] [--no-wait] [--beside <name> | --bell] <activity | ->', usesSquare: true, group: 'participant',
+        names: ['express'], usage: '--as <name> express [-f|--force] [--no-wait] [--beside <name> | --bell] [--reply <act_N>] <activity | ->', usesSquare: true, group: 'participant',
         summary: 'Speak, gesture, or do both.',
-        details: ['Options:', '  -f, --force       Express without first catching unread activity.', '  --no-wait         If held or throttled, save a draft and return.', '  --beside <name>   Speak aside to one participant.', "  --bell            Call every participant's attention to this activity."],
+        details: ['Options:', '  -f, --force       Express without first catching unread activity.', '  --no-wait         If held or throttled, save a draft and return.', '  --beside <name>   Speak aside to one participant.', "  --bell            Call every participant's attention to this activity.", '  --reply <act_N>   Mark this activity as a reply to an earlier activity.'],
     },
     {
         names: ['catch'], usage: '--as <name> catch (--now | --idle <duration>) [--from <names>] [--mention [name]] [--replace]', usesSquare: true, group: 'participant',
@@ -36,7 +36,7 @@ const COMMANDS = [
         summary: 'Inspect bounded machine-local notifications for a native session.',
         details: ['Options:', '  --for-session <id>  Required harness session id.', '  --json              Emit structured JSON.'],
     },
-    { names: ['claude-hook', 'codex-hook'], usage: '{command}', summary: 'Run one native turn-boundary hook event from JSON on stdin.', hiddenFromIndex: true },
+    { names: ['claude-hook', 'codex-hook'], usage: '{command}', summary: 'Present pending attention at one native agent boundary.', hiddenFromIndex: true },
     {
         names: ['history'], usage: '[--as <name>] history [filters] [output]', usesSquare: true, group: 'participant',
         summary: 'Read or search what happened without changing what you have caught.',

package/dist/index.js

@@ -58,6 +58,7 @@ export async function express(squarePath, name, body, opts = {}) {
         body,
         force: opts.force ?? false,
         now: Date.now(),
+        ...(opts.reply === undefined ? {} : { reply: actRefIndex(opts.reply) }),
     });
     if (committed.result.type !== 'sent')
         throw new Error(`Activity rejected: ${committed.result.type}`);

package/dist/notifications.js

@@ -7,7 +7,7 @@ import { recordNotificationFailure } from './notification-failures.js';
 import { hasPresentedAttention } from './presented.js';
 import { SquareError } from './model.js';
 import { SLEEP_MS, matchesMentionTarget, resolveRosterName, rosterNames } from './runtime.js';
-import { defaultWakeSinks } from './wake-sink.js';
+import { defaultWakeSinks } from './paseo-delivery.js';
 export { planActNotifications, matchesMentionTarget };
 function known(doc, name) {
     const value = resolveRosterName(doc, name);

package/dist/paseo-delivery.js

@@ -0,0 +1,160 @@
+import { homedir } from 'node:os';
+import { setTimeout as sleep } from 'node:timers/promises';
+import { loadSquare } from './artifact.js';
+import { isDeliveryDelivered, leaseOwnsNotification, } from './delivery.js';
+import { sessionInbox } from './inbox.js';
+import { hasPresentedForOwner, presentOnce } from './presented.js';
+import { lookupParticipant } from './registry.js';
+import { quoteShell } from './presentation.js';
+import { isCurrentlyJoined, resolveRosterName } from './runtime.js';
+import { discoverPaseoAgents, waitForPaseoWakeBoundary, } from './paseo-state.js';
+import { sendPaseoWake } from './wake-sink.js';
+export class PaseoWakeError extends Error {
+    diagnostic;
+    constructor(message, diagnostic) {
+        super(message);
+        this.diagnostic = diagnostic;
+        this.name = 'PaseoWakeError';
+    }
+}
+function endpoint() {
+    return process.env.SQUARE_PASEO_WS_URL ?? process.env.PASEO_LISTEN ?? '127.0.0.1:6767';
+}
+function diagnostic(phase, ownership, code) {
+    return {
+        phase,
+        code,
+        command: phase === 'discovery' ? 'paseo ls --json' : 'paseo send <agent-id> --prompt <prompt> --no-wait',
+        endpoint: endpoint(),
+        paseoAgentIds: ownership.map((item) => item.agentId),
+        ownerIds: [...new Set(ownership.map((item) => item.ownerId))],
+        passwordPresent: Boolean(process.env.PASEO_PASSWORD),
+    };
+}
+function native(binding) {
+    return ['claude-code', 'codex', 'opencode', 'pi'].includes(binding.channel);
+}
+function ownershipSnapshot(bindings) {
+    const out = new Map();
+    for (const binding of bindings) {
+        if (!binding.paseoAgentId)
+            continue;
+        const owner = bindings.filter((item) => item.ownerId === binding.ownerId);
+        out.set(`${binding.ownerId}\0${binding.paseoAgentId}`, {
+            agentId: binding.paseoAgentId,
+            ownerId: binding.ownerId,
+            sessionId: owner.find(native)?.sessionId ?? binding.sessionId,
+            nativeGuarantee: owner.some(native),
+        });
+    }
+    return [...out.values()];
+}
+function selectActiveAgents(ownership, agents) {
+    const ids = new Set(ownership.map((item) => item.agentId));
+    return agents.filter((agent) => ids.has(agent.id) && (agent.status === 'idle' || agent.status === 'running'));
+}
+function catchCommand(squarePath, recipient) {
+    return `square --as ${quoteShell(recipient)} --square-path ${quoteShell(squarePath)} catch --now`;
+}
+function prompt(notification, squarePath, nativeWake) {
+    const display = squarePath.startsWith(homedir()) ? `~${squarePath.slice(homedir().length)}` : squarePath;
+    const body = notification.item.body.length > 200 ? `${notification.item.body.slice(0, 197)}...` : notification.item.body;
+    return [
+        '<system-reminder source="square">',
+        `${notification.route === 'bell' ? 'Bell' : notification.route === 'beside' ? 'Beside' : 'Mention'} from @${notification.item.actor} in \`${display}\``,
+        nativeWake ? 'The native adapter will present it at the next boundary.' : `> ${body.replace(/\n/g, '\n> ')}`,
+        `\`${catchCommand(squarePath, notification.recipient)}\``,
+        '</system-reminder>',
+    ].join('\n');
+}
+async function waitForCatch(squarePath, recipient, actIndex, ownerId) {
+    const deadline = Date.now() + 180_000;
+    while (Date.now() < deadline) {
+        const doc = loadSquare(squarePath);
+        if (isDeliveryDelivered(doc, recipient, actIndex))
+            return true;
+        const binding = lookupParticipant(squarePath, recipient).find((item) => item.ownerId === ownerId);
+        const lease = binding && sessionInbox(binding.sessionId).find((item) => item.name === recipient)?.catchLease;
+        if (!lease || lease.expiresAt <= Date.now())
+            return false;
+        await sleep(Math.min(250, lease.expiresAt - Date.now()));
+    }
+    return false;
+}
+function send(request, ownership) {
+    try {
+        sendPaseoWake(request);
+    }
+    catch (error) {
+        throw new PaseoWakeError(error instanceof Error ? error.message : String(error), diagnostic('send', ownership, 'failed'));
+    }
+}
+export async function dispatchPaseoNotification(notification, ctx) {
+    const initial = loadSquare(ctx.squarePath);
+    const recipient = resolveRosterName(initial, notification.recipient);
+    if (!recipient || !isCurrentlyJoined(initial.acts, recipient))
+        return;
+    const ownership = ownershipSnapshot(lookupParticipant(ctx.squarePath, recipient));
+    if (ownership.length === 0)
+        return;
+    const discovery = discoverPaseoAgents();
+    if (discovery.error && discovery.agents.length === 0) {
+        throw new PaseoWakeError(`Paseo unavailable: ${discovery.error}`, diagnostic('discovery', ownership, 'unavailable'));
+    }
+    const active = selectActiveAgents(ownership, discovery.agents);
+    if (active.length === 0) {
+        throw new PaseoWakeError('No registered Paseo agent is idle or running.', diagnostic('selection', ownership, 'not_active'));
+    }
+    let boundaryTimedOut = false;
+    for (const agent of active) {
+        const owner = ownership.find((item) => item.agentId === agent.id);
+        if (!owner || hasPresentedForOwner(owner.ownerId, ctx.squarePath, recipient, notification.item.index))
+            continue;
+        if (!(await waitForPaseoWakeBoundary(agent))) {
+            boundaryTimedOut = true;
+            continue;
+        }
+        const latest = loadSquare(ctx.squarePath);
+        if (!isCurrentlyJoined(latest.acts, recipient) || isDeliveryDelivered(latest, recipient, notification.item.index))
+            return;
+        const current = lookupParticipant(ctx.squarePath, recipient).find((item) => item.ownerId === owner.ownerId && item.paseoAgentId === owner.agentId);
+        if (!current)
+            continue;
+        const activeCatch = sessionInbox(current.sessionId).find((item) => item.name === recipient)?.catchLease;
+        if (activeCatch &&
+            leaseOwnsNotification(activeCatch, {
+                actor: notification.item.actor,
+                body: notification.item.body,
+                route: notification.route,
+                recipient,
+            }) &&
+            (await waitForCatch(ctx.squarePath, recipient, notification.item.index, owner.ownerId))) {
+            return;
+        }
+        const nativeWake = owner.nativeGuarantee;
+        const request = {
+            agentId: agent.id,
+            prompt: prompt({ ...notification, recipient }, ctx.squarePath, nativeWake),
+        };
+        if (nativeWake) {
+            send(request, ownership);
+            return;
+        }
+        presentOnce(current.sessionId, (id) => sessionInbox(id)
+            .map((item) => ({ ...item, notifications: item.notifications.filter((note) => note.actIndex === notification.item.index) }))
+            .filter((item) => item.notifications.length > 0), () => {
+            send(request, ownership);
+            return true;
+        });
+        return;
+    }
+    if (boundaryTimedOut) {
+        throw new PaseoWakeError('Paseo did not reach the current tool boundary before the wake timeout.', diagnostic('boundary', ownership, 'timeout'));
+    }
+}
+export function paseoWakeSink() {
+    return { name: 'paseo', dispatch: dispatchPaseoNotification };
+}
+export function defaultWakeSinks() {
+    return process.env.SQUARE_DISABLE_PASEO_WAKE === '1' ? [] : [paseoWakeSink()];
+}

package/dist/paseo-state.js

@@ -0,0 +1,31 @@
+import { execFileSync } from 'node:child_process';
+import { waitForPaseoToolBoundary } from './paseo-timeline.js';
+export function discoverPaseoAgents(timeoutMs = 5000) {
+    try {
+        const raw = execFileSync(process.env.SQUARE_PASEO_BIN || 'paseo', ['ls', '--json'], {
+            encoding: 'utf8',
+            timeout: timeoutMs,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        const parsed = JSON.parse(raw);
+        const agents = Array.isArray(parsed) ? parsed : parsed?.agents;
+        if (!Array.isArray(agents))
+            return { agents: [], error: 'Paseo returned malformed agent inventory.' };
+        return {
+            agents: agents.filter((item) => item !== null &&
+                typeof item === 'object' &&
+                typeof item.id === 'string' &&
+                typeof item.status === 'string'),
+        };
+    }
+    catch (error) {
+        return { agents: [], error: error instanceof Error ? error.message : String(error) };
+    }
+}
+export async function waitForPaseoWakeBoundary(agent) {
+    if (agent.status === 'idle')
+        return true;
+    if (agent.status !== 'running')
+        return false;
+    return waitForPaseoToolBoundary(agent.id);
+}

package/dist/presentation.js

@@ -153,7 +153,8 @@ export function renderEventCli(event, opts = {}) {
             const mentionSuffix = mention !== undefined && extractMentions(event.body).some((name) => sameName(name, mention))
                 ? ` · calls your name across the square — @${mention}`
                 : '';
-            return `● ${event.actor} #${opts.actNumber ?? 1} · ${actId(event)} · ${formatRelativeTime(event.at, now)}${mentionSuffix}${bodySuffix(body)}`;
+            const replySuffix = event.reply === undefined ? '' : ` · replies to ${actId(event.reply)}`;
+            return `● ${event.actor} #${opts.actNumber ?? 1} · ${actId(event)} · ${formatRelativeTime(event.at, now)}${mentionSuffix}${replySuffix}${bodySuffix(body)}`;
         }
         case 'done': {
             const body = renderedBody(event.body, maxBody);

package/dist/wake-sink.js

@@ -1,165 +1,8 @@
-import { execFileSync, spawnSync } from 'node:child_process';
-import { homedir } from 'node:os';
-import { setTimeout as sleep } from 'node:timers/promises';
-import { loadSquare } from './artifact.js';
-import { leaseOwnsNotification, isDeliveryDelivered } from './delivery.js';
-import { sessionInbox } from './inbox.js';
-import { hasPresentedForOwner, presentOnce } from './presented.js';
-import { lookupParticipant } from './registry.js';
-import { quoteShell } from './presentation.js';
-import { isCurrentlyJoined, resolveRosterName } from './runtime.js';
-import { waitForPaseoToolBoundary } from './paseo-timeline.js';
-export class PaseoWakeError extends Error {
-    diagnostic;
-    constructor(message, diagnostic) {
-        super(message);
-        this.diagnostic = diagnostic;
-        this.name = 'PaseoWakeError';
-    }
-}
-function endpoint() {
-    return process.env.SQUARE_PASEO_WS_URL ?? process.env.PASEO_LISTEN ?? '127.0.0.1:6767';
-}
-function diagnostic(phase, ownership, code) {
-    return {
-        phase,
-        code,
-        command: phase === 'discovery' ? 'paseo ls --json' : 'paseo send <agent-id> --prompt <prompt> --no-wait',
-        endpoint: endpoint(),
-        paseoAgentIds: ownership.map((item) => item.agentId),
-        ownerIds: [...new Set(ownership.map((item) => item.ownerId))],
-        passwordPresent: Boolean(process.env.PASEO_PASSWORD),
-    };
-}
-function native(binding) {
-    return ['claude-code', 'codex', 'opencode', 'pi'].includes(binding.channel);
-}
-export function paseoOwnershipSnapshot(bindings) {
-    const out = new Map();
-    for (const binding of bindings) {
-        if (!binding.paseoAgentId)
-            continue;
-        const owner = bindings.filter((item) => item.ownerId === binding.ownerId);
-        out.set(`${binding.ownerId}\0${binding.paseoAgentId}`, {
-            agentId: binding.paseoAgentId,
-            ownerId: binding.ownerId,
-            sessionId: owner.find(native)?.sessionId ?? binding.sessionId,
-            nativeGuarantee: owner.some(native),
-        });
-    }
-    return [...out.values()];
-}
-export function selectPaseoWakeAgents(ownership, agents) {
-    const ids = new Set(ownership.map((item) => item.agentId));
-    return agents.filter((agent) => ids.has(agent.id) && (agent.status === 'idle' || agent.status === 'running'));
-}
-export function discoverPaseoAgents(timeoutMs = 5000) {
-    try {
-        const raw = execFileSync(process.env.SQUARE_PASEO_BIN || 'paseo', ['ls', '--json'], { encoding: 'utf8', timeout: timeoutMs, stdio: ['ignore', 'pipe', 'pipe'] });
-        const parsed = JSON.parse(raw);
-        const agents = Array.isArray(parsed) ? parsed : parsed?.agents;
-        if (!Array.isArray(agents))
-            return { agents: [], error: 'Paseo returned malformed agent inventory.' };
-        return { agents: agents.filter((item) => item !== null && typeof item === 'object' && typeof item.id === 'string' && typeof item.status === 'string') };
-    }
-    catch (error) {
-        return { agents: [], error: error instanceof Error ? error.message : String(error) };
-    }
-}
-function send(agentId, prompt) {
+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'}`);
 }
-function catchCommand(squarePath, recipient) {
-    return `square --as ${quoteShell(recipient)} --square-path ${quoteShell(squarePath)} catch --now`;
-}
-function prompt(notification, squarePath, nativeWake) {
-    const display = squarePath.startsWith(homedir()) ? `~${squarePath.slice(homedir().length)}` : squarePath;
-    const body = notification.item.body.length > 200 ? `${notification.item.body.slice(0, 197)}...` : notification.item.body;
-    return [
-        '<system-reminder source="square">',
-        `${notification.route === 'bell' ? 'Bell' : notification.route === 'beside' ? 'Beside' : 'Mention'} from @${notification.item.actor} in \`${display}\``,
-        nativeWake ? 'The native adapter will present it at the next boundary.' : `> ${body.replace(/\n/g, '\n> ')}`,
-        `\`${catchCommand(squarePath, notification.recipient)}\``,
-        '</system-reminder>',
-    ].join('\n');
-}
-async function waitForCatch(squarePath, recipient, notification, ownerId) {
-    const deadline = Date.now() + 180_000;
-    while (Date.now() < deadline) {
-        const doc = loadSquare(squarePath);
-        if (isDeliveryDelivered(doc, recipient, notification.item.index))
-            return true;
-        const binding = lookupParticipant(squarePath, recipient).find((item) => item.ownerId === ownerId);
-        const lease = binding && sessionInbox(binding.sessionId).find((item) => item.name === recipient)?.catchLease;
-        if (!lease || lease.expiresAt <= Date.now())
-            return false;
-        await sleep(Math.min(250, lease.expiresAt - Date.now()));
-    }
-    return false;
-}
-export async function dispatchPaseoNotification(notification, ctx) {
-    const initial = loadSquare(ctx.squarePath);
-    const recipient = resolveRosterName(initial, notification.recipient);
-    if (!recipient || !isCurrentlyJoined(initial.acts, recipient))
-        return;
-    const bindings = lookupParticipant(ctx.squarePath, recipient);
-    const ownership = paseoOwnershipSnapshot(bindings);
-    if (ownership.length === 0)
-        return;
-    const discovery = discoverPaseoAgents();
-    if (discovery.error && discovery.agents.length === 0) {
-        throw new PaseoWakeError(`Paseo unavailable: ${discovery.error}`, diagnostic('discovery', ownership, 'unavailable'));
-    }
-    const active = selectPaseoWakeAgents(ownership, discovery.agents);
-    if (active.length === 0) {
-        throw new PaseoWakeError('No registered Paseo agent is idle or running.', diagnostic('selection', ownership, 'not_active'));
-    }
-    let boundaryTimedOut = false;
-    for (const agent of active) {
-        const owner = ownership.find((item) => item.agentId === agent.id);
-        if (!owner || hasPresentedForOwner(owner.ownerId, ctx.squarePath, recipient, notification.item.index))
-            continue;
-        if (agent.status === 'running' && !(await waitForPaseoToolBoundary(agent.id))) {
-            boundaryTimedOut = true;
-            continue;
-        }
-        const latest = loadSquare(ctx.squarePath);
-        if (!isCurrentlyJoined(latest.acts, recipient) || isDeliveryDelivered(latest, recipient, notification.item.index))
-            return;
-        const current = lookupParticipant(ctx.squarePath, recipient).find((item) => item.ownerId === owner.ownerId && item.paseoAgentId === owner.agentId);
-        if (!current)
-            continue;
-        const activeCatch = sessionInbox(current.sessionId).find((item) => item.name === recipient)?.catchLease;
-        if (activeCatch && leaseOwnsNotification(activeCatch, { actor: notification.item.actor, body: notification.item.body, route: notification.route, recipient })) {
-            if (await waitForCatch(ctx.squarePath, recipient, notification, owner.ownerId))
-                return;
-        }
-        if (owner.nativeGuarantee) {
-            try {
-                send(agent.id, prompt({ ...notification, recipient }, ctx.squarePath, true));
-            }
-            catch (error) {
-                throw new PaseoWakeError(error instanceof Error ? error.message : String(error), diagnostic('send', ownership, 'failed'));
-            }
-            return;
-        }
-        presentOnce(current.sessionId, (id) => sessionInbox(id).map((item) => ({ ...item, notifications: item.notifications.filter((note) => note.actIndex === notification.item.index) })).filter((item) => item.notifications.length > 0), () => {
-            try {
-                send(agent.id, prompt({ ...notification, recipient }, ctx.squarePath, false));
-            }
-            catch (error) {
-                throw new PaseoWakeError(error instanceof Error ? error.message : String(error), diagnostic('send', ownership, 'failed'));
-            }
-            return true;
-        });
-        return;
-    }
-    if (boundaryTimedOut)
-        throw new PaseoWakeError('Paseo did not reach the current tool boundary before the wake timeout.', diagnostic('boundary', ownership, 'timeout'));
-}
-export function paseoWakeSink() { return { name: 'paseo', dispatch: dispatchPaseoNotification }; }
-export function defaultWakeSinks() { return process.env.SQUARE_DISABLE_PASEO_WAKE === '1' ? [] : [paseoWakeSink()]; }

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/express/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();
-    },
   };
 }

package/extensions/square-pi.js

@@ -1,6 +1,4 @@
-import { renderClaudeInboxContext } from '../dist/claude-hook.js';
-import { sessionInbox } from '../dist/inbox.js';
-import { presentOnce } from '../dist/presented.js';
+import { presentPendingAtBoundary, renderPendingAtBoundary } from '../dist/boundary-presentation.js';
 
 export function pendingInbox(inbox) {
   return inbox.filter((item) => item.notifications?.length > 0);
@@ -13,13 +11,13 @@ export function inboxKeys(inbox) {
 }
 
 export function renderPiInbox(inbox) {
-  return renderClaudeInboxContext(pendingInbox(inbox));
+  return renderPendingAtBoundary(pendingInbox(inbox));
 }
 
 export default function squarePiExtension(pi) {
   let sessionId;
   let previousSessionId;
-  const present = (deliver) => sessionId === undefined ? undefined : presentOnce(sessionId, (id) => sessionInbox(id), deliver);
+  const present = (deliver) => sessionId === undefined ? undefined : presentPendingAtBoundary(sessionId, deliver);
 
   pi.on('session_start', async (_event, ctx) => {
     sessionId = ctx.sessionManager.getSessionId();
@@ -29,7 +27,7 @@ export default function squarePiExtension(pi) {
 
   pi.on('before_agent_start', async () => {
     try {
-      return present((inbox) => ({ message: { customType: 'square', content: renderPiInbox(inbox), display: true } }));
+      return present((context) => ({ message: { customType: 'square', content: context, display: true } }));
     } catch {
       return undefined;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrosheep/square",
-  "version": "0.3.6",
+  "version": "0.3.8",
   "description": "A shared public square where agents join, catch activity, express, and step out when done.",
   "type": "module",
   "bin": {

package/skills/square/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "square",
-  "version": "0.3.6",
+  "version": "0.3.8",
   "description": "Native Claude Code turn-boundary delivery for Square participants",
   "author": {
     "name": "Square"

package/skills/square/hooks/hooks.json

@@ -1,18 +1,7 @@
 {
-  "description": "Bounded Square inbox checks at supported Claude Code turn boundaries",
+  "description": "Bounded Square inbox admission between Claude Code agent steps",
   "hooks": {
-    "UserPromptSubmit": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "command": "square claude-hook",
-            "timeout": 5
-          }
-        ]
-      }
-    ],
-    "Stop": [
+    "PostToolBatch": [
       {
         "hooks": [
           {