@astrosheep/square 0.3.57 → 0.3.61

package/dist/cli/square-commands.js

@@ -1,15 +1,16 @@
 import { cmdActivity } from '../activity.js';
 import { formatActivityId, formatHardCap, parseActivityId, } from '../model.js';
-import { participantCommandPrefix, participantIdentity, quoteShell, renderEventCli, renderAmbientEvent, withPathOutput, } from '../presentation.js';
+import { formatRefusal, participantCommandPrefix, participantIdentity, quoteShell, renderRoomChangeText, renderAmbientEvent, withPathOutput, } from '../presentation.js';
 import { claimSessionParticipant, hasAutomaticDeliveryIdentity, localSessionIdentities, lookupParticipant, readParticipantOwner, recordSessionDone, } from '../registry.js';
 import { createHostLedgerPort } from '../host-ledger-file-adapter.js';
 import { sessionIdsFromEnvironment } from '../square-projections.js';
-import { nowMs } from '../runtime.js';
+import { actId, nowMs } from '../runtime.js';
 import { createSquare, openSquare } from '../square-file-adapter.js';
 import { closeOpenSquare } from '../open-square.js';
 import { openParticipant, Square } from '../square-wiring.js';
 import { entryPresentation, eventPresentation } from '../views.js';
 import { createDefaultWakeTransport } from '../notifications.js';
+import { style } from '../tty-style.js';
 import { fail, parseBoundedLimit, parseHardCap, parsePositiveInteger, readStdin, requireParticipant, requireSquarePath, requireValue, resolveBody, usage, } from './context.js';
 const JOIN_DEFAULT_LAST = 10;
 const JOIN_MAX_LAST = 100;
@@ -57,7 +58,7 @@ export const buildCommand = {
         await createSquare(squarePath, intent.options, snippet);
         const cap = intent.options.hardCap === null ? 'unlimited' : formatHardCap(intent.options.hardCap);
         const throttle = intent.options.throttlePerMinute === undefined ? [] : [`  · throttle ${intent.options.throttlePerMinute}/min`];
-        return withPathOutput(squarePath, ['✓ built', `  · cap ${cap}`, ...throttle, '  · participants (none seeded — first join adds names)'].join('\n'), { participantCount: 0 });
+        return withPathOutput(squarePath, ['✓ the square is open', `  · cap ${cap}`, ...throttle, '  · nobody here yet — the first join steps in'].join('\n'), { participantCount: 0 });
     },
     present: (result) => process.stdout.write(result),
 };
