@astrosheep/square 0.3.9 → 0.3.11

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

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

package/dist/activity.js

@@ -7,6 +7,7 @@ import { SquareError, validateName } from './model.js';
 import { expressHintLine, renderActivityBlocked, renderActivityLimit, renderExpressNoWait, renderExpressWaiting, renderPendingFeed, withPathOutput, } from './presentation.js';
 import { currentHold, inSquareCount, nowMs, SLEEP_MS, resolveRosterName } from './runtime.js';
 import { resolveKnownName } from './decisions.js';
+import { dispatchActNotifications } from './notifications.js';
 import { execute } from './square-application.js';
 import { formatTimestamp } from './time.js';
 function draftDirFor(squarePath) {
@@ -83,6 +84,9 @@ export async function cmdActivity(squarePath, name, activity, resolveBody, opts)
         const held = currentHold(freshDoc.acts).active;
         switch (decision.type) {
             case 'sent': {
+                const sayAct = committed.acts.find((act) => act.kind === 'say');
+                if (sayAct !== undefined)
+                    await dispatchActNotifications(squarePath, sayAct);
                 const hasPending = decision.pendingPublic.length > 0 || decision.pendingRoomChanges.length > 0;
                 const pending = hasPending ? `\n\n${renderPendingFeed(freshDoc.acts, decision.pendingPublic, decision.pendingRoomChanges)}` : '';
                 const hint = expressHintLine(decision.ownActCount);

package/dist/artifact.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import { ACTIVITIES_HEADING, ACTIVITIES_MARKER, ACT_MARKER_PREFIX, WARMUP_HEADING, WARMUP_MARKER, SquareError, CURRENT_FORMAT_VERSION, formatHardCap, sameName, } from './model.js';
 import { formatTimestamp, parseTimestamp } from './time.js';
+import { isWakeRouteKind } from './model.js';
 const V2_KINDS = new Set(['say', 'join', 'done', 'hold', 'resume']);
 export function quoteBody(body) {
     const normalized = body.replace(/\r\n/g, '\n').trim();
@@ -64,6 +65,7 @@ export function emptyRuntimeState(nextActIndex = 0) {
         cursors: {},
         deliveryReceipts: {},
         leases: {},
+        notifyLeases: {},
     };
 }
 function renderFrontmatter(doc) {
@@ -136,12 +138,16 @@ function validateRuntimeSidecar(squarePath, value) {
     if (!isObject(value.leases) || !Object.values(value.leases).every(isWatchLease)) {
         throw invalidRuntimeSidecar(squarePath, 'leases contains an invalid watch lease.');
     }
+    if (value.notifyLeases !== undefined && (!isObject(value.notifyLeases) || !Object.values(value.notifyLeases).every(isNotifyLease))) {
+        throw invalidRuntimeSidecar(squarePath, 'notifyLeases contains an invalid notify lease.');
+    }
     return {
         version: 2,
         nextActIndex: value.nextActIndex,
         cursors: value.cursors,
         deliveryReceipts: value.deliveryReceipts,
         leases: value.leases,
+        notifyLeases: (value.notifyLeases ?? {}),
     };
 }
 export function loadRuntimeSidecar(squarePath, fallbackRuntime) {
@@ -284,6 +290,21 @@ export function isWatchLease(value) {
     const mention = value.filter.mention;
     return mention === undefined || typeof mention === 'string';
 }
+export function isNotifyLease(value) {
+    if (!isObject(value))
+        return false;
+    if (typeof value.leaseId !== 'string' || value.leaseId === '')
+        return false;
+    if (typeof value.expiresAt !== 'number' || !Number.isFinite(value.expiresAt))
+        return false;
+    if (value.phase !== 'claimed' && value.phase !== 'dispatching')
+        return false;
+    if (value.attemptN !== undefined && (typeof value.attemptN !== 'number' || !Number.isInteger(value.attemptN) || value.attemptN <= 0))
+        return false;
+    if (value.routeKind !== undefined && !isWakeRouteKind(value.routeKind))
+        return false;
+    return value.phase !== 'dispatching' || (value.attemptN !== undefined && value.routeKind !== undefined);
+}
 function invalidVersionGuidance(reason) {
     return new SquareError('invalid_args', `${reason} This format is no longer supported. Create a new square with \`square build\`.`);
 }
@@ -439,7 +460,11 @@ function normalizeActMeta(marker, kind, actor, head) {
     if (marker.reply !== undefined && kind !== 'say') {
         throw new SquareError('invalid_args', 'Invalid square: only say acts may reply to another activity.');
     }
-    return { index: marker.index, ...(marker.reach !== undefined ? { reach: marker.reach } : {}), ...(marker.reply !== undefined ? { reply: marker.reply } : {}) };
+    return {
+        index: marker.index,
+        ...(marker.reach !== undefined ? { reach: marker.reach } : {}),
+        ...(marker.reply !== undefined ? { reply: marker.reply } : {}),
+    };
 }
 export function activitiesSourceLines(text) {
     const lines = text.split('\n');
@@ -490,7 +515,13 @@ function parseActBlock(blockLines) {
             i++;
         body = unquoteBody(blockLines.slice(i));
     }
-    return { ...head, body, index: meta.index, ...(meta.reach !== undefined ? { reach: meta.reach } : {}), ...(meta.reply !== undefined ? { reply: meta.reply } : {}) };
+    return {
+        ...head,
+        body,
+        index: meta.index,
+        ...(meta.reach !== undefined ? { reach: meta.reach } : {}),
+        ...(meta.reply !== undefined ? { reply: meta.reply } : {}),
+    };
 }
 function parseActs(text) {
     const lines = activitiesSourceLines(text);

package/dist/cli/context.js

@@ -118,7 +118,7 @@ export function parseGlobalArgs(rawArgs) {
     let requestedPath;
     let name;
     for (let index = 0; index < args.length; index++) {
-        if (args[index] === '--square-path') {
+        if (args[index] === '--location') {
             requestedPath = requireValue(args, index, args[index]);
             args.splice(index, 2);
             index -= 1;

package/dist/cli/maintenance-commands.js

@@ -19,6 +19,17 @@ function readSquareText(squarePath) {
 function quarantinePath(squarePath) {
     return squarePath.replace(/\.md$/, '') + '.quarantine.md';
 }
+function registryActs(squarePath) {
+    if (!fs.existsSync(squarePath))
+        return [];
+    try {
+        return loadSquare(squarePath).acts;
+    }
+    catch {
+        // A temporarily unreadable artifact cannot disprove a cache binding.
+        return undefined;
+    }
+}
 export const doctorCommand = {
     parse(argv, context) {
         let fix = false;
@@ -59,7 +70,7 @@ export const doctorCommand = {
             };
         }
         const repaired = repair.repaired;
-        const registry = pruneRegistry();
+        const registry = pruneRegistry(registryActs);
         if (registry.removed > 0) {
             repaired.actions.push({ message: `pruned ${registry.removed} obsolete registry membership(s)` });
         }

package/dist/cli/observation-commands.js

@@ -3,11 +3,11 @@ import { runClaudeHook } from '../claude-hook.js';
 import { runCodexHook } from '../codex-hook.js';
 import { coreActivities, coreParticipants, coreStatus } from '../decisions.js';
 import { sessionInbox } from '../inbox.js';
+import { sweepPendingNotifications } from '../notifications.js';
 import { cmdListSquares } from '../list.js';
 import { sameName } from '../model.js';
 import { commandPrefix, participantCommandPrefix, renderActivitiesView, renderGrepActivitiesView, renderVisibleEvent, withPathOutput, } from '../presentation.js';
-import { recordLocalJoin } from '../registry.js';
-import { actId, inSquareCount, isCurrentlyJoined, nowMs, resolveRosterName, sayNumberFor, } from '../runtime.js';
+import { actId, inSquareCount, nowMs, sayNumberFor } from '../runtime.js';
 import { cmdStream, cmdStreamNdjson } from '../stream.js';
 import { formatRelativeTime, formatTimestamp, parseTimeOrRelative } from '../time.js';
 import { cmdWatch } from '../watch.js';
@@ -93,6 +93,7 @@ export const catchCommand = {
     },
     async execute(intent, context) {
         await cmdWatch(context.squarePath, requireParticipant(context.name), intent);
+        await sweepPendingNotifications(context.squarePath);
     },
     present: () => { },
 };
@@ -440,17 +441,3 @@ function hookCommand(runHook) {
 }
 export const claudeHookCommand = hookCommand(runClaudeHook);
 export const codexHookCommand = hookCommand(runCodexHook);
-/** Maintain the local discovery cache before participant-facing adapters run. */
-export function refreshLocalRegistration(squarePath, name) {
-    if (name === undefined)
-        return;
-    try {
-        const doc = loadSquare(squarePath);
-        const known = resolveRosterName(doc, name);
-        if (known !== undefined && isCurrentlyJoined(doc.acts, known))
-            recordLocalJoin(known, squarePath);
-    }
-    catch {
-        // The machine-local discovery cache never makes a Square command fail.
-    }
-}

package/dist/cli/program.js

@@ -1,7 +1,6 @@
 import { helpRequest } from '../help.js';
 import { SquareError } from '../model.js';
 import { defaultContext, parseGlobalArgs } from './context.js';
-import { refreshLocalRegistration } from './observation-commands.js';
 import { executeRegisteredCommand, findCommand } from './registry.js';
 function isMutatingCommand(command, argv) {
     if (['build', 'join', 'catch', 'express', 'done', 'hold', 'resume', 'compact'].includes(command))
@@ -37,9 +36,6 @@ export async function runCli(rawArgs = process.argv.slice(2)) {
             process.stderr.write('✕ more than one square is active here; choose the path before changing or consuming activity.\n» square list\n');
             process.exit(2);
         }
-        if (['express', 'catch', 'done', 'hold', 'resume'].includes(command)) {
-            refreshLocalRegistration(parsed.squarePath, parsed.name);
-        }
         await executeRegisteredCommand(command, parsed.args.slice(1), defaultContext(command, parsed.squarePath, parsed.name));
     }
     catch (error) {

package/dist/cli/square-commands.js

@@ -3,7 +3,8 @@ import { loadSquare } from '../artifact.js';
 import { cmdCompact } from '../compact.js';
 import { SquareError, formatHardCap, validateName, } from '../model.js';
 import { participantCommandPrefix, quoteShell, renderEventCli, renderPublicTail, withPathOutput, } from '../presentation.js';
-import { hasAutomaticDeliveryIdentity, recordLocalDone, recordLocalJoin } from '../registry.js';
+import { hasAutomaticDeliveryIdentity, localParticipantOwner, recordLocalDone, recordLocalJoin } from '../registry.js';
+import { sweepPendingNotifications } from '../notifications.js';
 import { inSquareCount, isCurrentlyJoined, nowMs, resolveRosterName } from '../runtime.js';
 import { createSquare, execute } from '../square-application.js';
 import { fail, parseHardCap, parsePositiveInteger, readPipedBodyFallback, readStdinSync, requireParticipant, requireValue, resolveBody, usage, } from './context.js';
@@ -56,6 +57,7 @@ export const buildCommand = {
 };
 function parseJoin(argv, context) {
     let lastN = 10;
+    let kick = false;
     for (let index = 0; index < argv.length; index++) {
         if (argv[index] === '--last') {
             lastN = parsePositiveInteger(requireValue(argv, index, argv[index]), argv[index]);
@@ -64,11 +66,14 @@ function parseJoin(argv, context) {
         else if (argv[index] === '--all') {
             lastN = null;
         }
+        else if (argv[index] === '--kick') {
+            kick = true;
+        }
         else {
             usage(context.command);
         }
     }
-    return { name: requireParticipant(context.name), lastN };
+    return { name: requireParticipant(context.name), lastN, kick };
 }
 export const joinCommand = {
     parse: parseJoin,
@@ -81,6 +86,7 @@ export const joinCommand = {
             const after = loadSquare(context.squarePath);
             const preamble = after.preamble.at(-1) === '---' ? after.preamble.slice(0, -1) : after.preamble;
             recordLocalJoin(joinedName, context.squarePath);
+            await sweepPendingNotifications(context.squarePath);
             const activities = renderPublicTail(after.acts, intent.lastN, nowMs(), joinedName);
             const contextText = preamble.join('\n').trim();
             const fallback = hasAutomaticDeliveryIdentity()
@@ -102,11 +108,24 @@ export const joinCommand = {
             const joinedName = resolveRosterName(doc, intent.name);
             if (joinedName === undefined || !isCurrentlyJoined(doc.acts, joinedName))
                 throw error;
+            const reconnect = localParticipantOwner(context.squarePath, joinedName) !== undefined;
+            if (!intent.kick && !reconnect) {
+                fail([
+                    `✕ ${joinedName} 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(context.squarePath, joinedName)} join --kick`,
+                ].join('\n'));
+            }
             recordLocalJoin(joinedName, context.squarePath);
+            await sweepPendingNotifications(context.squarePath);
             const fallback = hasAutomaticDeliveryIdentity()
                 ? ''
                 : `\n» ${participantCommandPrefix(context.squarePath, joinedName)} catch --idle 30m\n  no session delivery detected — keep this catch open for new activity`;
-            return withPathOutput(context.squarePath, `● ${joinedName} is already in the square${fallback}`, { participantCount: inSquareCount(doc) });
+            const line = reconnect && !intent.kick
+                ? `● you are already in the square`
+                : `✓ you banished the original ${joinedName} — the name is yours`;
+            return withPathOutput(context.squarePath, `${line}${fallback}`, { participantCount: inSquareCount(doc) });
         }
     },
     present: (result) => process.stdout.write(result),
@@ -156,6 +175,7 @@ function parseActivity(argv, context) {
 export const expressCommand = {
     parse: parseActivity,
     async execute(intent, context) {
+        await sweepPendingNotifications(context.squarePath);
         const reachArg = intent.reach === 'bell' ? ' --bell' : intent.reach === undefined ? '' : ` --beside ${quoteShell(intent.reach.beside)}`;
         await cmdActivity(context.squarePath, intent.name, intent.activity, resolveBody, {
             force: intent.force,

package/dist/cmd/notify-once.js

@@ -1,13 +1,12 @@
 #!/usr/bin/env node
 import { resolve } from 'node:path';
 import { setTimeout as sleep } from 'node:timers/promises';
-import { recordNotificationFailure } from '../notification-failures.js';
-import { notificationDeliveryWaitMs, processActNotificationsOnce } from '../notifications.js';
+import { processActNotificationsOnce, wakeGraceMs } from '../notifications.js';
 function args(argv) {
     let squarePath;
     let actIndex;
     for (let index = 0; index < argv.length; index += 1) {
-        if (argv[index] === '--square-path' && argv[index + 1] !== undefined)
+        if (argv[index] === '--location' && argv[index + 1] !== undefined)
             squarePath = resolve(argv[++index]);
         else if (argv[index] === '--act-index' && /^\d+$/.test(argv[index + 1] ?? ''))
             actIndex = Number(argv[++index]);
@@ -15,25 +14,16 @@ function args(argv) {
             throw new Error(`Unknown notify-once argument: ${argv[index]}`);
     }
     if (squarePath === undefined || actIndex === undefined)
-        throw new Error('notify-once requires --square-path and --act-index.');
+        throw new Error('notify-once requires --location and --act-index.');
     return { squarePath, actIndex };
 }
 async function main() {
     if (process.env.SQUARE_DISABLE_PASEO_WAKE === '1')
         return;
     const { squarePath, actIndex } = args(process.argv.slice(2));
-    await sleep(notificationDeliveryWaitMs());
+    await sleep(wakeGraceMs());
     await processActNotificationsOnce(squarePath, actIndex);
 }
-main().catch((error) => {
-    const squarePath = process.argv.includes('--square-path') ? process.argv[process.argv.indexOf('--square-path') + 1] : undefined;
-    if (squarePath) {
-        recordNotificationFailure(squarePath, {
-            actIndex: Number(process.argv[process.argv.indexOf('--act-index') + 1]) || 0,
-            sink: 'worker',
-            message: error instanceof Error ? error.message : String(error),
-            diagnostic: { phase: 'worker' },
-        });
-    }
+main().catch(() => {
     process.exitCode = 0;
 });

package/dist/decisions.js

@@ -46,7 +46,11 @@ export function decideAct(doc, input) {
     }
     const state = foldedState(doc);
     const current = participantState(state, name);
-    const result = validate(state, { kind: 'say', actor: name, at: now, body, ...(reach !== undefined ? { reach } : {}), ...(reply !== undefined ? { reply } : {}) }, { hardCap: doc.hardCap, throttlePerMinute: doc.throttlePerMinute, throttleWindowMs: THROTTLE_WINDOW_MS });
+    const result = validate(state, {
+        kind: 'say', actor: name, at: now, body,
+        ...(reach !== undefined ? { reach } : {}),
+        ...(reply !== undefined ? { reply } : {}),
+    }, { hardCap: doc.hardCap, throttlePerMinute: doc.throttlePerMinute, throttleWindowMs: THROTTLE_WINDOW_MS });
     if (!result.ok) {
         if (result.reason === 'done')
             throw new SquareError('conflict', `${name} is done; rejoin to express again`);
@@ -101,7 +105,11 @@ export function decideAct(doc, input) {
     const ownActCount = (current?.activityCount ?? 0) + 1;
     return {
         type: 'sent',
-        act: { kind: 'say', actor: name, at: now, body, ...(reach !== undefined ? { reach } : {}), ...(reply !== undefined ? { reply } : {}) },
+        act: {
+            kind: 'say', actor: name, at: now, body,
+            ...(reach !== undefined ? { reach } : {}),
+            ...(reply !== undefined ? { reply } : {}),
+        },
         confirmation: `● heads turn your way — #${ownActCount}`,
         ownActCount,
         pendingPublic: unreadPublic,

package/dist/delivery-health.js

@@ -1,143 +1,62 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
 import { loadSquare } from './artifact.js';
-import { deriveDeliveryModel } from './delivery.js';
-import { readNotificationFailures } from './notification-failures.js';
-import { isCurrentlyJoined } from './runtime.js';
-import { sameName } from './model.js';
+import { deriveDeliveryModel, } from './delivery.js';
 import { formatDuration } from './time.js';
-const STALE_MS = 60_000;
-const LOOKBACK_MS = 60 * 60 * 1000;
-function positive(name, fallback, env) {
-    const raw = env[name];
-    if (raw === undefined)
-        return fallback;
-    const value = Number(raw);
-    if (!Number.isInteger(value) || value <= 0)
-        throw new Error(`Invalid ${name}: expected a positive integer.`);
-    return value;
-}
-export function deliveryStaleMs(env = process.env) {
-    return positive('SQUARE_DELIVERY_STALE_MS', STALE_MS, env);
-}
-export function deliveryLookbackMs(env = process.env) {
-    return positive('SQUARE_DELIVERY_LOOKBACK_MS', LOOKBACK_MS, env);
-}
-function actedAfter(doc, recipient, actIndex) {
-    return doc.acts.some((act) => act.actor !== undefined && sameName(act.actor, recipient) && act.index > actIndex);
-}
-function pending(squarePath, now) {
+import { joinedRecipients, wakeEvidence } from './wake-evidence.js';
+const DISPLAY_ORDER = [
+    'awaiting',
+    'wake-accepted',
+    'wake-unknown',
+    'presented-not-delivered',
+    'unreachable',
+];
+const ACTIONABLE = new Set(['wake-unknown', 'unreachable']);
+/** Purely classify current pending attention from the artifact and durable ledgers. */
+export function classifyDeliveryHealth(squarePath, opts) {
+    const now = opts.now ?? Date.now();
+    const env = opts.env ?? process.env;
     const doc = loadSquare(squarePath);
     const model = deriveDeliveryModel(doc);
-    const recipients = [...new Set(doc.acts.filter((act) => act.kind === 'join').map((act) => act.actor))]
-        .filter((name) => isCurrentlyJoined(doc.acts, name));
-    return recipients.flatMap((recipient) => model.pendingFor(recipient).map((note) => ({
-        squarePath,
-        recipient: note.recipient,
-        actIndex: note.item.index,
-        actor: note.item.actor,
-        at: note.item.at,
-        ageMs: now - note.item.at,
-        route: note.route,
-        actedAfterWithoutDelivery: actedAfter(doc, note.recipient, note.item.index),
-    })));
-}
-export function partitionPendingDeliveries(squarePath, opts = {}) {
-    const now = opts.now ?? Date.now();
-    const staleMs = opts.staleMs ?? deliveryStaleMs();
-    const lookbackMs = Math.max(opts.lookbackMs ?? deliveryLookbackMs(), staleMs);
-    const recent = [];
-    const historical = [];
-    for (const item of pending(squarePath, now)) {
-        if (item.ageMs >= staleMs && item.ageMs <= lookbackMs)
-            recent.push(item);
-        else if (item.ageMs >= staleMs)
-            historical.push(item);
-    }
-    return { recent, historical };
-}
-function byRecipient(items) {
-    const groups = new Map();
-    for (const item of items)
-        groups.set(item.recipient, [...(groups.get(item.recipient) ?? []), item]);
-    return [...groups].map(([recipient, notes]) => {
-        const oldest = notes.reduce((first, item) => item.at < first.at ? item : first);
-        const adapterFault = notes.some((item) => item.actedAfterWithoutDelivery);
-        return adapterFault
-            ? `  · @${recipient}: ${notes.length} pending; they acted after it without a receipt (act_${oldest.actIndex})`
-            : `  · @${recipient}: ${notes.length} pending (oldest act_${oldest.actIndex} from @${oldest.actor})`;
-    });
-}
-export function formatStaleDeliveryWarnings(recent, historical = [], opts = {}) {
-    const out = [];
-    if (recent.length > 0) {
-        const adapterFaults = recent.filter((item) => item.actedAfterWithoutDelivery);
-        out.push(adapterFaults.length > 0
-            ? `✕ ${adapterFaults.length} pending notification(s) point to an adapter/pull dead path.`
-            : `✕ ${recent.length} recent notification(s) have no delivered receipt.`);
-        out.push(...byRecipient(recent));
+    return joinedRecipients(doc).flatMap((recipient) => model.pendingFor(recipient).map((note) => {
+        const ageMs = Math.max(0, now - note.item.at);
+        const evidence = 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);
+        return {
+            squarePath,
+            recipient: note.recipient,
+            actIndex: note.item.index,
+            actor: note.item.actor,
+            at: note.item.at,
+            ageMs,
+            route: note.route,
+            kind,
+            ...(attempt === undefined ? {} : { attempt }),
+        };
+    }));
+}
+function formatItem(item) {
+    const evidence = item.attempt?.signature === undefined ? '' : ` · ${item.attempt.signature}`;
+    return `  · act_${item.actIndex} → @${item.recipient} from @${item.actor} · ${formatDuration(item.ageMs)}${evidence}`;
+}
+export function doctorDeliveryHealth(squarePath, graceMs, now = Date.now(), env = process.env) {
+    const items = classifyDeliveryHealth(squarePath, { graceMs, now, env });
+    if (items.length === 0)
+        return ['✓ no pending delivery attention'];
+    const out = [`· delivery attention · ${items.length} pending`];
+    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}`);
+        out.push(...group.map(formatItem));
     }
-    if (historical.length > 0) {
-        out.push(`○ ${historical.length} older pending notification(s) remain as historical backlog.`);
-        out.push(...byRecipient(historical));
-        if (opts.previousBacklog !== undefined) {
-            const delta = historical.length - opts.previousBacklog;
-            out.push(delta === 0 ? '  · backlog unchanged since last doctor.' : delta > 0 ? `  · backlog grew by ${delta} since last doctor.` : `  · backlog shrank by ${-delta} since last doctor.`);
-        }
-    }
-    else if ((opts.previousBacklog ?? 0) > 0)
-        out.push(`○ backlog cleared (was ${opts.previousBacklog}).`);
     return out;
 }
-function baselineFile(env) {
-    return env.SQUARE_DELIVERY_BASELINE ?? path.join(os.homedir(), '.square', 'delivery-baseline.json');
-}
-function baseline(squarePath, env) {
-    try {
-        return JSON.parse(fs.readFileSync(baselineFile(env), 'utf8'))[path.resolve(squarePath)]?.backlogCount;
-    }
-    catch {
-        return undefined;
-    }
-}
-function writeBaseline(squarePath, backlogCount, env, at) {
-    const file = baselineFile(env);
-    let rows = {};
-    try {
-        rows = JSON.parse(fs.readFileSync(file, 'utf8'));
-    }
-    catch { }
-    rows[path.resolve(squarePath)] = { backlogCount, at };
-    fs.mkdirSync(path.dirname(file), { recursive: true });
-    fs.writeFileSync(file, `${JSON.stringify(rows, null, 2)}\n`, { mode: 0o600 });
-}
-function formatFailures(squarePath, recent, env) {
-    const failures = readNotificationFailures(squarePath, env);
-    if (failures.length === 0)
-        return [];
-    const pendingKeys = new Set(recent.map((item) => `${item.recipient}\0${item.actIndex}`));
-    const current = failures.filter((item) => item.recipient !== undefined && pendingKeys.has(`${item.recipient}\0${item.actIndex}`));
-    const rows = current.length > 0 ? current : failures;
-    const historical = current.length === 0;
-    const latest = rows.at(-1);
-    const diagnostic = latest.diagnostic;
-    return [
-        historical ? `○ ${rows.length} historical notification failure(s) retained: ${latest.message}` : `✕ ${rows.length} notification attempt(s) failed: ${latest.message}; receipt remains pending.`,
-        ...(diagnostic?.passwordPresent === false ? ['  · PASEO_PASSWORD absent; pass PASEO_PASSWORD to the Codex process.'] : []),
-        `  · ${notificationFailuresPathForDisplay(squarePath, env)}`,
-    ];
-}
-function notificationFailuresPathForDisplay(squarePath, env) {
-    return env.SQUARE_NOTIFICATION_FAILURES ?? path.join(path.dirname(squarePath), 'notification-failures.ndjsonl');
-}
-export function doctorDeliveryHealth(squarePath, now = Date.now(), env = process.env) {
-    const { recent, historical } = partitionPendingDeliveries(squarePath, { now, staleMs: deliveryStaleMs(env), lookbackMs: deliveryLookbackMs(env) });
-    const prior = baseline(squarePath, env);
-    writeBaseline(squarePath, historical.length, env, now);
-    return [
-        `· stale after ${formatDuration(deliveryStaleMs(env))} · scan window ${formatDuration(deliveryLookbackMs(env))}`,
-        ...(recent.length === 0 && historical.length === 0 ? ['✓ no stale undelivered notifications'] : formatStaleDeliveryWarnings(recent, historical, { previousBacklog: prior })),
-        ...formatFailures(squarePath, recent, env),
-    ];
-}

package/dist/doctor.js

@@ -29,6 +29,7 @@ export function planRepair(text) {
             cursors: {},
             deliveryReceipts: {},
             leases: {},
+            notifyLeases: {},
         },
     };
     return { diagnosis, repaired: { doc, actions, quarantinedBlocks: diagnosis.quarantined.map((q) => q.raw) } };