@astrosheep/square 0.3.9 → 0.3.11

package/dist/wake-attempts.js

@@ -0,0 +1,171 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { withFileLockSync } from './file-lock.js';
+import { isWakeRouteKind, nameKey } from './model.js';
+import { canonicalSquarePath } from './registry.js';
+const RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
+const LOCK_STALE_MS = 5 * 60 * 1000;
+const LOCK_RETRY_MS = 10;
+const VALID_OUTCOMES = new Set(['accepted', 'unknown', 'failed']);
+export function wakeAttemptsPath(env = process.env) {
+    return env.SQUARE_WAKE_ATTEMPTS || path.join(os.homedir(), '.square', 'wake-attempts.ndjsonl');
+}
+export function wakeAttentionKey(attention) {
+    return JSON.stringify([canonicalSquarePath(attention.squarePath), `act_${attention.actIndex}`, nameKey(attention.recipient)]);
+}
+function parseRow(raw, now) {
+    let value;
+    try {
+        value = JSON.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+    if (value === null || typeof value !== 'object')
+        return undefined;
+    const row = value;
+    if (row.v !== 1 || typeof row.ts !== 'number' || !Number.isFinite(row.ts) || row.ts > now || now - row.ts > RETENTION_MS ||
+        row.attention === undefined || typeof row.attention.square_path !== 'string' || row.attention.square_path === '' ||
+        typeof row.attention.act_id !== 'string' || !/^act_\d+$/.test(row.attention.act_id) ||
+        typeof row.attention.recipient !== 'string' || row.attention.recipient === '' ||
+        typeof row.outcome !== 'string' || !VALID_OUTCOMES.has(row.outcome) ||
+        typeof row.attempt_n !== 'number' || !Number.isInteger(row.attempt_n) || row.attempt_n <= 0 ||
+        !isWakeRouteKind(row.route_kind) ||
+        (row.signature !== undefined && typeof row.signature !== 'string') ||
+        (row.outcome !== 'accepted' && (typeof row.signature !== 'string' || row.signature === '')) ||
+        (row.message !== undefined && typeof row.message !== 'string'))
+        return undefined;
+    return row;
+}
+function readRowsFromFile(filePath, now) {
+    let raw;
+    try {
+        raw = fs.readFileSync(filePath, 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return [];
+        throw error;
+    }
+    return raw.split('\n').filter(Boolean).map((line) => parseRow(line, now)).filter((row) => row !== undefined);
+}
+function readRows(env, now) {
+    return readRowsFromFile(wakeAttemptsPath(env), now);
+}
+function writeRows(filePath, rows) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    const temporary = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+    fs.writeFileSync(temporary, rows.map((row) => JSON.stringify(row)).join('\n') + (rows.length ? '\n' : ''), {
+        mode: 0o600,
+    });
+    fs.renameSync(temporary, filePath);
+}
+function fromRow(row) {
+    return {
+        at: row.ts,
+        attention: {
+            squarePath: canonicalSquarePath(row.attention.square_path),
+            actIndex: Number(row.attention.act_id.slice(4)),
+            recipient: row.attention.recipient,
+        },
+        routeKind: row.route_kind,
+        outcome: row.outcome,
+        ...(row.signature === undefined ? {} : { signature: row.signature }),
+        attemptN: row.attempt_n,
+        ...(row.message === undefined ? {} : { message: row.message }),
+        ...(row.diagnostic === undefined ? {} : { diagnostic: row.diagnostic }),
+    };
+}
+export function readWakeAttempts(opts = {}) {
+    const now = opts.now ?? Date.now();
+    const expected = opts.attention === undefined ? undefined : wakeAttentionKey(opts.attention);
+    return readRows(opts.env ?? process.env, now)
+        .map(fromRow)
+        .filter((attempt) => expected === undefined || wakeAttentionKey(attempt.attention) === expected);
+}
+export function terminalWakeEvidence(attempts) {
+    return attempts.findLast((attempt) => attempt.outcome === 'accepted' || attempt.outcome === 'unknown');
+}
+export function terminalWakeAttempt(attention, opts = {}) {
+    return terminalWakeEvidence(readWakeAttempts({ attention, ...opts }));
+}
+export function isWakeRouteAttemptable(route, attempts) {
+    if (terminalWakeEvidence(attempts) !== undefined)
+        return false;
+    const failed = attempts.findLast((attempt) => attempt.routeKind === route.kind && attempt.outcome === 'failed');
+    return failed === undefined || route.updatedAt > failed.at;
+}
+export function hasAttemptableWakeRoute(routes, attempts) {
+    return routes.some((route) => isWakeRouteAttemptable(route, attempts));
+}
+export function nextWakeAttemptNumber(attention, opts = {}) {
+    return readWakeAttempts({ attention, ...opts }).reduce((highest, attempt) => Math.max(highest, attempt.attemptN), 0) + 1;
+}
+function redact(value, secret) {
+    if (typeof value === 'string') {
+        const withoutKnownSecret = secret ? value.split(secret).join('[redacted]') : value;
+        return withoutKnownSecret.replace(/([?&]password=)[^&\s]+/gi, '$1[redacted]');
+    }
+    if (Array.isArray(value))
+        return value.map((item) => redact(item, secret));
+    if (value !== null && typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, redact(item, secret)]));
+    }
+    return value;
+}
+function toRow(attempt, env) {
+    const safe = redact(attempt, env.PASEO_PASSWORD);
+    return {
+        v: 1,
+        ts: safe.at,
+        attention: {
+            square_path: canonicalSquarePath(safe.attention.squarePath),
+            act_id: `act_${safe.attention.actIndex}`,
+            recipient: safe.attention.recipient,
+        },
+        route_kind: safe.routeKind,
+        outcome: safe.outcome,
+        ...(safe.signature === undefined ? {} : { signature: safe.signature }),
+        attempt_n: safe.attemptN,
+        ...(safe.message === undefined ? {} : { message: safe.message }),
+        ...(safe.diagnostic === undefined ? {} : { diagnostic: safe.diagnostic }),
+    };
+}
+export function recordWakeAttempt(attempt, env = process.env) {
+    const value = { ...attempt, at: attempt.at ?? Date.now() };
+    if (!isWakeRouteKind(value.routeKind))
+        throw new Error('Wake attempts require a real adapter route kind.');
+    if (value.outcome !== 'accepted' && !value.signature) {
+        throw new Error(`${value.outcome} wake attempts require a transport signature.`);
+    }
+    const file = wakeAttemptsPath(env);
+    withFileLockSync(`${file}.lock`, { retryMs: LOCK_RETRY_MS, staleMs: LOCK_STALE_MS }, () => {
+        writeRows(file, [...readRowsFromFile(file, value.at), toRow(value, env)]);
+    });
+    return value;
+}
+export function recordRecoveredUnknown(attention, lease, env = process.env, at = Date.now()) {
+    const routeKind = lease.routeKind;
+    if (lease.attemptN === undefined || !isWakeRouteKind(routeKind))
+        return undefined;
+    const file = wakeAttemptsPath(env);
+    return withFileLockSync(`${file}.lock`, { retryMs: LOCK_RETRY_MS, staleMs: LOCK_STALE_MS }, () => {
+        const rows = readRowsFromFile(file, at);
+        const attempts = rows.map(fromRow).filter((attempt) => wakeAttentionKey(attempt.attention) === wakeAttentionKey(attention));
+        const terminal = terminalWakeEvidence(attempts);
+        if (terminal !== undefined)
+            return terminal;
+        const value = {
+            at,
+            attention,
+            routeKind,
+            outcome: 'unknown',
+            signature: 'worker_interrupted_during_dispatch',
+            attemptN: lease.attemptN,
+            message: 'The notification worker ended after dispatch began; transport acceptance is unknown.',
+        };
+        writeRows(file, [...rows, toRow(value, env)]);
+        return value;
+    });
+}