@@ -95,12 +96,13 @@ export const joinCommand = {
             const reconnect = before.joined && identity !== undefined && owner?.sessionId === identity.sessionId;
             const isRejoin = before.joined;
             if (isRejoin && !intent.kick && !reconnect) {
-                fail([
+                process.stderr.write(formatRefusal(squarePath, [
                     `✕ ${participantIdentity(intent.name)} shoos you out of the square`,
                     `  · a same-named participant stands here — the name is taken`,
-                    `  · --kick banishes her and the name becomes yours`,
-                    `» ${participantCommandPrefix(squarePath, intent.name)} join --kick`,
-                ].join('\n'));
+                    `  · --kick banishes the one standing there — the name becomes yours`,
+                    `${participantCommandPrefix(squarePath, intent.name)} join --kick`,
+                ], { participantCount: before.participantCount }));
+                process.exit(2);
             }
             const takeoverNeeded = isRejoin && intent.kick;
             const oldBindings = takeoverNeeded ? await lookupParticipant(squarePath, intent.name) : [];
@@ -134,20 +136,20 @@ export const joinCommand = {
             const contextText = after.joinContext;
             const fallback = hasAutomaticDeliveryIdentity()
                 ? []
-                : ['', `» ${participantCommandPrefix(squarePath, joinedName)} catch --idle 30m`, '  no session delivery detected — keep this catch open for new activity'];
+                : ['', `${participantCommandPrefix(squarePath, joinedName)} catch --idle 30m`, '  the square has no way to call you — keep this catch open and stay within earshot'];
             const scene = after.scene;
             const entryLine = !isRejoin
-                ? '● You stepped into the square'
+                ? '● you stepped into the square'
                 : reconnect && !intent.kick
                     ? '● you are already in the square'
                     : `✓ you banished the original ${participantIdentity(joinedName)} — the name is yours`;
             const output = [
                 entryLine,
                 '',
-                "Don't treat Square as a public dumping ground. Speak here only when you genuinely think someone else needs to know; otherwise you are needlessly interrupting them.",
+                "· carved into the fountain's edge: every word here lands on a real ear — speak when someone needs it.",
                 ...(reconnect || scene === '' ? [] : ['', scene]),
-                ...(isRejoin || contextText === '' ? [] : ['', 'context', contextText]),
-                ...(isRejoin || activities === '' ? [] : ['', 'recent activity', activities]),
+                ...(isRejoin || contextText === '' ? [] : ['', style('dim', 'context'), contextText]),
+                ...(isRejoin || activities === '' ? [] : ['', style('dim', 'recent activity'), activities]),
                 ...fallback,
             ].join('\n');
             return withPathOutput(squarePath, output, { participantCount: after.participantCount });
@@ -173,7 +175,7 @@ function parseActivity(argv, context) {
         else if (argument === '--no-wait')
             noWait = true;
         else if (argument === '--beside')
-            fail('✕ express does not know --beside\n» square express --help');
+            fail('✕ express does not know --beside\nsquare express --help');
         else if (argument === '--bell')
             bell = true;
         else if (argument === '--no-mention')
@@ -194,11 +196,11 @@ function parseActivity(argv, context) {
     }
     const reach = bell ? 'bell' : undefined;
     if (bell && (noMention || mentions.length > 0))
-        fail('✕ --bell cannot be combined with --mention or --no-mention\n» square express --help');
+        fail('✕ --bell cannot be combined with --mention or --no-mention\nsquare express --help');
     if (noMention && mentions.length > 0)
-        fail('✕ --no-mention cannot be combined with --mention\n» square express --help');
+        fail('✕ --no-mention cannot be combined with --mention\nsquare express --help');
     if (!bell && !noMention && mentions.length === 0)
-        fail('✕ express needs --mention <name>, --no-mention, or --bell\n» square express --help');
+        fail('✕ express needs --mention <name>, --no-mention, or --bell\nsquare express --help');
     if (bodyArgs.length !== 1) {
         if (bodyArgs.length === 0) {
             if (!process.stdin.isTTY)
@@ -320,7 +322,7 @@ export const doneCommand = {
         const name = result.activity.actor;
         const presentation = await openSquare(squarePath, { clock: nowMs });
         const participantCount = (await entryPresentation(presentation, name).finally(() => closeOpenSquare(presentation))).participantCount;
-        return withPathOutput(squarePath, `○ ${participantIdentity(name)} steps out of the square — done · just now`, { participantCount });
+        return withPathOutput(squarePath, `○ ${participantIdentity(name)} steps out of the square — done · ${result.activity.id} · just now`, { participantCount });
     },
     present: (result) => process.stdout.write(result),
 };
@@ -341,7 +343,7 @@ export const holdCommand = {
             const presentationSquare = await openSquare(squarePath, { clock: nowMs });
             const presentation = await eventPresentation(presentationSquare, result.activity.id);
             await closeOpenSquare(presentationSquare);
-            return withPathOutput(squarePath, renderEventCli(presentation.activity), { participantCount: presentation.participantCount, held: true });
+            return withPathOutput(squarePath, `· ${renderRoomChangeText(presentation.activity)} · ${actId(presentation.activity.index)} · just now`, { participantCount: presentation.participantCount, held: true });
         }
         finally {
             await square.close();
@@ -365,7 +367,7 @@ export const resumeCommand = {
             const presentationSquare = await openSquare(squarePath, { clock: nowMs });
             const presentation = await eventPresentation(presentationSquare, result.activity.id);
             await closeOpenSquare(presentationSquare);
-            return withPathOutput(squarePath, renderEventCli(presentation.activity), { participantCount: presentation.participantCount });
+            return withPathOutput(squarePath, `✓ ${renderRoomChangeText(presentation.activity)} · ${actId(presentation.activity.index)} · just now`, { participantCount: presentation.participantCount });
         }
         finally {
             await square.close();

package/dist/decisions.d.ts

@@ -58,6 +58,8 @@ export type ActDecision = {
     type: 'bell_quota';
     nextAt: number;
 };
+/** The unread activity a viewer has not caught up to, grouped by speaker. */
+export declare function unreadActivitySummaries(squareState: SquareState, name: string, now: number): UnreadActivitySummary[];
 export declare function decideAct(squareState: SquareState, input: {
     name: string;
     body: string;

package/dist/decisions.js

@@ -9,7 +9,7 @@ export function resolveKnownName(squareState, name) {
     validateName(name);
     const known = resolveRosterName(squareState, name);
     if (known === undefined) {
-        throw new SquareError('invalid_args', `Unknown participant "${participantIdentity(name)}".`);
+        throw new SquareError('invalid_args', `✕ ${participantIdentity(name)} has never stepped into this square`);
     }
     return known;
 }
@@ -66,6 +66,40 @@ function requireStanding(squareState, act) {
     throw new Error(`Unexpected standing validation result: ${result.reason}`);
 }
 const UNREAD_PREVIEW_LIMIT = 3;
+/** The unread activity a viewer has not caught up to, grouped by speaker. */
+export function unreadActivitySummaries(squareState, name, now) {
+    const delivery = deriveDeliveryModel(squareState);
+    const delta = actDelta(squareState.acts, delivery.cursorFor(name));
+    const unreadPublic = directedPeerSays(squareState, delta, name, delivery);
+    const sayCountByActor = new Map();
+    const unreadByParticipant = new Map();
+    for (const item of unreadPublic) {
+        if (item.kind === 'say') {
+            const key = item.actor.toLocaleLowerCase();
+            sayCountByActor.set(key, (sayCountByActor.get(key) ?? 0) + 1);
+        }
+        if (sameName(item.actor, name))
+            continue;
+        const actorKey = item.actor.toLocaleLowerCase();
+        const currentSummary = unreadByParticipant.get(item.actor);
+        unreadByParticipant.set(item.actor, {
+            count: (currentSummary?.count ?? 0) + 1,
+            latestAt: currentSummary === undefined ? item.at : Math.max(currentSummary.latestAt, item.at),
+            previews: [
+                ...(currentSummary?.previews ?? []),
+                { number: sayCountByActor.get(actorKey) ?? 1, act: item, perception: delivery.perceive(item, name) },
+            ].slice(-UNREAD_PREVIEW_LIMIT),
+        });
+    }
+    return [...unreadByParticipant.entries()]
+        .map(([participant, summary]) => ({
+        name: participant,
+        count: summary.count,
+        latestActivityAgeMs: Math.max(0, now - summary.latestAt),
+        previews: summary.previews,
+    }))
+        .sort((a, b) => a.latestActivityAgeMs - b.latestActivityAgeMs || a.name.localeCompare(b.name));
+}
 export function decideAct(squareState, input) {
     const { now, force } = input;
     const name = resolveStandingName(squareState, input.name);
@@ -81,7 +115,7 @@ export function decideAct(squareState, input) {
         validateName(requested);
         const resolved = joinedNames.find((candidate) => sameName(candidate, requested));
         if (resolved === undefined) {
-            throw new SquareError('invalid_args', `Unknown mention target ${participantIdentity(requested)}.`);
+            throw new SquareError('invalid_args', `✕ ${participantIdentity(requested)} is not standing in this square`);
         }
         if (!mentionNames.some((existing) => sameName(existing, resolved))) {
             if (mentionNames.length >= MAX_IDENTITY_SET_SIZE) {
@@ -126,34 +160,7 @@ export function decideAct(squareState, input) {
     const delta = actDelta(squareState.acts, delivery.cursorFor(name));
     const unreadPublic = directedPeerSays(squareState, delta, name, delivery);
     const unreadRoomChanges = [];
-    const sayCountByActor = new Map();
-    const unreadByParticipant = new Map();
-    for (const item of unreadPublic) {
-        if (item.kind === 'say') {
-            const key = item.actor.toLocaleLowerCase();
-            sayCountByActor.set(key, (sayCountByActor.get(key) ?? 0) + 1);
-        }
-        if (sameName(item.actor, name))
-            continue;
-        const actorKey = item.actor.toLocaleLowerCase();
-        const currentSummary = unreadByParticipant.get(item.actor);
-        unreadByParticipant.set(item.actor, {
-            count: (currentSummary?.count ?? 0) + 1,
-            latestAt: currentSummary === undefined ? item.at : Math.max(currentSummary.latestAt, item.at),
-            previews: [
-                ...(currentSummary?.previews ?? []),
-                { number: sayCountByActor.get(actorKey) ?? 1, act: item, perception: delivery.perceive(item, name) },
-            ].slice(-UNREAD_PREVIEW_LIMIT),
-        });
-    }
-    const activitySummaries = [...unreadByParticipant.entries()]
-        .map(([participant, summary]) => ({
-        name: participant,
-        count: summary.count,
-        latestActivityAgeMs: Math.max(0, now - summary.latestAt),
-        previews: summary.previews,
-    }))
-        .sort((a, b) => a.latestActivityAgeMs - b.latestActivityAgeMs || a.name.localeCompare(b.name));
+    const activitySummaries = unreadActivitySummaries(squareState, name, now);
     const latestActivityAgeMs = activitySummaries[0]?.latestActivityAgeMs;
     const hasUnread = unreadPublic.length > 0;
     const hasFreshUnreadActivity = latestActivityAgeMs !== undefined && latestActivityAgeMs <= UNREAD_BLOCK_GRACE_MS;
@@ -168,7 +175,7 @@ export function decideAct(squareState, input) {
             ...(reach !== undefined ? { reach } : {}),
             ...(reply !== undefined ? { reply } : {}),
         },
-        confirmation: `● heads turn your way — #${ownActCount}`,
+        confirmation: `● your activity lands — #${ownActCount}`,
         ownActCount,
         pendingPublic: unreadPublic,
         pendingRoomChanges: unreadRoomChanges,

package/dist/delivery-health.d.ts

@@ -1,5 +1,6 @@
 import { type DirectedNotificationRoute } from './delivery.js';
-import type { WakeAttempt } from './square-projections.js';
+import { type WakeAttempt } from './square-projections.js';
+import { type WakeReleaseDiagnostic } from './wake-attempts.js';
 export type DeliveryHealthKind = 'awaiting' | 'wake-accepted' | 'wake-unknown' | 'presented-not-delivered' | 'unreachable';
 export interface DeliveryHealthItem {
     squarePath: string;
@@ -18,5 +19,5 @@ export declare function classifyDeliveryHealth(squarePath: string, opts: {
     now?: number;
     env?: NodeJS.ProcessEnv;
 }): Promise<DeliveryHealthItem[]>;
-export declare function renderDeliveryHealth(items: readonly DeliveryHealthItem[]): string[];
+export declare function renderDeliveryHealth(items: readonly DeliveryHealthItem[], releases?: readonly WakeReleaseDiagnostic[], now?: number): string[];
 export declare function doctorDeliveryHealth(squarePath: string, graceMs: number, now?: number, env?: NodeJS.ProcessEnv): Promise<string[]>;

package/dist/delivery-health.js

@@ -1,10 +1,12 @@
+import { deriveDeliveryModel } from './delivery.js';
 import { formatActivityId } from './square-core.js';
 import { participantIdentity, truncateChars } from './presentation.js';
 import { formatDuration } from './time.js';
-import { wakeEvidence } from './wake-evidence.js';
+import { projectWakeEvidenceFromState } from './square-projections.js';
 import { openSquare } from './square-file-adapter.js';
 import { closeOpenSquare } from './open-square.js';
-import { pendingDeliveries } from './views.js';
+import { pendingDeliveriesFromState } from './views.js';
+import { readWakeReleaseDiagnostics } from './wake-attempts.js';
 const DISPLAY_ORDER = [
     'awaiting',
     'wake-accepted',
@@ -19,37 +21,51 @@ const DISPLAY_FIELD_LIMIT = 160;
 export async function classifyDeliveryHealth(squarePath, opts) {
     const now = opts.now ?? Date.now();
     const env = opts.env ?? process.env;
-    const square = await openSquare(squarePath, { clock: () => now });
-    const pending = await pendingDeliveries(square).finally(() => closeOpenSquare(square));
-    const items = [];
-    for (const delivery of pending) {
-        for (const note of delivery.notifications) {
-            const ageMs = Math.max(0, now - note.item.at);
-            const evidence = await wakeEvidence(squarePath, note.recipient, note.item.index, now, env);
-            const kind = evidence.presented
-                ? 'presented-not-delivered'
-                : evidence.terminal?.outcome === 'accepted'
-                    ? 'wake-accepted'
-                    : evidence.terminal?.outcome === 'unknown'
-                        ? 'wake-unknown'
-                        : ageMs > opts.graceMs && evidence.attemptableRoutes.length === 0
-                            ? 'unreachable'
-                            : 'awaiting';
-            const attempt = evidence.terminal ?? evidence.attempts.at(-1);
-            items.push({
-                squarePath,
-                recipient: note.recipient,
-                actIndex: note.item.index,
-                actor: note.item.actor,
-                at: note.item.at,
-                ageMs,
-                route: note.route,
-                kind,
-                ...(attempt === undefined ? {} : { attempt }),
-            });
+    const square = await openSquare(squarePath, { clock: () => now, env });
+    try {
+        const { state } = await square.artifact.read();
+        const delivery = deriveDeliveryModel(state);
+        const pending = pendingDeliveriesFromState(state, delivery);
+        const evidenceProjection = await projectWakeEvidenceFromState({
+            location: squarePath,
+            state,
+            hostLedger: square.hostLedger,
+            now,
+            delivery,
+        });
+        const items = [];
+        for (const pendingDelivery of pending) {
+            for (const note of pendingDelivery.notifications) {
+                const ageMs = Math.max(0, now - note.item.at);
+                const evidence = evidenceProjection.evidence(pendingDelivery.recipient, note.item.index);
+                const kind = evidence.presented
+                    ? 'presented-not-delivered'
+                    : evidence.terminal?.outcome === 'accepted'
+                        ? 'wake-accepted'
+                        : evidence.terminal?.outcome === 'unknown'
+                            ? 'wake-unknown'
+                            : ageMs > opts.graceMs && evidence.attemptableRoutes.length === 0
+                                ? 'unreachable'
+                                : 'awaiting';
+                const attempt = evidence.terminal ?? evidence.attempts.at(-1);
+                items.push({
+                    squarePath,
+                    recipient: pendingDelivery.recipient,
+                    actIndex: note.item.index,
+                    actor: note.item.actor,
+                    at: note.item.at,
+                    ageMs,
+                    route: note.route,
+                    kind,
+                    ...(attempt === undefined ? {} : { attempt }),
+                });
+            }
         }
+        return items;
+    }
+    finally {
+        await closeOpenSquare(square);
     }
-    return items;
 }
 function displayField(value) {
     const truncated = truncateChars(value, DISPLAY_FIELD_LIMIT - 1);
@@ -59,24 +75,40 @@ function formatItem(item) {
     const evidence = item.attempt?.signature === undefined ? '' : ` · ${displayField(item.attempt.signature)}`;
     return `  · ${formatActivityId(item.actIndex)} → ${displayField(participantIdentity(item.recipient))} from ${displayField(participantIdentity(item.actor))} · ${formatDuration(item.ageMs)}${evidence}`;
 }
-export function renderDeliveryHealth(items) {
-    if (items.length === 0)
-        return ['✓ no pending delivery attention'];
-    const out = [`· delivery attention · ${items.length} pending`];
-    let displayed = 0;
-    for (const kind of DISPLAY_ORDER) {
-        const group = items.filter((item) => item.kind === kind);
-        if (group.length === 0)
-            continue;
-        out.push(`${ACTIONABLE.has(kind) ? '✕' : '○'} ${kind}: ${group.length}`);
-        const details = group.slice(0, DETAIL_LIMIT - displayed);
-        out.push(...details.map(formatItem));
-        displayed += details.length;
+export function renderDeliveryHealth(items, releases = [], now = Date.now()) {
+    const out = items.length === 0 ? ['✓ no pending delivery attention'] : [`· delivery attention · ${items.length} pending`];
+    if (items.length > 0) {
+        let displayed = 0;
+        for (const kind of DISPLAY_ORDER) {
+            const group = items.filter((item) => item.kind === kind);
+            if (group.length === 0)
+                continue;
+            out.push(`${ACTIONABLE.has(kind) ? '✕' : '○'} ${kind}: ${group.length}`);
+            const details = group.slice(0, DETAIL_LIMIT - displayed);
+            out.push(...details.map(formatItem));
+            displayed += details.length;
+        }
+        if (items.length > DETAIL_LIMIT)
+            out.push(`${DETAIL_LIMIT} of ${items.length} pending details shown`);
+    }
+    if (releases.length > 0) {
+        out.push(`· recent wake releases · ${releases.length}`);
+        out.push(...releases.slice(0, DETAIL_LIMIT).map((release) => formatRelease(release, now)));
+        if (releases.length > DETAIL_LIMIT)
+            out.push(`${DETAIL_LIMIT} of ${releases.length} wake releases shown`);
     }
-    if (items.length > DETAIL_LIMIT)
-        out.push(`${DETAIL_LIMIT} of ${items.length} pending details shown`);
     return out;
 }
+function formatRelease(release, now) {
+    const route = displayField(release.routeKind ?? 'unknown route');
+    const reason = displayField(release.signature ?? 'reason not recorded');
+    const age = formatDuration(Math.max(0, now - release.at));
+    const message = release.message === undefined ? '' : ` — ${displayField(release.message)}`;
+    const diagnostic = release.diagnostic === undefined ? '' : ` · ${displayField(JSON.stringify(release.diagnostic))}`;
+    return `  · ${formatActivityId(release.attention.actIndex)} → ${displayField(participantIdentity(release.attention.recipient))} · ${route} · ${reason} · ${age}${message}${diagnostic}`;
+}
 export async function doctorDeliveryHealth(squarePath, graceMs, now = Date.now(), env = process.env) {
-    return renderDeliveryHealth(await classifyDeliveryHealth(squarePath, { graceMs, now, env }));
+    const items = await classifyDeliveryHealth(squarePath, { graceMs, now, env });
+    const releases = await readWakeReleaseDiagnostics({ location: squarePath, now, env });
+    return renderDeliveryHealth(items, releases, now);
 }

package/dist/delivery-operations.js

@@ -4,6 +4,22 @@ import { nameKey } from './model.js';
 import { deriveDeliveryModel } from './delivery.js';
 import { currentSessionBindings, isWakeRouteAttemptable, presentationSuppressesWake, projectPresentationEvidence } from './square-projections.js';
 import { retireWakeRouteFromArtifact } from './routes.js';
+import { redactCurrentDiagnostic } from './diagnostic-redaction.js';
+async function releaseWakeClaim(input, details) {
+    await input.hostLedger.releaseEvidence({
+        location: input.location,
+        participant: input.participant,
+        session: input.session,
+        activity: input.activity,
+        kind: 'wake',
+        claimToken: input.claimToken,
+        ...(input.routeKind === undefined ? {} : { routeKind: input.routeKind }),
+        ...(input.attemptN === undefined ? {} : { attemptN: input.attemptN }),
+        signature: details.signature,
+        message: redactCurrentDiagnostic(details.message),
+        ...(details.diagnostic === undefined ? {} : { diagnostic: redactCurrentDiagnostic(details.diagnostic) }),
+    });
+}
 async function attemptWakeWithin(transport, request, timeoutMs, beforeSend) {
     let timer;
     const timeout = new Promise((resolve) => {
@@ -119,7 +135,10 @@ export async function deliverPending(input) {
                 if (lease.type === 'ambiguous') {
                     let recovered = await input.hostLedger.claimEvidence({ location: input.location, participant: membership.recipient, session: route.session, activity, kind: 'wake', leaseMs, claimToken: lease.lease.leaseId });
                     if (recovered.status === 'busy' && recovered.record.claimToken !== undefined) {
-                        await input.hostLedger.releaseEvidence({ location: input.location, participant: membership.recipient, session: route.session, activity, kind: 'wake', claimToken: recovered.record.claimToken });
+                        await releaseWakeClaim({ hostLedger: input.hostLedger, location: input.location, participant: membership.recipient, session: route.session, activity, claimToken: recovered.record.claimToken, routeKind: lease.lease.routeKind ?? route.route.kind, attemptN: lease.lease.attemptN }, {
+                            signature: 'stale_dispatch_claim_recovered',
+                            message: 'A stale dispatch claim was released so recovery could continue.',
+                        });
                         recovered = await input.hostLedger.claimEvidence({ location: input.location, participant: membership.recipient, session: route.session, activity, kind: 'wake', leaseMs, claimToken: lease.lease.leaseId });
                     }
                     if (recovered.status === 'acquired') {
@@ -168,7 +187,10 @@ export async function deliverPending(input) {
                 const claimToken = claim.claimToken;
                 const dispatching = await input.hostLedger.transitionWakeDispatch({ attention, leaseId, phase: 'dispatching', leaseMs, routeKind: route.route.kind, attemptN, session: route.session });
                 if (!dispatching) {
-                    await input.hostLedger.releaseEvidence({ location: input.location, participant: membership.recipient, session: route.session, activity, kind: 'wake', claimToken }).catch(() => undefined);
+                    await releaseWakeClaim({ hostLedger: input.hostLedger, location: input.location, participant: membership.recipient, session: route.session, activity, claimToken, routeKind: route.route.kind, attemptN }, {
+                        signature: 'dispatch_claim_transition_failed',
+                        message: 'The wake dispatch claim could not enter the dispatching phase.',
+                    }).catch(() => undefined);
                     await input.hostLedger.releaseWakeDispatch({ attention, leaseId, session: route.session });
                     continue;
                 }
@@ -190,7 +212,11 @@ export async function deliverPending(input) {
                     && published.kind === route.route.kind
                     && JSON.stringify(published.address) === JSON.stringify(route.route.address));
                 if (!stillPending || !stillBound || !stillPublished) {
-                    await input.hostLedger.releaseEvidence({ location: input.location, participant: membership.recipient, session: route.session, activity, kind: 'wake', claimToken }).catch(() => undefined);
+                    await releaseWakeClaim({ hostLedger: input.hostLedger, location: input.location, participant: membership.recipient, session: route.session, activity, claimToken, routeKind: route.route.kind, attemptN }, {
+                        signature: 'pre_send_revalidation_failed',
+                        message: 'Wake was not sent because the activity, session binding, or published route changed before dispatch.',
+                        diagnostic: { pending: stillPending, bound: stillBound, publishedRoute: stillPublished },
+                    }).catch(() => undefined);
                     await input.hostLedger.releaseWakeDispatch({ attention, leaseId, session: route.session }).catch(() => undefined);
                     continue;
                 }
@@ -200,7 +226,11 @@ export async function deliverPending(input) {
                 }
                 catch { /* capability is handled by the transport path */ }
                 if (presentationSuppressesWake(latestPresentations)) {
-                    await input.hostLedger.releaseEvidence({ location: input.location, participant: membership.recipient, session: route.session, activity, kind: 'wake', claimToken }).catch(() => undefined);
+                    await releaseWakeClaim({ hostLedger: input.hostLedger, location: input.location, participant: membership.recipient, session: route.session, activity, claimToken, routeKind: route.route.kind, attemptN }, {
+                        signature: 'presentation_already_recorded',
+                        message: 'Wake was suppressed because presentation evidence already exists.',
+                        diagnostic: { outcomes: latestPresentations.map((row) => row.outcome) },
+                    }).catch(() => undefined);
                     await input.hostLedger.releaseWakeDispatch({ attention, leaseId, session: route.session }).catch(() => undefined);
                     continue;
                 }
@@ -221,13 +251,20 @@ export async function deliverPending(input) {
                     outcome = { outcome: 'unknown', diagnostic: error instanceof Error ? error.message : String(error) };
                 }
                 if (suppressedDuringSend) {
-                    await input.hostLedger.releaseEvidence({ location: input.location, participant: membership.recipient, session: route.session, activity, kind: 'wake', claimToken }).catch(() => undefined);
+                    await releaseWakeClaim({ hostLedger: input.hostLedger, location: input.location, participant: membership.recipient, session: route.session, activity, claimToken, routeKind: route.route.kind, attemptN }, {
+                        signature: 'presentation_recorded_during_dispatch',
+                        message: 'Wake was cancelled because presentation evidence appeared before the final send check.',
+                    }).catch(() => undefined);
                     await input.hostLedger.releaseWakeDispatch({ attention, leaseId, session: route.session }).catch(() => undefined);
                     continue;
                 }
                 attempted += 1;
                 if (outcome.outcome === 'not-capable') {
-                    await input.hostLedger.releaseEvidence({ location: input.location, participant: membership.recipient, session: route.session, activity, kind: 'wake', claimToken }).catch(() => undefined);
+                    await releaseWakeClaim({ hostLedger: input.hostLedger, location: input.location, participant: membership.recipient, session: route.session, activity, claimToken, routeKind: route.route.kind, attemptN }, {
+                        signature: 'transport_not_capable',
+                        message: 'The wake transport reported that it could not deliver this route.',
+                        diagnostic: outcome.diagnostic,
+                    }).catch(() => undefined);
                     await input.hostLedger.releaseWakeDispatch({ attention, leaseId, session: route.session }).catch(() => undefined);
                     notCapableForAttention = true;
                     continue;
@@ -235,12 +272,17 @@ export async function deliverPending(input) {
                 if (outcome.outcome === 'failed' && outcome.unavailable) {
                     if (outcome.routeStale === true)
                         await retireWakeRouteFromArtifact(input.artifact, { location: route.location, participant: route.participant, sessionId: route.session });
-                    await input.hostLedger.releaseEvidence({ location: input.location, participant: membership.recipient, session: route.session, activity, kind: 'wake', claimToken });
+                    await releaseWakeClaim({ hostLedger: input.hostLedger, location: input.location, participant: membership.recipient, session: route.session, activity, claimToken, routeKind: route.route.kind, attemptN: outcome.attemptN ?? attemptN }, {
+                        signature: outcome.signature ?? 'transport_unavailable',
+                        message: outcome.message ?? 'The wake transport was unavailable.',
+                        diagnostic: outcome.diagnostic,
+                    });
                     await input.hostLedger.releaseWakeDispatch({ attention, leaseId, session: route.session });
                     failedForAttention = true;
                     continue;
                 }
-                await input.hostLedger.appendEvidence({ location: input.location, participant: membership.recipient, session: route.session, activity, kind: 'wake', outcome: outcome.outcome, routeKind: route.route.kind, attemptN: outcome.attemptN ?? attemptN, ...(outcome.outcome === 'accepted' && outcome.signature === undefined ? {} : outcome.outcome === 'accepted' ? { signature: outcome.signature } : outcome.outcome === 'failed' ? { message: outcome.message } : { diagnostic: outcome.diagnostic }), claimToken });
+                const safeOutcome = redactCurrentDiagnostic(outcome);
+                await input.hostLedger.appendEvidence({ location: input.location, participant: membership.recipient, session: route.session, activity, kind: 'wake', outcome: safeOutcome.outcome, routeKind: route.route.kind, attemptN: safeOutcome.attemptN ?? attemptN, ...(safeOutcome.signature === undefined ? {} : { signature: safeOutcome.signature }), ...(safeOutcome.outcome !== 'accepted' && safeOutcome.message !== undefined ? { message: safeOutcome.message } : {}), ...(safeOutcome.outcome !== 'accepted' && safeOutcome.diagnostic !== undefined ? { diagnostic: safeOutcome.diagnostic } : {}), claimToken });
                 await input.hostLedger.releaseWakeDispatch({ attention, leaseId, session: route.session });
                 if (outcome.outcome === 'accepted') {
                     acceptedForAttention = true;

package/dist/diagnostic-redaction.d.ts

@@ -0,0 +1,2 @@
+export declare function redactDiagnostic(value: unknown, secret: string | undefined): unknown;
+export declare function redactCurrentDiagnostic(value: unknown, env?: NodeJS.ProcessEnv): unknown;

package/dist/diagnostic-redaction.js

@@ -0,0 +1,40 @@
+const MAX_STRING_LENGTH = 1_000;
+const MAX_COLLECTION_ITEMS = 32;
+const MAX_NESTING = 8;
+function redactText(value, secret) {
+    const withoutSecret = secret?.trim() ? value.split(secret.trim()).join('[redacted]') : value;
+    const withoutUrlPassword = withoutSecret.replace(/([?&]password=)[^&\s]+/gi, '$1[redacted]');
+    return [...withoutUrlPassword].length <= MAX_STRING_LENGTH
+        ? withoutUrlPassword
+        : `${[...withoutUrlPassword].slice(0, MAX_STRING_LENGTH - 1).join('')}…`;
+}
+function redactValue(value, secret, seen, depth) {
+    if (typeof value === 'string')
+        return redactText(value, secret);
+    if (depth >= MAX_NESTING)
+        return '[truncated]';
+    if (Array.isArray(value)) {
+        if (seen.has(value))
+            return '[circular]';
+        seen.add(value);
+        return value.slice(0, MAX_COLLECTION_ITEMS).map((item) => redactValue(item, secret, seen, depth + 1));
+    }
+    if (value !== null && typeof value === 'object') {
+        if (seen.has(value))
+            return '[circular]';
+        seen.add(value);
+        return Object.fromEntries(Object.entries(value).slice(0, MAX_COLLECTION_ITEMS).map(([key, item]) => [
+            key,
+            /password|secret|api[-_]?key|token/i.test(key) && typeof item !== 'boolean'
+                ? '[redacted]'
+                : redactValue(item, secret, seen, depth + 1),
+        ]));
+    }
+    return value;
+}
+export function redactDiagnostic(value, secret) {
+    return redactValue(value, secret, new WeakSet(), 0);
+}
+export function redactCurrentDiagnostic(value, env = process.env) {
+    return redactDiagnostic(value, env.PASEO_PASSWORD);
+}

package/dist/help.js

@@ -66,7 +66,7 @@ const COMMANDS = [
     {
         names: ['harness'], usage: 'harness doctor [claude|codex|opencode|pi|delivery]', usesSquare: true, group: 'maintenance', hiddenFromIndex: true,
         summary: 'Diagnose installed agent-host support.',
-        details: ['Targets:', '  claude, codex, opencode, pi  Diagnose one installed adapter.', '  delivery                      Diagnose delivery for the selected square.'],
+        details: ['Targets:', '  claude, codex, opencode, pi  Diagnose one installed adapter.', '  delivery                      Diagnose pending delivery and recent wake-release reasons for the selected square.'],
     },
     {
         names: ['doctor'], usage: 'doctor', usesSquare: true, group: 'maintenance',

package/dist/host-ledger-file-adapter.js

@@ -154,11 +154,11 @@ export class FileHostLedgerPort {
         return { status: 'degraded', error };
     } }
     async releaseEvidence(i) { const f = this.file('user', 'evidence'), location = await canon(i.location), at = i.now ?? this.clock(); await withFileLock(f + '.lock', LOCK, async () => { const all = await read(f, at, true), same = (x) => x.kind === i.kind && x.location === location && nameKey(x.participant) === nameKey(i.participant) && x.activity === i.activity && x.session === i.session, current = all.findLast(x => same(x) && x.outcome === 'dispatching'); if (current === undefined || current.claimToken !== i.claimToken)
-        return; const tombstone = { ...current, outcome: 'released', at, expiresAt: undefined }; delete tombstone.expiresAt; await write(f, [...all.filter(x => x !== current), tombstone]); }); }
+        return; const tombstone = { ...current, outcome: 'released', at, ...(i.routeKind === undefined ? {} : { routeKind: i.routeKind }), ...(i.attemptN === undefined ? {} : { attemptN: i.attemptN }), ...(i.signature === undefined ? {} : { signature: i.signature }), ...(i.message === undefined ? {} : { message: i.message }), ...(i.diagnostic === undefined ? {} : { diagnostic: i.diagnostic }), expiresAt: undefined }; delete tombstone.expiresAt; await write(f, [...all.filter(x => x !== current), tombstone]); }); }
     async appendEvidence(i) { const f = this.file('user', 'evidence'), r = { ...i, location: await canon(i.location), at: i.at ?? this.clock(), v: 1 }; const token = i.claimToken; if (typeof token !== 'string' || token.length === 0)
         return; await withFileLock(f + '.lock', LOCK, async () => { const all = await read(f, r.at, true); const same = (x) => x.kind === r.kind && x.location === r.location && nameKey(x.participant) === nameKey(r.participant) && x.activity === r.activity && x.session === r.session; const current = all.findLast(x => same(x) && x.outcome === 'dispatching'); if (current === undefined || current.claimToken !== token)
         return; const terminalKey = (x) => same(x) && x.attemptN === r.attemptN && x.outcome !== 'dispatching' && x.outcome !== 'released'; await write(f, [...all.filter(x => x !== current && !terminalKey(x)), r]); }); }
-    async listEvidence(i = {}) { const loc = i.location === undefined ? undefined : await canon(i.location); return (await read(this.file('user', 'evidence'), i.now ?? this.clock())).filter(r => r.outcome !== 'released' && (!loc || r.location === loc) && (!i.participant || nameKey(r.participant) === nameKey(i.participant)) && (!i.session || r.session === i.session) && (!i.activity || r.activity === i.activity) && (!i.kind || r.kind === i.kind)); }
+    async listEvidence(i = {}) { const loc = i.location === undefined ? undefined : await canon(i.location); return (await read(this.file('user', 'evidence'), i.now ?? this.clock())).filter(r => (i.includeReleased === true || r.outcome !== 'released') && (!loc || r.location === loc) && (!i.participant || nameKey(r.participant) === nameKey(i.participant)) && (!i.session || r.session === i.session) && (!i.activity || r.activity === i.activity) && (!i.kind || r.kind === i.kind)); }
     async gcEvidence(i) { const f = this.file('user', 'evidence'), pending = new Set(i.pendingWakeActivities ?? []); await withFileLock(f + '.lock', LOCK, async () => write(f, (await read(f, this.clock(), true)).filter(r => r.at >= i.before || r.kind === 'wake' && r.outcome === 'accepted' && pending.has(r.activity)))); }
     async reconcileBinding(i = {}) { let b = []; try {
         b = [...await this.listPresence({ scopes: i.scopes, now: i.now })];

package/dist/host-ledger.d.ts

@@ -65,9 +65,15 @@ export interface EvidenceClaim {
     readonly claimToken?: string;
     readonly now?: number;
 }
-export type EvidenceRelease = Omit<EvidenceClaim, 'leaseMs'> & {
+/** Release metadata and includeReleased are diagnostic-only; default evidence reads stay behavior-safe. */
+export interface EvidenceRelease extends Omit<EvidenceClaim, 'leaseMs'> {
     readonly claimToken: string;
-};
+    readonly routeKind?: WakeRouteKind;
+    readonly attemptN?: number;
+    readonly signature?: string;
+    readonly message?: string;
+    readonly diagnostic?: unknown;
+}
 export interface EvidenceLookup {
     readonly location?: string;
     readonly participant?: string;
@@ -75,6 +81,7 @@ export interface EvidenceLookup {
     readonly activity?: string;
     readonly kind?: EvidenceRecord['kind'];
     readonly now?: number;
+    readonly includeReleased?: boolean;
 }
 export interface EvidenceGc {
     readonly before: number;