@astrosheep/square 0.4.6 → 0.4.8

package/dist/cli/observation-commands.js

@@ -1,11 +1,11 @@
 import path from 'node:path';
 import { once } from 'node:events';
-import { runClaudeHook, runClaudeWatch } from '../claude-hook.js';
+import { runClaudeMod } from '../claude-mod.js';
 import { runCodexHook, runCodexInterrupt } from '../codex-hook.js';
 import { runCodexWatch } from '../codex-watch.js';
 import { isSquareError } from '../model.js';
 import { commandPrefix, truncateChars, withPathOutput, quoteShell, } from '../presentation.js';
-import { PARTICIPANTS_DEFAULT_LIMIT, PARTICIPANTS_MAX_LIMIT, renderHistoryResult, renderParticipantsResult, renderStatusResult, renderSquareList, } from '../operation-presentation.js';
+import { historyContinuationCommand, renderHistoryResult, renderStatusResult, renderSquareList, } from '../operation-presentation.js';
 import { formatTimestamp, parseTimeOrRelative } from '../time.js';
 import { discover, inbox, formatActivityId, parseActivityId, PERCEIVE_DEFAULT_LIMIT, PERCEIVE_MAX_LIMIT, HISTORY_MAX_LIMIT, DEFAULT_LIST_DEPTH, MAX_LIST_DEPTH, DEFAULT_LIST_LIMIT, MAX_LIST_LIMIT } from '../square-api.js';
 import { renderPerceiveOutcome, renderPerceiveProgress } from './perceive-presentation.js';