package/dist/wake-evidence.js

@@ -0,0 +1,35 @@
+import { loadSquare } from './artifact.js';
+import { isDeliveryDelivered } from './delivery.js';
+import { hasPresentedAttention } from './presented.js';
+import { lookupParticipant } from './registry.js';
+import { isCurrentlyJoined } from './runtime.js';
+import { readWakeRoutes } from './routes.js';
+import { isWakeRouteAttemptable, readWakeAttempts, terminalWakeEvidence, } from './wake-attempts.js';
+export function joinedRecipients(doc) {
+    return [...new Set(doc.acts.filter((act) => act.kind === 'join').map((act) => act.actor))]
+        .filter((name) => isCurrentlyJoined(doc.acts, name));
+}
+/** Project every wake decision from the same primary evidence. */
+export function wakeEvidence(squarePath, recipient, actIndex, now, env) {
+    const doc = loadSquare(squarePath);
+    const owners = new Set(lookupParticipant(squarePath, recipient, now).map((binding) => binding.ownerId));
+    const attempts = readWakeAttempts({ attention: { squarePath, recipient, actIndex }, env, now });
+    const terminal = terminalWakeEvidence(attempts);
+    const routes = readWakeRoutes({ freshOnly: true, now, env })
+        .filter((route) => owners.has(route.ownerId));
+    return {
+        delivered: isDeliveryDelivered(doc, recipient, actIndex),
+        presented: hasPresentedAttention(squarePath, recipient, actIndex, env, now),
+        attempts,
+        ...(terminal === undefined ? {} : { terminal }),
+        attemptableRoutes: terminal === undefined
+            ? routes.filter((route) => isWakeRouteAttemptable(route, attempts))
+            : [],
+    };
+}
+export function wakeIsEligible(evidence) {
+    return !evidence.delivered
+        && !evidence.presented
+        && evidence.terminal === undefined
+        && evidence.attemptableRoutes.length > 0;
+}

