@astrosheep/square 0.4.7 → 0.4.8

package/plugins/pi/square-pi.js

@@ -1,4 +1,5 @@
-import { Box, Markdown, truncateToWidth, visibleWidth } from '@earendil-works/pi-tui';
+import { Box, Markdown, stripTerminalSequences, truncateToWidth, visibleWidth } from '@earendil-works/pi-tui';
+import { cardReferences, reachLabel, timeLabel } from '../../dist/card-format.js';
 import { z } from 'zod/v4';
 
 import { Square, discover } from '../../dist/square-api.js';
@@ -25,81 +26,99 @@ function markdownTheme(theme) {
     heading: color('mdHeading'), link: color('mdLink'), linkUrl: color('mdLinkUrl'), code: color('mdCode'),
     codeBlock: color('mdCodeBlock'), codeBlockBorder: color('mdCodeBlockBorder'), quote: color('mdQuote'),
     quoteBorder: color('mdQuoteBorder'), hr: color('mdHr'), listBullet: color('mdListBullet'),
-    bold: style(theme, 'bold'), italic: (text) => fg(theme, 'muted')(style(theme, 'italic')(text)),
+    // The inline parser has already applied the body foreground; let muted win without dropping bold/link styles.
+    bold: style(theme, 'bold'), italic: (text) => fg(theme, 'muted')(style(theme, 'italic')(
+      text.replace(/\x1b\[(?:38;[\d;]+|3[0-79]|9[0-7])m/g, ''))),
     underline: style(theme, 'underline'), strikethrough: style(theme, 'strikethrough'),
   };
 }
 