@@ -134,8 +134,7 @@ export const perceiveCommand = {
         let mention;
         let limit;
         let id;
-        let replace = false;
-        let now = false;
+        let takeover = false;
         const participants = [];
         for (let index = 0; index < argv.length; index++) {
             if (argv[index] === '--id') {
@@ -162,29 +161,25 @@ export const perceiveCommand = {
                 limit = parseBoundedLimit(argv[index + 1], '--limit', PERCEIVE_MAX_LIMIT, `${commandPrefix(requireSquarePath(context))} perceive --limit ${PERCEIVE_MAX_LIMIT}`);
                 index += 1;
             }
-            else if (argv[index] === '--replace')
-                replace = true;
-            else if (argv[index] === '--now')
-                now = true;
+            else if (argv[index] === '--takeover')
+                takeover = true;
             else if (argv[index] !== '--json')
                 fail(`✕ perceive does not know ${argv[index]}\nsquare perceive --help`);
         }
         if (id !== undefined) {
-            if (argv.some((flag) => ['--idle', '--from', '--mention', '--limit', '--replace'].includes(flag))) {
-                fail('✕ --id cannot be combined with --idle, --from, --mention, --limit or --replace\nsquare perceive --help');
+            if (argv.some((flag) => ['--idle', '--from', '--mention', '--limit', '--takeover'].includes(flag))) {
+                fail('✕ --id cannot be combined with --idle, --from, --mention, --limit or --takeover\nsquare perceive --help');
             }
             return { id };
         }
-        if (idle !== undefined && now)
-            fail('perceive accepts --now or --idle, not both.');
-        if (replace && idle === undefined)
-            fail('--replace can only be used with --idle.');
+        if (takeover && idle === undefined)
+            fail('--takeover can only be used with --idle.');
         return {
             ...(participants.length > 0 ? { from: participants } : {}),
             ...(mention === undefined ? {} : { mention }),
             limit: limit ?? PERCEIVE_DEFAULT_LIMIT,
             ...(idle === undefined ? {} : { idle }),
-            ...(replace ? { replace } : {}),
+            ...(takeover ? { takeover } : {}),
         };
     },
     async execute(intent, context) {
@@ -244,7 +239,7 @@ function historyContinuationArgs(argv) {
             continue;
         }
         result.push(flag);
-        if (flag === '--from' || flag === '--since' || flag === '--at' || flag === '-B' || flag === '-A' || flag === '-C' || flag === '--mention' || flag === '--grep' || flag === '--fixed' || flag === '--order' || flag === '--format') {
+        if (flag === '--from' || flag === '--since' || flag === '--at' || flag === '-C' || flag === '--mention' || flag === '--search' || flag === '--order' || flag === '--format') {
             const value = argv[index + 1];
             if (value !== undefined) {
                 result.push(value);
@@ -261,12 +256,11 @@ function parseHistory(argv, context) {
     let after;
     let before;
     const at = [];
-    let beforeContext;
-    let afterContext;
+    let historyContext;
     let mention;
-    let noTruncate = false;
-    let grep;
-    let fixed;
+    let full = false;
+    let search;
+    let regex = false;
     let order;
     let format;
     const participants = [];
@@ -299,32 +293,20 @@ function parseHistory(argv, context) {
             at.push(...values.map((value) => formatActivityId(parseActRef(value, flag))));
             index += 1;
         }
-        else if (flag === '-B') {
-            beforeContext = parseNonNegativeInteger(requireValue(argv, index, flag), flag);
-            index += 1;
-        }
-        else if (flag === '-A') {
-            afterContext = parseNonNegativeInteger(requireValue(argv, index, flag), flag);
-            index += 1;
-        }
         else if (flag === '-C') {
-            const context = parseNonNegativeInteger(requireValue(argv, index, flag), flag);
-            beforeContext = context;
-            afterContext = context;
+            historyContext = parseNonNegativeInteger(requireValue(argv, index, flag), flag);
             index += 1;
         }
-        else if (flag === '--no-truncate')
-            noTruncate = true;
+        else if (flag === '--full')
+            full = true;
         else if (flag === '--mention') {
             mention = requireValue(argv, index, flag);
             index += 1;
         }
-        else if (flag === '--grep') {
-            grep = requireValue(argv, index, flag);
-            index += 1;
-        }
-        else if (flag === '--fixed') {
-            fixed = requireValue(argv, index, flag);
+        else if (flag === '--regex')
+            regex = true;
+        else if (flag === '--search') {
+            search = requireValue(argv, index, flag);
             index += 1;
         }
         else if (flag === '--order') {
@@ -341,26 +323,20 @@ function parseHistory(argv, context) {
         else if (flag !== '--json')
             fail(`✕ history does not know ${flag}\nsquare history --help`);
     }
-    if (grep !== undefined && fixed !== undefined)
-        fail('--grep and --fixed cannot be combined.');
-    if (grep === '' || fixed === '')
-        fail('--grep and --fixed require non-empty text.');
+    if (search === '')
+        fail('--search requires non-empty text.');
     if (before !== undefined && after !== undefined)
         fail('--before and --after cannot be combined.');
     return {
         query: { limit, from: participants.length === 0 ? undefined : participants, since,
             cursor: after !== undefined ? { id: after, direction: 'after' } : before === undefined ? undefined : { id: before, direction: 'before' },
             at: at.length === 0 ? undefined : at,
-            contextBefore: beforeContext, contextAfter: afterContext, mention, order,
-            search: grep !== undefined ? { text: grep, mode: 'regex' } : fixed === undefined ? undefined : { text: fixed, mode: 'literal' } },
-        noTruncate, format,
+            context: historyContext, mention, order,
+            search: search === undefined ? undefined : { text: search, mode: regex ? 'regex' : 'literal' } },
+        full, format,
         continuationArgs: historyContinuationArgs(argv),
     };
 }
-function historyContinuationCommand(options, squarePath, args) {
-    const full = [...(options.continuationArgs ?? []), ...args];
-    return `${commandPrefix(squarePath)} history ${full.map((arg) => arg.startsWith('-') || /^act\/\d+$/.test(arg) || /^\d+$/.test(arg) ? arg : quoteShell(arg)).join(' ')}`;
-}
 function renderFields(sayNumbers, item, fields) {
     return fields.map((field) => {
         switch (field) {
@@ -388,7 +364,7 @@ export const historyCommand = {
         catch (error) {
             const bounds = error?.operation?.historyBounds;
             if (bounds !== undefined)
-                fail(`✕ history is capped at ${bounds.maxLimit} activities\n${historyContinuationCommand(options, squarePath, ['--limit', String(bounds.maxLimit)])}`);
+                fail(`✕ history is capped at ${bounds.maxLimit} activities\n${historyContinuationCommand(squarePath, [...options.continuationArgs, '--limit', String(bounds.maxLimit)])}`);
             throw error;
         }
         if (context.json)
@@ -400,36 +376,12 @@ export const historyCommand = {
         }
         return renderHistoryResult(squarePath, outcome, {
             query: options.query,
-            noTruncate: options.noTruncate,
+            full: options.full,
             continuationArgs: options.continuationArgs,
         });
     },
     present: (result) => process.stdout.write(result),
 };
-function participantsLimitCommand(squarePath, limit) {
-    return `${commandPrefix(squarePath)} participants --limit ${limit}`;
-}
-function parseParticipants(argv, context) {
-    let limit = PARTICIPANTS_DEFAULT_LIMIT;
-    for (let index = 0; index < argv.length; index++) {
-        if (argv[index] === '--json')
-            continue;
-        if (argv[index] !== '--limit')
-            usage(context.command);
-        limit = parseBoundedLimit(argv[index + 1], '--limit', PARTICIPANTS_MAX_LIMIT, participantsLimitCommand(requireSquarePath(context), PARTICIPANTS_MAX_LIMIT));
-        index += 1;
-    }
-    return { limit };
-}
-export const participantsCommand = {
-    parse(argv, context) { return parseParticipants(argv, context); },
-    async execute(intent, context) {
-        const squarePath = requireSquarePath(context);
-        const data = await withSquare(context, (square) => square.participants(context.json ? {} : { observe: true }));
-        return context.json ? jsonResult(data) : renderParticipantsResult(squarePath, data, intent.limit);
-    },
-    present: (result) => process.stdout.write(result),
-};
 export const statusCommand = {
     parse(argv, context) { if (argv.some((arg) => arg !== '--json'))
         usage(context.command); return undefined; },
@@ -498,28 +450,10 @@ function hookCommand(runHook) {
         present: (result) => process.stdout.write(result),
     };
 }
-export const claudeHookCommand = {
-    parse(argv, context) { if (argv.length > 0)
-        usage(context.command); return undefined; },
-    execute: async () => {
-        try {
-            return await runClaudeHook(await readStdin(), process.env, text => new Promise((resolve, reject) => {
-                process.stdout.write(text, error => { if (error)
-                    reject(error);
-                else
-                    resolve(); });
-            }));
-        }
-        catch {
-            return '';
-        }
-    },
-    present: () => { },
-};
-export const claudeWatchCommand = {
+export const claudeModCommand = {
     parse(argv, context) { if (argv.length > 0)
         usage(context.command); return undefined; },
-    execute: async () => runClaudeWatch(await readStdin(), process.env),
+    execute: async () => runClaudeMod(await readStdin(), process.env),
     present: () => { },
 };
 export const codexHookCommand = {

package/dist/cli/registry.js

@@ -1,10 +1,10 @@
-import { buildCommand, doneCommand, expressCommand, ignoreCommand, joinCommand, listenCommand, listeningCommand, unlistenCommand } from './square-commands.js';
+import { buildCommand, doneCommand, expressCommand, ignoreCommand, joinCommand, listenCommand, unlistenCommand } from './square-commands.js';
 import { doctorCommand } from './maintenance-commands.js';
 import { harnessCommand, installCommand, uninstallCommand } from './harness-command.js';
 import { helpCommand, versionCommand } from './meta-commands.js';
 import { mcpServerCommand } from './mcp-server-command.js';
 import { JSON_COMMANDS } from './json.js';
-import { perceiveCommand, claudeHookCommand, claudeWatchCommand, codexHookCommand, codexWatchCommand, codexInterruptCommand, historyCommand, inboxCommand, listCommand, participantsCommand, statusCommand, streamCommand, } from './observation-commands.js';
+import { perceiveCommand, claudeModCommand, codexHookCommand, codexWatchCommand, codexInterruptCommand, historyCommand, inboxCommand, listCommand, statusCommand, streamCommand, } from './observation-commands.js';
 /** Every public command is an executable adapter, including aliases and utility commands. */
 export const commandRegistry = [
     { names: ['build'], spec: buildCommand },
@@ -12,8 +12,7 @@ export const commandRegistry = [
     { names: ['join'], spec: joinCommand },
     { names: ['stream'], spec: streamCommand },
     { names: ['inbox'], spec: inboxCommand },
-    { names: ['claude-hook'], spec: claudeHookCommand },
-    { names: ['claude-watch'], spec: claudeWatchCommand },
+    { names: ['claude-mod'], spec: claudeModCommand },
     { names: ['codex-hook'], spec: codexHookCommand },
     { names: ['codex-watch'], spec: codexWatchCommand },
     { names: ['codex-interrupt'], spec: codexInterruptCommand },
@@ -22,7 +21,6 @@ export const commandRegistry = [
     { names: ['listen'], spec: listenCommand },
     { names: ['ignore'], spec: ignoreCommand },
     { names: ['unlisten'], spec: unlistenCommand },
-    { names: ['listening'], spec: listeningCommand },
     { names: ['done'], spec: doneCommand },
     { names: ['install'], spec: installCommand },
     { names: ['uninstall'], spec: uninstallCommand },
@@ -30,7 +28,6 @@ export const commandRegistry = [
     { names: ['doctor'], spec: doctorCommand },
     { names: ['history'], spec: historyCommand },
     { names: ['status'], spec: statusCommand },
-    { names: ['participants'], spec: participantsCommand },
     { names: ['help'], spec: helpCommand },
     { names: ['version', '--version', '-v'], spec: versionCommand },
     { names: ['mcp-server'], spec: mcpServerCommand },

package/dist/cli/square-commands.d.ts

@@ -8,7 +8,7 @@ interface BuildIntent {
 }
 interface JoinIntent {
     lastN: number;
-    kick: boolean;
+    takeover: boolean;
 }
 interface ActivityIntent {
     activity?: string;
@@ -25,7 +25,7 @@ interface BodyIntent {
     body?: string;
 }
 interface ListenerIntent {
-    target?: string;
+    target: string;
 }
 export declare const buildCommand: CommandSpec<BuildIntent, string>;
 export declare const joinCommand: CommandSpec<JoinIntent, string>;
@@ -33,6 +33,5 @@ export declare const expressCommand: CommandSpec<ActivityIntent>;
 export declare const listenCommand: CommandSpec<ListenerIntent, string>;
 export declare const ignoreCommand: CommandSpec<ListenerIntent, string>;
 export declare const unlistenCommand: CommandSpec<ListenerIntent, string>;
-export declare const listeningCommand: CommandSpec<ListenerIntent, string>;
 export declare const doneCommand: CommandSpec<BodyIntent, string>;
 export {};

package/dist/cli/square-commands.js

@@ -1,6 +1,6 @@
 import { formatHardCap } from '../model.js';
 import { commandPrefix, participantCommandPrefix, withPathOutput, } from '../presentation.js';
-import { renderJoinResult, renderLifecycleResult, renderListenerChange, renderListeningResult, } from '../operation-presentation.js';
+import { renderJoinResult, renderLifecycleResult, renderListenerChange, } from '../operation-presentation.js';
 import { Square, requireOwner, requireJoinName, selectOwnSeat } from '../square-api.js';
 import { executeExpression } from './express-presentation.js';
 import { jsonResult } from './json.js';
@@ -62,23 +62,23 @@ export const buildCommand = {
 export const joinCommand = {
     parse(argv, context) {
         let lastN = JOIN_DEFAULT_LAST;
-        let kick = false;
+        let takeover = false;
         for (let index = 0; index < argv.length; index++) {
             if (argv[index] === '--last') {
                 lastN = parseBoundedLimit(argv[index + 1], '--last', JOIN_MAX_LAST, `${context.name === undefined ? commandPrefix(requireSquarePath(context)) : participantCommandPrefix(requireSquarePath(context), context.name)} join --last ${JOIN_MAX_LAST}`);
                 index += 1;
             }
-            else if (argv[index] === '--kick')
-                kick = true;
+            else if (argv[index] === '--takeover')
+                takeover = true;
             else if (argv[index] !== '--json')
                 usage(context.command);
         }
-        return { lastN, kick };
+        return { lastN, takeover };
     },
     async execute(intent, context) {
         const { owner, wakeAddress } = commandIdentity(context.env, context.owner);
         const data = await withSquare(context, (square) => square.join(requireJoinName(context.name), {
-            owner: requireOwner(owner), wakeAddress, takeover: intent.kick, last: intent.lastN, ...(context.json ? {} : { observe: true }),
+            owner: requireOwner(owner), wakeAddress, takeover: intent.takeover, last: intent.lastN, ...(context.json ? {} : { observe: true }),
         }));
         return context.json ? jsonResult(data) : renderJoinResult(data, context.owner ?? context.env.SQUARE_OWNER);
     },
@@ -153,15 +153,14 @@ export const expressCommand = {
     },
     present: () => { },
 };
-function parseListener(argv, context, targetRequired) {
-    const args = argv.filter((arg) => arg !== '--json');
-    if (targetRequired ? args.length !== 1 : args.length !== 0)
-        usage(context.command);
-    return targetRequired ? { target: args[0] } : {};
-}
 function listenerCommand(verb) {
     return {
-        parse(argv, context) { return parseListener(argv, context, true); },
+        parse(argv, context) {
+            const args = argv.filter((arg) => arg !== '--json');
+            if (args.length !== 1)
+                usage(context.command);
+            return { target: args[0] };
+        },
         async execute(intent, context) {
             const squarePath = requireSquarePath(context);
             const data = await withSquare(context, async (square) => (await selectOwnSeat(square, commandIdentity(context.env, context.owner).owner, context.name))[verb](intent.target, context.json ? {} : { observe: true }));
@@ -173,15 +172,6 @@ function listenerCommand(verb) {
 export const listenCommand = listenerCommand('listen');
 export const ignoreCommand = listenerCommand('ignore');
 export const unlistenCommand = listenerCommand('unlisten');
-export const listeningCommand = {
-    parse(argv, context) { return parseListener(argv, context, false); },
-    async execute(_intent, context) {
-        const squarePath = requireSquarePath(context);
-        const data = await withSquare(context, async (square) => (await selectOwnSeat(square, commandIdentity(context.env, context.owner).owner, context.name)).listening(context.json ? {} : { observe: true }));
-        return context.json ? jsonResult(data) : renderListeningResult(squarePath, data);
-    },
-    present: (result) => process.stdout.write(result),
-};
 export const doneCommand = {
     parse(argv, context) {
         const args = argv.filter((arg) => arg !== '--json');

package/dist/decisions.js

@@ -65,10 +65,11 @@ export function unreadActivitySummaries(facts, name, now) {
     }
     const selected = facts.activities([...summaries.values()].map((item) => item.lastIndex));
     const byIndex = new Map(selected.map((item) => [item.index, item]));
-    return [...summaries].map(([name, summary]) => ({
-        name, count: summary.count, latestActivityAgeMs: Math.max(0, now - summary.latestAt),
-        preview: byIndex.get(summary.lastIndex),
-    })).sort((a, b) => a.latestActivityAgeMs - b.latestActivityAgeMs || a.name.localeCompare(b.name));
+    return [...summaries].map(([name, summary]) => {
+        const latest = byIndex.get(summary.lastIndex);
+        return { name, count: summary.count, latestActivityAgeMs: Math.max(0, now - summary.latestAt),
+            preview: { ...(latest.body === undefined ? {} : { body: latest.body }), structured: latest.metadata !== undefined } };
+    }).sort((a, b) => a.latestActivityAgeMs - b.latestActivityAgeMs || a.name.localeCompare(b.name));
 }
 export function decideAct(facts, input) {
     const { now, force, reach, reply } = input;

package/dist/harness-claude.js

@@ -71,8 +71,8 @@ export async function doctorClaudePlugin(homeDir, run = runClaude) {
     return [
         fs.existsSync(bundle) ? `✓ Square Claude plugin bundle ${root}` : `○ Square Claude plugin bundle missing ${root}`,
         installed ? `✓ ${CLAUDE_PLUGIN_ID} installed` : `○ ${CLAUDE_PLUGIN_ID} unavailable`,
-        `Claude delivery uses synchronous prompt/tool hooks and one finite 24-hour asyncRewake Stop observer; actual coverage ends at native boundaries.`,
-        `Idle Escape cannot disarm a watcher, and already emitted notifications cannot be recalled; busy Escape disarms at the next prompt boundary.`,
-        `Native stderr output is recorded unknown until its exact token/hash frame appears at a later prompt boundary; model comprehension is not observed.`,
+        `Claude delivery uses a mod: busy turns append context and log it; idle main sessions submit an attributed plugin prompt.`,
+        `Stop suppresses the current delivery batch; clear, resume and module reload retire the captured helper and attachment.`,
+        `Exact native acceptance records presentation, not model comprehension. Paseo does not yet expose Claude ui_log events.`,
     ];
 }

package/dist/help.js

@@ -13,9 +13,9 @@ const COMMANDS = [
         details: ['Options:', '  --depth <N>    Descend through at most N directory levels (default 4; maximum 16; 0 scans only the current directory).', '  --limit <N>    Show one page (default 20, maximum 100).', '  --after <path> Resume after a relative path from a previous page.'],
     },
     {
-        names: ['join'], usage: '--as <name> join [--last N] [--kick]', usesSquare: true, group: 'participant',
+        names: ['join'], usage: '--as <name> join [--last N] [--takeover]', usesSquare: true, group: 'participant',
         summary: 'Step into the square and read its current context.',
-        details: ['Options:', '  --last <N>  Show the last N public activities (default 10, maximum 100).', '  --kick      End the standing participant and reclaim the name for this session.'],
+        details: ['Options:', '  --last <N>  Show the last N public activities (default 10, maximum 100).', '  --takeover  End the standing participant and reclaim the name for this session.'],
     },
     {
         names: ['express'], usage: '--as <name> express [-f|--force] [--no-wait] [--metadata <json>] [--mention <name>... | --bell] [--no-mention] [--reply <activity-id>] [<activity> | -]', usesSquare: true, group: 'participant',
@@ -40,11 +40,10 @@ const COMMANDS = [
     { names: ['listen'], usage: '--as <name> listen <participant>', usesSquare: true, group: 'participant', summary: 'Turn an ear toward one participant\'s future activity.' },
     { names: ['unlisten'], usage: '--as <name> unlisten <participant>', usesSquare: true, group: 'participant', summary: 'Stop listening without blocking that participant\'s mentions or replies.' },
     { names: ['ignore'], usage: '--as <name> ignore <participant>', usesSquare: true, group: 'participant', summary: 'Stop hearing one participant\'s future activity, except bells.' },
-    { names: ['listening'], usage: '--as <name> listening', usesSquare: true, group: 'participant', summary: 'Show who you are turned toward.', details: ['Listening applies to future activity. What you could hear when an activity landed does not change afterward.'] },
     {
-        names: ['perceive'], usage: '--as <name> perceive [--id <activity-id>] [--now | --idle <duration>] [--from <names>] [--mention] [--limit <count>] [--replace]', usesSquare: true, group: 'participant',
+        names: ['perceive'], usage: '--as <name> perceive [--id <activity-id>] [--idle <duration>] [--from <names>] [--mention] [--limit <count>] [--takeover]', usesSquare: true, group: 'participant',
         summary: 'Perceive directed conversation since you last looked.',
-        details: ['Modes:', '  --id <activity-id> Perceive exactly one activity addressed to you, with its full body; implies --now.', '                    Marks only this activity seen; repeats return it again. No filters, limit, idle or replace.', '                    history stays read-only; perceive --id consumes the selected activity.', '  --now             Take in activity immediately; bare perceive already does this.', '  --idle <duration> Wait for something relevant, or for quiet to last this long.', '', 'Attention:', '  Mentions arrive when you are addressed; bells arrive for everyone; bare says require listen.', '  listen and ignore are future-only and fixed when each say lands.', '', 'Filters:', '  --from <names>    Match only comma-separated participants.', '  --mention         Match direct attention for your current participant (and bells).', '  --limit <count>   Return one page (default 10, maximum 100).', '', 'Recovery:', '  --replace         Replace another active perceive for this participant.'],
+        details: ['Modes:', '  --id <activity-id> Open one activity addressed to you in full; repeats work. Use it alone.', '  --idle <duration> Wait for something relevant, or for quiet to last this long.', '', 'Attention:', '  Mentions arrive when you are addressed; bells arrive for everyone; bare says require listen.', '  listen and ignore are future-only and fixed when each say lands.', '', 'Filters:', '  --from <names>    Match only comma-separated participants.', '  --mention         Match direct attention for your current participant (and bells).', '  --limit <count>   Return one page (default 10, maximum 100).', '', 'Recovery:', '  --takeover        Take over from another active perceive for this participant.'],
     },
     { names: ['done'], usage: '--as <name> done', usesSquare: true, group: 'participant', summary: 'Step out of the square.', details: ['done takes no message. Use express before leaving to send one.'] },
     {
@@ -60,19 +59,13 @@ const COMMANDS = [
     { names: ['codex-hook'], usage: '{command}', summary: 'Present pending attention at one native agent boundary.', hiddenFromIndex: true },
     { names: ['codex-watch'], usage: '{command}', summary: 'Observe pending attention from a native async Stop hook.', hiddenFromIndex: true },
     { names: ['codex-interrupt'], usage: '{command}', summary: 'Cancel pending attention at a native Interrupt boundary.', hiddenFromIndex: true },
-    { names: ['claude-hook'], usage: '{command}', summary: 'Receive a native Claude hook event.', hiddenFromIndex: true },
-    { names: ['claude-watch'], usage: '{command}', summary: 'Observe pending attention from a native async Stop hook.', hiddenFromIndex: true },
+    { names: ['claude-mod'], usage: '{command}', summary: 'Run the Claude mod delivery helper.', hiddenFromIndex: true },
     {
         names: ['history'], usage: 'history [filters] [output]', usesSquare: true, group: 'participant',
         summary: 'Read or search the archive without changing what you have perceived.',
-        details: ['Optional --as is accepted but does not change the archive or claim a name.', '', 'Filters:', '  --from <names>                  Match activities from participants.', '  --since <time>                  Match activities after a time.', '  --grep <regex> | --fixed <s>    Search activity ids, participants, and original bodies.', '  --mention <name>                Match direct attention for a participant.', '  --at <ids>                      Center on comma-separated activity ids; may repeat.', '  -B, -A, -C <N>                 Set non-negative context around every --at coordinate.', '  --before <id>                   Read the page immediately before an activity.', '  --after <id>                    Read the page immediately after an activity.', '', 'Results:', '  --limit <N>                     Page size (default 10, maximum 100).', '  --order <asc|desc>              Set display order (default oldest first).', '', 'Output:', '  --no-truncate  --json  --format <fields>', '  One result shows its full body; multiple results use previews.', '  --no-truncate shows every original body.'],
+        details: ['Filters:', '  --from <names>                  Match activities from participants.', '  --since <time>                  Match activities after a time.', '  --search <text> [--regex]      Search ids, participants, and original bodies; literal by default.', '  --mention <name>                Match direct attention for a participant.', '  --at <ids>                      Center on comma-separated activity ids; may repeat.', '  -C <N>                         Set symmetric context around every --at coordinate.', '  --before <id>                   Read the page immediately before an activity.', '  --after <id>                    Read the page immediately after an activity.', '', 'Results:', '  --limit <N>                     Page size (default 10, maximum 100).', '  --order <asc|desc>              Set display order (default oldest first).', '', 'Output:', '  --full  --json  --format <fields>', '  One result shows its full body; multiple results use previews.', '  --full shows every original body.'],
     },
     { names: ['status'], usage: '[--as <name>] status', usesSquare: true, group: 'participant', summary: 'Show who is present and what happened most recently.' },
-    {
-        names: ['participants'], usage: 'participants [--limit <count>]', usesSquare: true, group: 'host',
-        summary: 'Show the participant roster and current states.',
-        details: ['Options:', '  --limit <count>  Show the first count names in human text (default 20, maximum 100).'],
-    },
     {
         names: ['install'], usage: 'install (--all | <target>...) [-f]', group: 'maintenance',
         summary: 'Install Square support for one or more agent hosts.',
@@ -101,8 +94,8 @@ function isHelpFlag(value) {
 }
 export function renderGlobalHelp() {
     const groups = [
-        { key: 'participant', title: 'In the square:', order: ['join', 'express', 'listen', 'unlisten', 'ignore', 'listening', 'perceive', 'history', 'status', 'done'] },
-        { key: 'host', title: 'Prepare and manage:', order: ['build', 'list', 'participants'] },
+        { key: 'participant', title: 'In the square:', order: ['join', 'express', 'listen', 'unlisten', 'ignore', 'perceive', 'history', 'status', 'done'] },
+        { key: 'host', title: 'Prepare and manage:', order: ['build', 'list'] },
         { key: 'maintenance', title: 'Setup:', order: ['install', 'uninstall', 'doctor'] },
     ];
     const commandLines = groups.flatMap(({ key, title, order }) => [
@@ -117,7 +110,7 @@ export function renderGlobalHelp() {
         'Usage: square [--location <square>] [--as <name>] [--owner <id>] <command> [args...]',
         'Location: square-accessing commands require --location <square>. Use square list to find nearby squares and your joined names; use --as to select a participant.',
         'Identity: --owner overrides SQUARE_OWNER, then a complete harness identity, then user:<OS user>@<host>. Incomplete or ambiguous harness identities refuse. Owners without wake use perceive --idle.',
-        'Output: --json on join, express, perceive, history, listen, ignore, unlisten, listening, done, status, participants and inbox prints the SDK result without observation; a participant handle becomes {name}.',
+        'Output: --json on join, express, perceive, history, listen, ignore, unlisten, done, status and inbox prints the SDK result without observation; a participant handle becomes {name}.',
         'History emits one JSON document; stream --ndjson emits one SDK record per line.',
         '',
         ...commandLines,

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { Square, squareLocation, squareClock, discover, inbox, diagnoseSquare } from './square-api.js';
+export { Square, squareLocation, discover, inbox, diagnoseSquare } from './square-api.js';
 export { SquareError, ACTIVITY_METADATA_MAX_BYTES } from './model.js';
 export { selectOwnSeat, requireOwner, requireJoinName, localUserOwner, harnessOwner, decodeHarnessOwner } from './square-api.js';
 export { postAndDispatch, dispatchEligibleCards } from './notifications.js';

package/dist/index.js

@@ -1,4 +1,4 @@
-export { Square, squareLocation, squareClock, discover, inbox, diagnoseSquare } from './square-api.js';
+export { Square, squareLocation, discover, inbox, diagnoseSquare } from './square-api.js';
 export { SquareError, ACTIVITY_METADATA_MAX_BYTES } from './model.js';
 export { selectOwnSeat, requireOwner, requireJoinName, localUserOwner, harnessOwner, decodeHarnessOwner } from './square-api.js';
 export { postAndDispatch, dispatchEligibleCards } from './notifications.js';

package/dist/mcp.d.ts

@@ -4,6 +4,7 @@ import type { SquareAtInput } from './square-facade.js';
 import type { WakeAddress } from './model.js';
 /** Each tool call chooses its square and owns its connection lifetime. */
 export interface SquareMcpOptions extends Omit<SquareAtInput, 'path'> {
+    readonly env?: NodeJS.ProcessEnv;
     readonly owner?: Owner;
     readonly wakeAddress?: WakeAddress;
 }

package/dist/mcp.js

@@ -1,11 +1,10 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { SQUARE_TOOLS, SQUARE_TOOL_INSTRUCTIONS, createSquareToolRunner, squareToolsEnabled } from './square-tools.js';
-import { operationEnv } from './participant-identity.js';
 import { codexWakeAddress } from './codex-address.js';
 import { readClaudeMcpCall } from './claude-mcp-context.js';
 import { SQUARE_IDENTITY } from './identity.js';
-import { Square, discover, squareClock } from './square-api.js';
+import { Square, discover } from './square-api.js';
 import { harnessOwner } from './square-api.js';
 export function createSquareMcpServer(options) {
     const { owner: configuredOwner, wakeAddress, ...resourceOptions } = options;
@@ -21,7 +20,7 @@ export function createSquareMcpServer(options) {
                 return invoke(tool, args, { signal: extra.signal }, async () => {
                     const threadId = extra._meta?.threadId;
                     const opencodeSessionId = extra._meta?.['ai.opencode/sessionID'];
-                    // Claude's bundled plugin requires a per-call native hook association; startup identity is not a fallback.
+                    // Claude's bundled mod requires a per-call native association; startup identity is not a fallback.
                     const claude = baseEnv.SQUARE_CLAUDE_MCP_CONTEXT === '1'
                         ? await readClaudeMcpCall(extra._meta?.['claudecode/toolUseId'], baseEnv)
                         : undefined;
@@ -32,27 +31,17 @@ export function createSquareMcpServer(options) {
                             : typeof opencodeSessionId === 'string' && opencodeSessionId.trim()
                                 ? harnessOwner({ channel: 'opencode', session: opencodeSessionId })
                                 : configuredOwner;
-                    const env = claude !== undefined
-                        ? { ...operationEnv('claude', claude.sessionId, baseEnv),
-                            // An agent loop ID is not a session ID.
-                            CLAUDE_CODE_CHILD_SESSION: claude.agentId === undefined ? '' : '1' }
-                        : typeof threadId === 'string' && threadId.trim()
-                            ? operationEnv('codex', threadId, baseEnv)
-                            : typeof opencodeSessionId === 'string' && opencodeSessionId.trim()
-                                ? operationEnv('opencode', opencodeSessionId, baseEnv)
-                                : baseEnv;
                     const callWake = wakeAddress !== undefined && (owner === configuredOwner
                         || wakeAddress.kind === 'paseo' && wakeAddress.address.agentId === baseEnv.PASEO_AGENT_ID
                         || wakeAddress.kind === 'opencode-server' && wakeAddress.address.sessionId === opencodeSessionId)
                         ? wakeAddress : undefined;
+                    const clock = resourceOptions.clock ?? Date.now;
                     return {
                         identity: { owner, wakeAddress: claude === undefined && typeof threadId === 'string' && threadId.trim()
-                                ? { ...codexWakeAddress(threadId, env), kind: 'codex-queue' } : callWake },
-                        open: (location, control) => Square.at({ ...resourceOptions, env, cwd: claude?.cwd ?? resourceOptions.cwd, path: location }, control),
-                        discover: async (discovery, control) => ({
-                            result: await discover({ ...resourceOptions, env, cwd: claude?.cwd ?? resourceOptions.cwd }, discovery, control),
-                            now: squareClock(env, resourceOptions.clock)(),
-                        }),
+                                ? { ...codexWakeAddress(threadId, baseEnv), kind: 'codex-queue' } : callWake },
+                        now: clock,
+                        open: (location, control) => Square.at({ ...resourceOptions, cwd: claude?.cwd ?? resourceOptions.cwd, path: location, clock }, control),
+                        discover: (discovery, control) => discover({ cwd: claude?.cwd ?? resourceOptions.cwd }, discovery, control),
                     };
                 }).then(({ text, isError }) => ({
                     ...(isError ? { isError } : {}), content: [{ type: 'text', text }],

package/dist/model.d.ts

@@ -54,7 +54,7 @@ export type DirectedNotificationRoute = import('./attention.js').AudienceRoute;
 export interface WatchOptions {
     participants?: string[];
     mention?: string;
-    replace?: boolean;
+    takeover?: boolean;
 }
 export type PublicAct = Extract<HydratedAct, {
     kind: 'say' | 'done';

package/dist/neutral.d.ts

@@ -2,9 +2,17 @@
 export type Owner = string;
 export type SquareErrorCode = 'invalid_name' | 'invalid_args' | 'unknown_participant' | 'not_joined' | 'already_joined' | 'already_done' | 'capped' | 'throttled' | 'bell_quota' | 'behind' | 'io' | 'unavailable';
 export type InternalSquareErrorCode = SquareErrorCode | 'not_found' | 'cap_reached' | 'conflict' | 'pending_peer';
+/** One speaker's unperceived activity, previewed by its latest body. */
+export interface UnreadActivitySummary {
+    readonly name: string;
+    readonly count: number;
+    readonly latestActivityAgeMs: number;
+    readonly preview: {
+        readonly body?: string;
+        readonly structured: boolean;
+    };
+}
 export interface SquareErrorFacts {
-    /** Copyable recovery for a missing, detached or foreign seat. */
-    join?: string;
     /** Express admission rejected before any activity was committed. */
     activityUnsent?: true;
     /** Refusal reason, including absent participants, conflicting reach, and inaccessible activities. */
@@ -15,8 +23,12 @@ export interface SquareErrorFacts {
     targets?: readonly string[];
     /** Whether the artifact holds that activity at all; an unknown id needs an ordinary page. */
     activityExists?: boolean;
-    pending?: number;
+    /** Who spoke while an express was away; the refusal rests on exactly these. */
+    activitySummaries?: readonly UnreadActivitySummary[];
     retryAfterMs?: number;
+    /** A capped speaker's spoken count against the square's cap. */
+    spoken?: number;
+    hardCap?: number;
 }
 export interface PerceiveWaitStart {
     readonly idleMs: number;

package/dist/notifications.d.ts

@@ -3,7 +3,6 @@ import type { Owner } from './owner.js';
 export { createDefaultDeliveryTransports } from './wake-transports.js';
 /** Best-effort dispatch for currently eligible cards, including cards restored by release. */
 export declare function dispatchEligibleCards(ledger: DeliveryLedger, owner: Owner, options?: {
-    readonly env?: NodeJS.ProcessEnv;
     readonly signal?: AbortSignal;
     readonly track?: (result: HandoffResult) => void;
     readonly transports?: readonly DeliveryTransport[];
@@ -15,10 +14,9 @@ export declare function postAndDispatch(ledger: DeliveryLedger, input: {
     readonly text: string;
     readonly details?: Readonly<Record<string, unknown>>;
 }, options?: {
-    readonly env?: NodeJS.ProcessEnv;
     readonly signal?: AbortSignal;
     readonly track?: (result: HandoffResult) => void;
     readonly transports?: readonly DeliveryTransport[];
 }): Promise<PostResult>;
 /** Best-effort dispatch after a card has been posted; never inspect producer storage. */
-export declare function dispatchPostedCard(ledger: DeliveryLedger, owner: Owner, key: string, track: (result: HandoffResult) => void, env?: NodeJS.ProcessEnv, signal?: AbortSignal, suppliedTransports?: readonly DeliveryTransport[]): Promise<void>;
+export declare function dispatchPostedCard(ledger: DeliveryLedger, owner: Owner, key: string, track: (result: HandoffResult) => void, signal?: AbortSignal, suppliedTransports?: readonly DeliveryTransport[]): Promise<void>;