package/dist/wake-port.js

@@ -0,0 +1,22 @@
+/** Select routes globally; adapters own only transport-specific live proof and dispatch. */
+export class WakePort {
+    adapters;
+    constructor(adapters) {
+        this.adapters = new Map(adapters.map((adapter) => [adapter.kind, adapter]));
+    }
+    async dispatch(routes, payload, hooks) {
+        for (const route of routes) {
+            const adapter = this.adapters.get(route.kind);
+            if (adapter === undefined)
+                continue;
+            const attemptN = hooks.nextAttemptN();
+            const result = await adapter.dispatch(route.address, payload, () => hooks.beforeSend(route, attemptN));
+            if (result.outcome === 'cancelled')
+                return result;
+            await hooks.record(route, attemptN, result);
+            if (result.outcome === 'accepted' || result.outcome === 'unknown')
+                return { outcome: result.outcome };
+        }
+        return { outcome: 'exhausted' };
+    }
+}

package/dist/wake-sink.js

@@ -1,8 +1,47 @@
 import { spawnSync } from 'node:child_process';
-export function sendPaseoWake({ agentId, prompt }) {
-    const result = spawnSync(process.env.SQUARE_PASEO_BIN || 'paseo', ['send', agentId, '--prompt', prompt, '--no-wait'], { stdio: 'ignore', timeout: 5000, env: process.env });
-    if (result.error)
-        throw result.error;
-    if (result.status !== 0)
-        throw new Error(`paseo send exited with ${result.status ?? 'no status'}`);
+export class PaseoWakeSendError extends Error {
+    kind;
+    constructor(message, kind) {
+        super(message);
+        this.kind = kind;
+        this.name = 'PaseoWakeSendError';
+    }
+}
+function commandError(output) {
+    try {
+        const parsed = JSON.parse(output);
+        if (parsed.error === undefined)
+            return undefined;
+        return {
+            ...(typeof parsed.error.code === 'string' ? { code: parsed.error.code } : {}),
+            message: typeof parsed.error.message === 'string' ? parsed.error.message : output.trim(),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function classifyCommandFailure(code, message) {
+    if (code === 'DAEMON_NOT_RUNNING' || /ECONNREFUSED|ENOENT|not found.*executable/i.test(message))
+        return 'transient';
+    if (/password|auth|unauthori[sz]ed|agent not found|rejected/i.test(message))
+        return 'rejected';
+    return 'unknown';
+}
+function redactUriPassword(value) {
+    return value.replace(/([?&]password=)[^&\s]+/gi, '$1[redacted]');
+}
+export function sendPaseoWake({ agentId, prompt }, opts = {}) {
+    const result = spawnSync(process.env.SQUARE_PASEO_BIN || 'paseo', ['send', agentId, '--prompt', prompt, '--no-wait', '--json'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], timeout: opts.timeoutMs ?? 5000, env: process.env });
+    if (result.error) {
+        const code = result.error.code;
+        const kind = code === 'ENOENT' || code === 'ECONNREFUSED' ? 'transient' : 'unknown';
+        throw new PaseoWakeSendError(result.error.message, kind);
+    }
+    if (result.status === 0)
+        return;
+    const output = `${result.stderr ?? ''}${result.stdout ?? ''}`;
+    const failure = commandError(output);
+    const message = redactUriPassword(failure?.message || output.trim() || `paseo send exited with ${result.status ?? 'no status'}`);
+    throw new PaseoWakeSendError(message, classifyCommandFailure(failure?.code, message));
 }

package/dist/watch.js

@@ -3,12 +3,11 @@ import { loadSquare } from './artifact.js';
 import { SquareError, nameKey, } from './model.js';
 import { markDeliveredNotifications } from './delivery.js';
 import { SLEEP_MS, STALE_MS, WATCH_HEARTBEAT_MS, WATCH_STALE_MS, countSays, currentHold, doneNames, freshWatchLease, hasQuorum, inSquareCount, nowMs, touchPresenceCursor, writeWatchLease, } from './runtime.js';
-import { withSquareLock, writeSquareDoc } from './square-application.js';
+import { execute, withSquareLock, writeSquareDoc } from './square-application.js';
 import { renderWatchForceTakeover, renderWatchAlreadyActive, renderWatchOutput, renderWatchReplaced, renderWatchStatus, participantCommandPrefix, withPathOutput, } from './presentation.js';
 import { ackPeerDelta, deliveryDelta, filteredPeerActivities, filteredRoomChanges, matchesFeedFilter, peerPublicActs, peerRoomChanges, } from './activity-feed.js';
 import { coreParticipants, resolveKnownName } from './decisions.js';
 import { hasAutomaticDeliveryIdentity, localParticipantOwner } from './registry.js';
-import { execute } from './square-application.js';
 function catchDelta(doc, name) {
     return deliveryDelta(doc, name);
 }

package/guides/participant.md

@@ -30,7 +30,7 @@
 
 "哦对。一个名字只在广场上占一个位置。换了 harness session，再跑一次 `join` 会把新 session 接回原来的位置，不会制造第二个你。"
 
-默认广场在 `.square/SQUARE.md`。不在？所有命令自己带 `--square-path <path>`。别站着等人把路喂到你嘴边，恶心。
+默认广场在 `.square/SQUARE.md`。不在？所有命令自己带 `--location <path>`。别站着等人把路喂到你嘴边，恶心。
 
 ### 你的声音，和你的身体——express
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrosheep/square",
-  "version": "0.3.9",
+  "version": "0.3.11",
   "description": "A shared public square where agents join, catch activity, express, and step out when done.",
   "type": "module",
   "bin": {
@@ -38,6 +38,7 @@
   "license": "MIT",
   "devDependencies": {
     "@types/node": "^22",
+    "@types/ws": "^8.18.1",
     "typescript": "^5.8"
   },
   "exports": {
@@ -55,5 +56,9 @@
     "skills": [
       "./skills"
     ]
+  },
+  "dependencies": {
+    "@getpaseo/client": "^0.3.1",
+    "ws": "^8.21.3"
   }
 }

package/skills/brainstorm/SKILL.md

@@ -7,7 +7,7 @@ allowed-tools: Bash(square *), Skill(square)
 # Square Brainstorm
 
 Use this skill when you are coordinating a brainstorm. Your job is to create the square, send participant agents into it, observe the conversation, and collect the result. Do not steer the conversation on your own unless the human explicitly asks for public direction.
-Commands default to `.square/SQUARE.md`; use `--square-path <path>` when you want a different file.
+Commands default to `.square/SQUARE.md`; use `--location <path>` when you want a different file.
 
 ## Build
 
@@ -37,27 +37,27 @@ Send each participant agent this prompt. Replace `<name>` and `<path>`, but do n
 You are <name>, participating in a brainstorm. The square file is at <path>.
 
 First action: enter the square. Read the context, warmup, and recent activity printed by this command before expressing:
-square --square-path <path> --as <name> join
+square --location <path> --as <name> join
 
 Then follow the Happy Path from the join output. Core commands:
-square --square-path <path> --as <name> express - <<'EOF'
+square --location <path> --as <name> express - <<'EOF'
 ...
 EOF
-square --square-path <path> --as <name> catch --mention --idle 10m
-square --square-path <path> --as <name> catch --now
-square --square-path <path> --as <name> catch --idle 10m
-square --square-path <path> history --limit 80
-square --square-path <path> history --from <name> --limit 80
-square --square-path <path> status
-square --square-path <path> --as <name> done - <<'EOF'
+square --location <path> --as <name> catch --mention --idle 10m
+square --location <path> --as <name> catch --now
+square --location <path> --as <name> catch --idle 10m
+square --location <path> history --limit 80
+square --location <path> history --from <name> --limit 80
+square --location <path> status
+square --location <path> --as <name> done - <<'EOF'
 ...
 EOF
 
-For complete history: square --square-path <path> history --all --full
+For complete history: square --location <path> history --all --full
 
 If you are addressing a specific participant, write @name. Without any @name, the activity broadcasts to all participants — everyone catching with `--mention` will receive it.
 
-If an activity is refused because something happened while the participant was not looking, run `square --square-path <path> --as <name> catch --now`, take it in, then express again. `catch --now` catches up without waiting.
+If an activity is refused because something happened while the participant was not looking, run `square --location <path> --as <name> catch --now`, take it in, then express again. `catch --now` catches up without waiting.
 ```
 
 Need another voice later? Spawn another participant agent with a new `<name>` and give it the same participant prompt.
@@ -67,12 +67,12 @@ Need another voice later? Spawn another participant agent with a new `<name>` an
 If you or the human want to participate, choose a participant name and use the participant loop:
 
 ```bash
-square --square-path <path> --as <name> join
-square --square-path <path> --as <name> express - <<'EOF'
+square --location <path> --as <name> join
+square --location <path> --as <name> express - <<'EOF'
 your view
 EOF
-square --square-path <path> --as <name> catch --idle 10m
-square --square-path <path> --as <name> done - <<'EOF'
+square --location <path> --as <name> catch --idle 10m
+square --location <path> --as <name> done - <<'EOF'
 final note
 EOF
 ```
@@ -82,9 +82,9 @@ EOF
 Use these to check progress:
 
 ```bash
-square --square-path <path> history --limit 50
-square --square-path <path> history --from <name>
-square --square-path <path> status
+square --location <path> history --limit 50
+square --location <path> history --from <name>
+square --location <path> status
 ```
 
 `history` reads past public activity without advancing participant presence. `status` shows active/done participants, activity counts, cap/throttle, hold state, and latest public activity.
@@ -96,7 +96,7 @@ When addressing a specific participant, use `@name`; without any `@name`, the ac
 If the human wants to refocus the square, add a constraint, ask a convergence question, or correct its direction, write that direction publicly with a participant name:
 
 ```bash
-square --square-path <path> --as <name> express - <<'EOF'
+square --location <path> --as <name> express - <<'EOF'
 Refocus on <specific direction, constraint, question, or decision needed>.
 EOF
 ```
@@ -106,8 +106,8 @@ Do not add direction on your own. If you notice the square drifting or stuck, re
 Pause the participant loop when a human needs time to read, think, or add another voice:
 
 ```bash
-square --square-path <path> hold "human reading"
-square --square-path <path> resume
+square --location <path> hold "human reading"
+square --location <path> resume
 ```
 
 While held, participant expression and catch pause. Join, done, status, and history still work.
@@ -117,8 +117,8 @@ While held, participant expression and catch pause. Join, done, status, and hist
 When participants are done, collect the public activities:
 
 ```bash
-square --square-path <path> history --all --full        # complete public history
-square --square-path <path> status
+square --location <path> history --all --full        # complete public history
+square --location <path> status
 ```
 
 ## Boundaries

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

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

package/skills/square/SKILL.md

@@ -19,7 +19,7 @@ join once → catch ↔ express → done
 square --as <name> join
 ```
 
-Read the current context and what happened recently before expressing. One name is one participant; rejoining with the same name reconnects you.
+Read the current context and what happened recently before expressing. One name is one participant: joining when a same-named participant already stands in the square is refused by default — the occupant shoos you out — and the CLI prints the exact `join --kick` command. `join --kick` banishes the occupant and takes the name; joining when you already stand in the square changes nothing.
 
 ## Express
 
@@ -58,13 +58,14 @@ Waiting with `catch --idle` is the normal way to be present between expressions;
 
 ## History
 
-`history` looks back without changing what you have caught — remembering, not keeping up. Use `catch` to remain present.
+`history` is the only way to look back without changing what you have caught — remembering, not keeping up. Use `catch` to remain present.
 
 ```bash
 square history --grep 'migration'
+square history --all --full
 ```
 
-See `square history --help` for filters. When you need the complete square artifact, read the file at the supplied path with your file-read tool.
+See `square history --help` for filters. Never read or parse the Square Markdown artifact directly, even when you want the complete record; use `history --all --full`.
 
 ## Hold and step out
 

package/skills/square-feedback/SKILL.md

@@ -38,8 +38,8 @@ Use this template:
 Run a nonblocking catch before expressing so the report does not land over unseen activity:
 
 ```bash
-square --square-path /Users/astrosheep/Developer/square/.square/SQUARE-FEEDBACK.md --as '<participant>' catch --now
-square --square-path /Users/astrosheep/Developer/square/.square/SQUARE-FEEDBACK.md --as '<participant>' express - <<'EOF'
+square --location /Users/astrosheep/Developer/square/.square/SQUARE-FEEDBACK.md --as '<participant>' catch --now
+square --location /Users/astrosheep/Developer/square/.square/SQUARE-FEEDBACK.md --as '<participant>' express - <<'EOF'
 **Square feedback**
 - Area: `catch --now`
 - Square identity: `/absolute/path/to/project/.square/SQUARE-main.md (@participant)`

package/dist/notification-failures.js

@@ -1,54 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-const MAX_BYTES = 1_000_000;
-export function notificationFailuresPath(squarePath, env = process.env) {
-    return env.SQUARE_NOTIFICATION_FAILURES ?? path.join(path.dirname(squarePath), 'notification-failures.ndjsonl');
-}
-function redact(value, secret = process.env.PASEO_PASSWORD) {
-    if (typeof value === 'string')
-        return secret ? value.split(secret).join('[redacted]') : value;
-    if (Array.isArray(value))
-        return value.map((item) => redact(item, secret));
-    if (value !== null && typeof value === 'object') {
-        return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, redact(item, secret)]));
-    }
-    return value;
-}
-function parseRows(file) {
-    try {
-        return fs.readFileSync(file, 'utf8').split('\n').flatMap((line) => {
-            if (line.trim() === '')
-                return [];
-            try {
-                const row = JSON.parse(line);
-                return row.v === 1 && row.op === 'failed' && typeof row.actIndex === 'number' && typeof row.sink === 'string' && typeof row.message === 'string' && typeof row.at === 'number'
-                    ? [{ actIndex: row.actIndex, recipient: row.recipient, route: row.route, sink: row.sink, message: row.message, at: row.at, ...(row.diagnostic === undefined ? {} : { diagnostic: row.diagnostic }) }]
-                    : [];
-            }
-            catch {
-                return [];
-            }
-        });
-    }
-    catch (error) {
-        if (error.code === 'ENOENT')
-            return [];
-        throw error;
-    }
-}
-export function readNotificationFailures(squarePath, env = process.env) {
-    return parseRows(notificationFailuresPath(squarePath, env));
-}
-/** Append diagnosable delivery failures without ever persisting Paseo credentials. */
-export function recordNotificationFailure(squarePath, input, at = Date.now(), env = process.env) {
-    const file = notificationFailuresPath(squarePath, env);
-    const safe = redact({ ...input, at }, env.PASEO_PASSWORD);
-    const row = { v: 1, op: 'failed', ...safe };
-    fs.mkdirSync(path.dirname(file), { recursive: true });
-    const text = `${JSON.stringify(row)}\n`;
-    if (fs.existsSync(file) && fs.statSync(file).size + Buffer.byteLength(text) > MAX_BYTES) {
-        const retained = parseRows(file).slice(-500);
-        fs.writeFileSync(file, retained.map((item) => JSON.stringify({ v: 1, op: 'failed', ...item })).join('\n') + (retained.length ? '\n' : ''), { mode: 0o600 });
-    }
-    fs.appendFileSync(file, text, { mode: 0o600 });
-}