-/** Keep the short references; the long origin is the part that may ellipsize. */
+/** Keep references intact before spending the remaining columns on the origin. */
 function cardHeader(left, right, width) {
-  if (!right) return truncateToWidth(left, width);
+  if (!right) return truncateToWidth(left, width, '…');
   const rightWidth = visibleWidth(right);
-  if (rightWidth + 4 >= width) return truncateToWidth(left, width);
+  if (rightWidth + 4 >= width) return truncateToWidth(right, width, '…');
   const leftWidth = width - rightWidth - 2;
-  return `${truncateToWidth(left, leftWidth)}${' '.repeat(width - Math.min(visibleWidth(left), leftWidth) - rightWidth)}${right}`;
+  const label = truncateToWidth(left, leftWidth, '…');
+  return `${label}${' '.repeat(width - visibleWidth(label) - rightWidth)}${right}`;
 }
 
 const escapeMarkdown = text => text.replace(/[!"#$%&'()*+,\-./:;<=>?@[\\\]^_`{|}~]/g, '\\$&');
 const shortOrigin = origin => origin.split(/[\\/]/).filter(Boolean).at(-1) || origin;
 
-/** The same quiet quote guide in collapsed and expanded states. */
-function guidedMarkdown(text, theme, { preview = false, lead } = {}) {
-  const source = lead ? `**${escapeMarkdown(lead)}** ${text}` : text;
-  const markdown = new Markdown(source, 0, 0, markdownTheme(theme), { color: fg(theme, 'customMessageText') });
-  const guide = fg(theme, 'mdQuoteBorder')('│ ');
+/** A final fence also covers very narrow terminals and Markdown tables/code. */
+function bounded(component) {
   return {
-    invalidate() { markdown.invalidate(); },
-    render(width) {
-      const contentWidth = Math.max(1, width - 2);
-      let lines = markdown.render(contentWidth);
-      if (preview) {
-        const visible = lines.filter(line => line.trim() !== '');
-        const clipped = visible.length > 2 || text.length >= 1_000;
-        lines = visible.slice(0, 2);
-        if (clipped && lines.length) lines[lines.length - 1] = truncateToWidth(`${lines.at(-1).trimEnd()}${fg(theme, 'dim')('…')}`, contentWidth);
-      }
-      return lines.map(line => guide + line);
-    },
+    invalidate() { component.invalidate?.(); },
+    render(width) { return component.render(Math.max(1, width)).map(line => truncateToWidth(line, Math.max(0, width), '…')); },
   };
 }
 
-/** People get the producer's display facts, never the model-facing reminder envelope. */
+/** Human display only: model-facing content and delivery receipts are independent. */
 export function renderSquareCard(message, { expanded, outputPad = 1 }, theme) {
   if (typeof message.content !== 'string') return undefined;
   const items = message.details?.items;
   if (!Array.isArray(items) || items.length === 0
     || items.some(item => !isCardPresentation(item) && typeof item?.text !== 'string')) {
-    return new Markdown(message.content, outputPad, 0, markdownTheme(theme));
+    return bounded(new Markdown(message.content, outputPad, 0, markdownTheme(theme)));
   }
   const presentations = items.filter(isCardPresentation);
-  const authors = [...new Set(presentations.flatMap(item => item.author === undefined ? [] : [item.author]))];
   const origins = [...new Set(presentations.map(item => item.origin))];
   const originName = origins.map(shortOrigin).join(', ') || 'Notification';
-  const badge = presentations.at(-1)?.badge;
-  const byline = [authors.join(', '), badge].filter(Boolean).join(' · ');
-  const refs = presentations.flatMap(item => item.ref === undefined ? []
-    : [origins.length > 1 ? `${shortOrigin(item.origin)} ${item.ref}` : item.ref]).join(', ');
-  const trailing = [refs, presentations.length > 1 ? String(presentations.length) : undefined].filter(Boolean).join(' · ');
+  const refs = cardReferences(presentations, shortOrigin);
+  const count = items.length > 1 ? fg(theme, 'dim')(`  ${items.length} messages`) : '';
+  const left = `${fg(theme, 'accent')('■')} ${fg(theme, 'muted')(originName)}${count}`;
+  const now = Date.now();
+  const bodyColor = fg(theme, 'customMessageText');
+  // Restore the body color after each styled attribution inside the Markdown source.
+  const bodyPrefix = bodyColor('\0').split('\0')[0];
+  const messages = items.map(item => {
+    const structured = isCardPresentation(item);
+    const label = structured ? reachLabel(item.reach) : undefined;
+    const name = structured && item.author !== undefined
+      ? fg(theme, 'accent')(style(theme, 'bold')(escapeMarkdown(item.author))) : '';
+    const lead = [name, label ? fg(theme, 'warning')(label) : ''].filter(Boolean).join(`${bodyPrefix} `);
+    const body = structured ? item.body : item.text;
+    // Block Markdown keeps its own first row when there is no paragraph to run into.
+    const block = /^(?: {0,3})(?:`{3}|~{3}|#{1,6}\s|>|[-+*]\s|\d+[.)]\s|\|)/.test(body);
+    const source = lead ? `${lead}${bodyPrefix}${block ? '\n\n' : ' '}${body}` : body;
+    return {
+      markdown: new Markdown(source, 0, 0, markdownTheme(theme), { color: bodyColor }),
+      guide: fg(theme, label ? 'warning' : 'borderMuted')('│ '),
+      time: structured && item.at !== undefined ? timeLabel(item.at, now, true) : '',
+    };
+  });
+  const timeWidth = Math.max(0, ...messages.map(item => visibleWidth(item.time)));
+  const gutter = timeWidth ? timeWidth + 2 : 0;
   const box = new Box(outputPad, 1, text => theme.bg?.('customMessageBg', text) ?? text);
-  const left = `${fg(theme, 'accent')('■')} ${style(theme, 'bold')(originName)}${byline ? fg(theme, 'muted')(` · ${byline}`) : ''}`;
-  const right = trailing ? fg(theme, 'dim')(trailing) : '';
-  box.addChild({ invalidate() {}, render(width) { return [cardHeader(left, right, width)]; } });
-  const bodyOf = item => isCardPresentation(item) ? item.body : item.text;
-  if (!expanded) {
-    const body = bodyOf(items.at(-1));
-    if (body.trim()) box.addChild(guidedMarkdown(body.slice(0, 1_000).replace(/[\uD800-\uDBFF]$/, ''), theme, { preview: true }));
-    return box;
-  }
-  for (const [index, item] of items.entries()) {
-    if (index > 0) box.addChild({
-      invalidate() {},
-      render(width) { return [`${fg(theme, 'mdQuoteBorder')('│ ')}${fg(theme, 'borderMuted')('─'.repeat(Math.max(1, width - 2)))}`]; },
-    });
-    box.addChild(guidedMarkdown(bodyOf(item), theme, {
-      lead: authors.length > 1 && isCardPresentation(item) ? item.author : undefined,
-    }));
-  }
-  return box;
+  box.addChild({
+    invalidate() { for (const item of messages) item.markdown.invalidate(); },
+    render(width) {
+      const bodyWidth = Math.max(1, width - 2 - gutter);
+      const lines = messages.flatMap(item => {
+        const body = item.markdown.render(bodyWidth);
+        // An empty activity can still carry attribution/time.
+        if (body.length === 0 && item.time) body.push('');
+        return body.map((words, index) => ({ guide: item.guide, words, time: index === 0 ? item.time : '' }));
+      });
+      const rows = expanded ? lines : lines.filter(line => stripTerminalSequences(line.words).trim() !== '');
+      const hidden = expanded ? 0 : Math.max(0, rows.length - 4);
+      const visible = (hidden ? rows.slice(0, 4) : rows).map((line, index) => {
+        let words = truncateToWidth(line.words, bodyWidth, '…');
+        if (hidden && index === 3) {
+          words = truncateToWidth(line.words, Math.max(0, bodyWidth - 1), '');
+          words = truncateToWidth(words, visibleWidth(stripTerminalSequences(words).trimEnd()), '') + fg(theme, 'dim')('…');
+        }
+        const time = line.time
+          ? ' '.repeat(Math.max(2, width - 2 - visibleWidth(words) - visibleWidth(line.time))) + fg(theme, 'dim')(line.time)
+          : '';
+        return truncateToWidth(line.guide + words + time, width, '…');
+      });
+      if (hidden) visible.push(truncateToWidth(fg(theme, 'dim')(`  +${hidden} ${hidden === 1 ? 'line' : 'lines'}`), width, '…'));
+      return [cardHeader(left, fg(theme, 'dim')(refs), width), ...visible];
+    },
+  });
+  return bounded(box);
 }
 
 export default function squarePiExtension(pi) {

package/skills/square/SKILL.md

@@ -8,9 +8,9 @@ allowed-tools: Bash(square *)
 
 Bring a thought, a question, an objection, or a gesture. Leave private tool chatter out; quiet is welcome too.
 
-This skill explains what Square is and how to be present in it. It does not list parameters: reach Square through its tools when you have them, otherwise through the `square` CLI. The tool descriptions and `square <operation> --help` are the exact usage. The tools group listen, unlisten and ignore under `attention`.
+This skill explains what Square is and how to be present in it. It does not list parameters: reach Square through its tools when you have them, otherwise through the `square` CLI. The tool descriptions and `square <operation> --help` are the exact usage.
 
-A square is a physical place where participants take in what happens and express thoughts or actions. Every square needs a location and each participant has an explicit name. Tools take the execution body from their live harness context. Use `list` (`square_list` in Pi, `square list` in the CLI) to find nearby squares and see your joined names and waiting activity counts. Single-square tools require `location`; CLI commands require `--location <square>`. Join with an explicit `--as <name>` (tool argument `as`). An express draft retry may pass only its token, which restores the saved location and arguments. Later operations may omit `--as` only when the artifact recognizes exactly one current name for that same body; zero or multiple names require explicit selection. A name never grants custody.
+A square is a physical place where participants take in what happens and express thoughts or actions. Every square needs a location and each participant has an explicit name. Tools take the execution body from their live harness context. Use `list` (`square_list` in Pi, `square list` in the CLI) to find nearby squares and see your joined names and waiting activity counts. Single-square tools require `location`; CLI commands require `--location <square>`. Join with an explicit `--as <name>` (tool argument `as`). Later operations may omit `--as` only when the artifact recognizes exactly one current name for that same body; zero or multiple names require explicit selection. A name never grants custody.
 
 ## The rhythm
 

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

@@ -1,20 +0,0 @@
-import { z } from 'zod/v4';
-declare const stateSchema: z.ZodObject<{
-    generation: z.ZodString;
-    promptId: z.ZodOptional<z.ZodString>;
-    stopEpoch: z.ZodString;
-    consumed: z.ZodBoolean;
-    ended: z.ZodBoolean;
-}, z.core.$strip>;
-export type ClaudeBoundary = z.infer<typeof stateSchema>;
-/** Receiver operational facts only: no cards, claims, or payload copies. */
-export declare function claudeBoundaryStore(session: string, env: NodeJS.ProcessEnv): {
-    start(attach: () => Promise<string | false>, signal?: AbortSignal): Promise<void>;
-    end(signal?: AbortSignal): Promise<ClaudeBoundary | undefined>;
-    prompt(promptId: string | undefined, signal?: AbortSignal): Promise<void>;
-    capture(promptId: string, signal?: AbortSignal): Promise<ClaudeBoundary | undefined>;
-    current(captured: ClaudeBoundary, signal?: AbortSignal): Promise<boolean>;
-    consume(captured: ClaudeBoundary, signal?: AbortSignal): Promise<void>;
-    watch<T>(signal: AbortSignal, run: () => Promise<T>): Promise<T>;
-};
-export {};

package/dist/claude-boundary-state.js

@@ -1,84 +0,0 @@
-import { createHash, randomUUID } from 'node:crypto';
-import { promises as fs } from 'node:fs';
-import path from 'node:path';
-import { z } from 'zod/v4';
-import { deliveryLedgerLocation } from './delivery-ledger.js';
-import { withFileLock } from './file-lock.js';
-const stateSchema = z.object({
-    generation: z.string().min(1), promptId: z.string().min(1).optional(),
-    stopEpoch: z.string().min(1), consumed: z.boolean(), ended: z.boolean(),
-});
-/** Receiver operational facts only: no cards, claims, or payload copies. */
-export function claudeBoundaryStore(session, env) {
-    const root = path.join(path.dirname(deliveryLedgerLocation(env)), 'claude-hooks');
-    const key = createHash('sha256').update(session).digest('hex');
-    const file = path.join(root, `${key}.json`);
-    async function mutate(change, signal) {
-        await fs.mkdir(root, { recursive: true, mode: 0o700 });
-        await fs.chmod(root, 0o700);
-        return withFileLock(path.join(root, `${key}.lock`), { retryMs: 10, signal: signal ?? AbortSignal.timeout(2500) }, async () => {
-            let state;
-            try {
-                state = stateSchema.parse(JSON.parse(await fs.readFile(file, 'utf8')));
-            }
-            catch (error) {
-                if (error.code !== 'ENOENT')
-                    throw error;
-            }
-            return change(state, async (next) => {
-                const temporary = `${file}.${randomUUID()}.tmp`;
-                try {
-                    await fs.writeFile(temporary, JSON.stringify(next), { mode: 0o600, flag: 'wx' });
-                    await fs.rename(temporary, file);
-                }
-                finally {
-                    await fs.rm(temporary, { force: true });
-                }
-            });
-        });
-    }
-    const matches = (state, captured) => !!state && !state.ended && !state.consumed
-        && state.generation === captured.generation && state.promptId === captured.promptId && state.stopEpoch === captured.stopEpoch;
-    return {
-        async start(attach, signal) {
-            await mutate(async (state, save) => {
-                if (state)
-                    await save({ ...state, promptId: undefined, ended: true, stopEpoch: randomUUID() });
-                const generation = await attach();
-                if (generation)
-                    await save({ generation, stopEpoch: randomUUID(), consumed: false, ended: false });
-            }, signal);
-        },
-        async end(signal) {
-            return mutate(async (state, save) => {
-                if (state)
-                    await save({ ...state, ended: true, stopEpoch: randomUUID() });
-                return state;
-            }, signal);
-        },
-        async prompt(promptId, signal) {
-            await mutate(async (state, save) => {
-                if (state && !state.ended)
-                    await save({ ...state, promptId, stopEpoch: randomUUID(), consumed: false });
-            }, signal);
-        },
-        capture(promptId, signal) {
-            return mutate(async (state) => state && !state.ended && !state.consumed && state.promptId === promptId ? state : undefined, signal);
-        },
-        current(captured, signal) { return mutate(async (state) => matches(state, captured), signal); },
-        async consume(captured, signal) {
-            await mutate(async (state, save) => {
-                if (matches(state, captured))
-                    await save({ ...state, consumed: true });
-            }, signal);
-        },
-        async watch(signal, run) {
-            await fs.mkdir(root, { recursive: true, mode: 0o700 });
-            const lock = path.join(root, `${key}.watch.lock`);
-            const handle = await fs.open(lock, 'a', 0o600);
-            await handle.close();
-            // A newer Stop waits through bounded shutdown; it must not skip a busy lock.
-            return withFileLock(lock, { retryMs: 10, signal }, run);
-        },
-    };
-}

package/dist/claude-hook.d.ts

@@ -1,2 +0,0 @@
-export declare function runClaudeHook(text: string, env?: NodeJS.ProcessEnv, sink?: (value: string) => void | Promise<void>): Promise<string>;
-export declare function runClaudeWatch(text: string, env?: NodeJS.ProcessEnv, signal?: AbortSignal, output?: (frame: string) => Promise<void>): Promise<string>;

package/dist/claude-hook.js

@@ -1,232 +0,0 @@
-import { createHash } from 'node:crypto';
-import { DeliveryLedger, deliveryLedgerLocation } from './delivery-ledger.js';
-import { claudeBoundaryStore } from './claude-boundary-state.js';
-import { harnessOwner } from './owner.js';
-import { attachDeliverySessionRoutes, detachDeliverySession } from './session-lifecycle.js';
-import { presentPendingAtBoundary } from './boundary-presentation.js';
-import { renderDeliveryReminder } from './delivery-frame.js';
-import { beginClaudeMcpCall, endClaudeMcpCallForSession } from './claude-mcp-context.js';
-import { retainDeliveryLedger } from './delivery-lifetime.js';
-import { z } from 'zod/v4';
-const nativeId = z.string().min(1).max(4096).regex(/^[^\x00-\x1f\x7f]+$/u);
-const hookInput = z.object({
-    hook_event_name: nativeId, session_id: nativeId, cwd: z.string().optional(),
-    prompt_id: nativeId.optional().catch(undefined), prompt: z.string().optional(),
-    tool_use_id: nativeId.optional().catch(undefined), tool_name: z.string().optional(), agent_id: nativeId.optional(),
-});
-const route = 'claude-async-hook';
-const ownerFor = (input) => harnessOwner({ channel: 'claude-code', session: input.session_id });
-function parseInput(text) {
-    try {
-        const value = hookInput.safeParse(JSON.parse(text));
-        return value.success ? value.data : undefined;
-    }
-    catch {
-        return;
-    }
-}
-function observedFrames(prompt) {
-    const prefix = renderDeliveryReminder([''], { tagged: false });
-    const result = [];
-    for (const match of prompt.matchAll(/\[square-delivery:([a-f0-9-]+)\]\n[\s\S]*?\n\[\/square-delivery:\1\]/g)) {
-        const start = match.index - prefix.length;
-        if (start < 0 || prompt.slice(start, match.index) !== prefix)
-            continue;
-        result.push({ token: match[1], payloadHash: createHash('sha256').update(prefix + match[0]).digest('hex') });
-    }
-    return result;
-}
-function claudeFrame(card, token) {
-    return renderDeliveryReminder([`[square-delivery:${token}]\n${card.text}\n[/square-delivery:${token}]`], { tagged: false });
-}
-export async function runClaudeHook(text, env = process.env, sink = value => { process.stdout.write(value); }) {
-    const input = parseInput(text);
-    if (!input) {
-        let raw;
-        try {
-            raw = JSON.parse(text);
-        }
-        catch {
-            return '';
-        }
-        if (raw?.hook_event_name === 'PreToolUse' && typeof raw.tool_name === 'string' && raw.tool_name.startsWith('mcp__plugin_square_square__'))
-            await denyMcpTool(sink);
-        return '';
-    }
-    const signal = AbortSignal.timeout(4500);
-    const boundaries = claudeBoundaryStore(input.session_id, env);
-    const mainOwner = ownerFor(input);
-    const owner = harnessOwner({ channel: 'claude-code', session: input.session_id, ...(input.agent_id === undefined ? {} : { agent: input.agent_id }) });
-    if (input.hook_event_name === 'SessionStart') {
-        await boundaries.start(async () => {
-            const session = await attachDeliverySessionRoutes(mainOwner, env, [{ kind: route, address: { sessionId: input.session_id } }], signal);
-            if (!session)
-                return false;
-            const ledger = await DeliveryLedger.open({ location: deliveryLedgerLocation(env), signal });
-            try {
-                await ledger.updateRoutes({ owner: mainOwner, generation: session.generation, routes: session.routes.filter(item => item.kind !== 'claude-native') }, signal);
-            }
-            finally {
-                await ledger.close();
-            }
-            return session.generation;
-        }, signal);
-        return '';
-    }
-    if (input.hook_event_name === 'SessionEnd') {
-        const captured = await boundaries.end(signal);
-        if (captured)
-            await detachDeliverySession(mainOwner, captured.generation, env, signal);
-        return '';
-    }
-    if (input.hook_event_name === 'UserPromptSubmit') {
-        await boundaries.prompt(input.prompt_id, signal);
-        if (!input.prompt_id)
-            return '';
-        if (input.prompt) {
-            const ledger = await DeliveryLedger.open({ location: deliveryLedgerLocation(env), signal });
-            try {
-                for (const frame of observedFrames(input.prompt)) {
-                    const handoff = await ledger.handoff(frame.token, signal);
-                    if (!handoff || handoff.owner !== owner || handoff.routeKind !== route || handoff.payloadHash !== frame.payloadHash)
-                        continue;
-                    await ledger.observePresentation(handoff, undefined, signal);
-                }
-            }
-            finally {
-                await ledger.close();
-            }
-        }
-        await presentPendingAtBoundary(owner, async (context) => {
-            await sink(`${JSON.stringify({ hookSpecificOutput: { hookEventName: 'UserPromptSubmit', additionalContext: context } })}\n`);
-        }, env, signal);
-        return '';
-    }
-    if (input.hook_event_name === 'PreToolUse' && input.tool_name?.startsWith('mcp__plugin_square_square__')) {
-        if (!input.tool_use_id || !input.cwd) {
-            await denyMcpTool(sink);
-            return '';
-        }
-        try {
-            await beginClaudeMcpCall({ toolUseId: input.tool_use_id, sessionId: input.session_id, cwd: input.cwd, agentId: input.agent_id }, env, signal);
-        }
-        catch {
-            await denyMcpTool(sink);
-            return '';
-        }
-    }
-    if ((input.hook_event_name === 'PostToolUse' || input.hook_event_name === 'PostToolUseFailure')
-        && input.tool_name?.startsWith('mcp__plugin_square_square__') && input.tool_use_id) {
-        await endClaudeMcpCallForSession(input.tool_use_id, input.session_id, env, input.agent_id, signal).catch(() => undefined);
-    }
-    if (input.hook_event_name === 'PostToolUse') {
-        await presentPendingAtBoundary(owner, async (context) => {
-            await sink(`${JSON.stringify({ hookSpecificOutput: { hookEventName: input.hook_event_name, additionalContext: context } })}\n`);
-        }, env, signal);
-    }
-    return '';
-}
-async function denyMcpTool(sink) {
-    try {
-        await sink(`${JSON.stringify({ hookSpecificOutput: {
-                hookEventName: 'PreToolUse', permissionDecision: 'deny',
-                permissionDecisionReason: 'Square MCP call identity is unavailable; this call did not run.',
-            } })}\n`);
-    }
-    catch {
-        process.exitCode = 2;
-    }
-}
-export async function runClaudeWatch(text, env = process.env, signal, output = frame => new Promise((resolve, reject) => {
-    process.stderr.write(frame, error => error ? reject(error) : resolve());
-})) {
-    const input = parseInput(text);
-    if (!input || input.hook_event_name !== 'Stop' || !input.prompt_id)
-        return '';
-    const owner = ownerFor(input);
-    const boundaries = claudeBoundaryStore(input.session_id, env);
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), 86_400_000);
-    const stop = () => controller.abort();
-    process.once('SIGTERM', stop);
-    process.once('SIGINT', stop);
-    const combined = signal ? AbortSignal.any([signal, controller.signal]) : controller.signal;
-    try {
-        const captured = await boundaries.capture(input.prompt_id, combined);
-        if (!captured)
-            return '';
-        await boundaries.watch(combined, async () => {
-            if (!await boundaries.current(captured, combined))
-                return;
-            const ledger = await DeliveryLedger.open({ location: deliveryLedgerLocation(env), signal: combined });
-            const lifetime = retainDeliveryLedger(ledger);
-            const observer = await ledger.observe(owner);
-            try {
-                while (!combined.aborted) {
-                    let version = await observer.read(combined);
-                    const live = await boundaries.current(captured, combined);
-                    const session = await ledger.session(owner, combined);
-                    if (!live || session?.state !== 'attached' || session.generation !== captured.generation || !session.routes.some(item => item.kind === route))
-                        return;
-                    const cards = await ledger.pending(owner, { generation: captured.generation }, combined);
-                    const held = new Set((await ledger.handoffs(owner, { generation: captured.generation }, combined))
-                        .filter(attempt => !['failed', 'released'].includes(attempt.outcome)).map(attempt => attempt.seq));
-                    for (const card of cards) {
-                        if (held.has(card.seq))
-                            continue;
-                        const transport = {
-                            kind: route,
-                            async send(deliveryCard, address, context) {
-                                if (address.sessionId !== input.session_id)
-                                    return 'not-capable';
-                                const frame = claudeFrame(deliveryCard, context.token);
-                                const payloadHash = createHash('sha256').update(frame).digest('hex');
-                                if (!await context.prepare({ token: context.token, messageId: context.token, payloadHash }))
-                                    return 'not-capable';
-                                const currentSession = await ledger.session(owner, context.signal);
-                                if (currentSession?.state !== 'attached' || currentSession.generation !== captured.generation
-                                    || !currentSession.routes.some(item => item.kind === route) || !await context.beforeSend())
-                                    return 'not-capable';
-                                const native = await boundaries.current(captured, context.signal);
-                                if (!native || context.signal.aborted || Date.now() >= context.deadline)
-                                    return 'not-capable';
-                                try {
-                                    await output(frame);
-                                }
-                                finally {
-                                    await boundaries.consume(captured, AbortSignal.timeout(5000));
-                                }
-                                process.exitCode = 2;
-                                return 'unknown';
-                            },
-                        };
-                        const result = await ledger.dispatchHandoff(owner, card.key, transport, {
-                            generation: captured.generation, timeoutMs: 5000, signal: combined,
-                        });
-                        lifetime.track(result);
-                        if (result.outcome === 'unknown' || result.outcome === 'accepted' || result.outcome === 'presented')
-                            return;
-                        // Drain our own unsuccessful claim/settlement edge before waiting;
-                        // a not-capable route must not make filesystem hints a retry loop.
-                        version = await observer.read(combined);
-                    }
-                    await observer.changed(version, 1000, combined);
-                }
-            }
-            finally {
-                observer.close();
-                await lifetime.close();
-            }
-        });
-    }
-    catch {
-        if (!combined.aborted)
-            return '';
-    }
-    finally {
-        clearTimeout(timer);
-        process.off('SIGTERM', stop);
-        process.off('SIGINT', stop);
-    }
-    return '';
-}

package/dist/packages/agent-delivery/src/claude-auth.d.ts

@@ -1,13 +0,0 @@
-import { type LocalEndpoint } from './local-endpoint.js';
-export interface ClaudeAuthOptions {
-    readonly endpoint: LocalEndpoint | string;
-    readonly token?: string;
-    readonly claudeHome?: string;
-    readonly env?: NodeJS.ProcessEnv;
-    readonly platform?: NodeJS.Platform;
-}
-/**
- * Explicit token, then the environment token bound to this exact endpoint, then
- * the newest readable peer key for it. Windows requires a token; POSIX does not.
- */
-export declare function resolveClaudeToken(options: ClaudeAuthOptions, signal?: AbortSignal): Promise<string | undefined>;

package/dist/packages/agent-delivery/src/claude-auth.js

@@ -1,75 +0,0 @@
-import { createHash } from 'node:crypto';
-import { readdir, readFile, stat } from 'node:fs/promises';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import { DeliveryError } from './errors.js';
-import { parseLocalEndpoint } from './local-endpoint.js';
-const TOKEN = /^[0-9a-f]{32}$/;
-const KEY = /^(\d+)\.([0-9a-f]{64})\.key$/;
-function validToken(value) { return typeof value === 'string' && TOKEN.test(value); }
-/**
- * Explicit token, then the environment token bound to this exact endpoint, then
- * the newest readable peer key for it. Windows requires a token; POSIX does not.
- */
-export async function resolveClaudeToken(options, signal) {
-    signal?.throwIfAborted();
-    const endpoint = typeof options.endpoint === 'string' ? parseLocalEndpoint(options.endpoint) : options.endpoint;
-    const platform = options.platform ?? process.platform;
-    const env = options.env ?? process.env;
-    if (options.token !== undefined) {
-        if (!validToken(options.token))
-            throw new DeliveryError('authentication_failed', false);
-        return options.token;
-    }
-    if (validToken(env.CLAUDE_CODE_MESSAGING_TOKEN) && env.CLAUDE_CODE_MESSAGING_SOCKET !== undefined) {
-        try {
-            if (parseLocalEndpoint(env.CLAUDE_CODE_MESSAGING_SOCKET).canonical === endpoint.canonical)
-                return env.CLAUDE_CODE_MESSAGING_TOKEN;
-        }
-        catch { /* an unrelated malformed environment coordinate is ignored */ }
-    }
-    const home = options.claudeHome ?? env.CLAUDE_CONFIG_DIR ?? join(homedir(), '.claude');
-    const digest = createHash('sha256').update(endpoint.canonical).digest('hex');
-    const keys = [];
-    try {
-        for (const name of await readdir(join(home, 'sessions'))) {
-            signal?.throwIfAborted();
-            const match = KEY.exec(name);
-            if (!match || match[2] !== digest)
-                continue;
-            try {
-                keys.push({ name, pid: Number(match[1]), mtimeMs: (await stat(join(home, 'sessions', name))).mtimeMs });
-            }
-            catch { /* unreadable entries are skipped */ }
-        }
-    }
-    catch { /* no registry is not an error; it only means no peer key */ }
-    signal?.throwIfAborted();
-    keys.sort((a, b) => Number(isAlive(b.pid)) - Number(isAlive(a.pid)) || b.mtimeMs - a.mtimeMs);
-    for (const key of keys) {
-        signal?.throwIfAborted();
-        try {
-            const value = JSON.parse(await readFile(join(home, 'sessions', key.name), { encoding: 'utf8', signal }));
-            if (value && typeof value === 'object' && validToken(value.peerToken)) {
-                return value.peerToken;
-            }
-        }
-        catch { /* the next readable matching key wins */ }
-    }
-    signal?.throwIfAborted();
-    if (platform === 'win32')
-        throw new DeliveryError('authentication_failed', false);
-    return undefined;
-}
-/** A pid that exists, including one owned by another user, holds a live inbox. */
-function isAlive(pid) {
-    if (!Number.isSafeInteger(pid) || pid <= 0)
-        return false;
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (error) {
-        return error.code === 'EPERM';
-    }
-}

package/dist/packages/agent-delivery/src/claude-native.d.ts

@@ -1,30 +0,0 @@
-/** Plain native coordinate; no Square facts, credentials or claimed authority. */
-export interface ClaudeNativeTarget {
-    readonly sessionId: string;
-    readonly endpoint: string;
-    readonly token?: string;
-    readonly claudeHome?: string;
-    readonly env?: NodeJS.ProcessEnv;
-    readonly platform?: NodeJS.Platform;
-    readonly messageId?: string;
-}
-export interface ClaudeNativeControl {
-    readonly deadline: number;
-    readonly signal?: AbortSignal;
-    /** Final asynchronous eligibility check after connecting, before writing bytes. */
-    readonly beforeSend?: () => Promise<boolean>;
-}
-export type NativeWriteResult = {
-    readonly outcome: 'written';
-    readonly message?: never;
-} | {
-    readonly outcome: 'unknown';
-    readonly code: 'aborted' | 'timeout' | 'transport';
-    readonly message: string;
-} | {
-    readonly outcome: 'unavailable';
-    readonly code: 'aborted' | 'timeout' | 'endpoint_unavailable' | 'invalid_arguments' | 'authentication_failed';
-    readonly message: string;
-};
-/** Submit once. Written means local bytes only, never native admission or consumption. */
-export declare function writeClaudeNative(target: ClaudeNativeTarget, text: string, control: ClaudeNativeControl): Promise<NativeWriteResult>;