@astrosheep/square 0.3.2

package/dist/watch.js

@@ -0,0 +1,386 @@
+import { setTimeout as sleep } from 'node:timers/promises';
+import { loadSquare } from './artifact.js';
+import { SquareError, nameKey, } from './model.js';
+import { deriveDeliveryModel } from './delivery.js';
+import { SLEEP_MS, STALE_MS, WATCH_HEARTBEAT_MS, WATCH_STALE_MS, countSays, currentHold, doneNames, freshWatchLease, hasQuorum, inSquareCount, markDeliveredMentions, nowMs, readCursor, touchPresenceCursor, withSquareLock, writeSquareDoc, } from './runtime.js';
+import { renderWatchForceTakeover, renderWatchAlreadyActive, renderWatchInterrupted, renderWatchOutput, renderWatchReplaced, renderWatchStatus, participantCommandPrefix, withPathOutput, withWatchNextOutput, } from './presentation.js';
+import { ackPeerDelta, filteredPeerActivities, filteredRoomChanges, indexedDelta, matchesFeedFilter, peerPublicActs, peerRoomChanges, } from './activity-feed.js';
+import { coreParticipants, resolveKnownName } from './decisions.js';
+import { hasAutomaticDeliveryIdentity } from './registry.js';
+/** Notification receipts are stronger than the public-feed cursor, which self activity may advance. */
+function catchDelta(doc, name) {
+    const items = indexedDelta(doc.acts, readCursor(doc, name));
+    const seen = new Set(items.map((item) => item.index));
+    for (const notification of deriveDeliveryModel(doc).pendingFor(name)) {
+        if (!seen.has(notification.item.index))
+            items.push(notification.item);
+    }
+    return items.sort((a, b) => a.index - b.index);
+}
+function watchStatusExitCode(status) {
+    return status === 'capped' ? 1 : 0;
+}
+function leaseId() {
+    return `watch_${process.pid}_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+}
+function leaseFilter(opts) {
+    const filter = {
+        ...(opts.participants !== undefined ? { participants: opts.participants } : {}),
+        ...(opts.mention !== undefined ? { mention: opts.mention } : {}),
+    };
+    return Object.keys(filter).length === 0 ? undefined : filter;
+}
+function setLease(doc, name, id, at, opts) {
+    const filter = leaseFilter(opts);
+    doc.runtime.leases[name] = {
+        leaseId: id,
+        heartbeatAt: at,
+        expiresAt: at + WATCH_STALE_MS,
+        ...(filter ? { filter } : {}),
+    };
+}
+function sameLease(doc, name, id, at = nowMs()) {
+    return freshWatchLease(doc, name, at)?.leaseId === id;
+}
+function consumeDelta(doc, name, delta, delivered, at) {
+    const consumed = ackPeerDelta(doc, name, delta);
+    const receipts = markDeliveredMentions(doc, name, delivered, at);
+    return consumed || receipts;
+}
+function watchOutputResult(squarePath, doc, name, delta, opts = {}) {
+    const publicItems = peerPublicActs(delta, name).filter((item) => matchesFeedFilter(item, opts));
+    const roomChanges = filteredRoomChanges(delta, name, opts);
+    consumeDelta(doc, name, delta, publicItems, nowMs());
+    writeSquareDoc(squarePath, doc);
+    return {
+        type: 'output',
+        stdout: renderWatchOutput(doc.acts, publicItems, roomChanges, {
+            ...opts,
+            squarePath,
+            viewer: name,
+            showCatchHint: !hasAutomaticDeliveryIdentity(),
+        }),
+        ...(opts.status ? { status: opts.status } : {}),
+    };
+}
+function loadPresence(squarePath) {
+    try {
+        const doc = loadSquare(squarePath);
+        const now = nowMs();
+        return { participants: coreParticipants(doc, now).participants, now };
+    }
+    catch {
+        return undefined;
+    }
+}
+function loadHeaderCount(squarePath) {
+    try {
+        return inSquareCount(loadSquare(squarePath));
+    }
+    catch {
+        return undefined;
+    }
+}
+function writeWatchOutput(squarePath, name, stdout, status, idleMs) {
+    const presence = loadPresence(squarePath);
+    const headerOpts = { participantCount: loadHeaderCount(squarePath) };
+    const showCatchHint = !hasAutomaticDeliveryIdentity();
+    if (status) {
+        process.stdout.write(withPathOutput(squarePath, [renderWatchStatus({ status, squarePath, name, idleMs, presence, showCatchHint }), stdout.trimEnd()].filter(Boolean).join('\n\n').trimEnd(), headerOpts));
+        return;
+    }
+    const fallback = showCatchHint
+        ? `» ${participantCommandPrefix(squarePath, name)} catch --idle 30m\n  stay available for new activity`
+        : '';
+    process.stdout.write(withWatchNextOutput(squarePath, [stdout.trimEnd(), fallback].filter(Boolean).join('\n\n'), headerOpts));
+}
+async function beginWatch(squarePath, name, opts) {
+    return withSquareLock(squarePath, () => {
+        const doc = loadSquare(squarePath);
+        const at = nowMs();
+        const active = freshWatchLease(doc, name, at);
+        if (active !== undefined && !(opts.force ?? false))
+            return { type: 'active', lease: active };
+        const id = leaseId();
+        setLease(doc, name, id, at, opts);
+        touchPresenceCursor(doc, name, at, 'watch');
+        writeSquareDoc(squarePath, doc);
+        return { type: 'started', leaseId: id, replaced: active !== undefined, heartbeatAt: at };
+    });
+}
+async function endWatch(squarePath, name, id) {
+    if (id === undefined)
+        return;
+    await withSquareLock(squarePath, () => {
+        const doc = loadSquare(squarePath);
+        if (doc.runtime.leases[name]?.leaseId !== id)
+            return;
+        delete doc.runtime.leases[name];
+        writeSquareDoc(squarePath, doc);
+    });
+}
+function installWatchInterruptHandler(squarePath, name, currentLeaseId) {
+    const onInterrupt = () => {
+        void (async () => {
+            await endWatch(squarePath, name, currentLeaseId());
+            process.stdout.write(withPathOutput(squarePath, renderWatchInterrupted({ squarePath, name })));
+            process.exit(130);
+        })().catch((error) => {
+            process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+            process.exit(130);
+        });
+    };
+    process.once('SIGINT', onInterrupt);
+    return () => {
+        process.off('SIGINT', onInterrupt);
+    };
+}
+function terminalStatus(doc, name) {
+    const count = countSays(doc.acts, name);
+    if (doc.hardCap !== null && count >= doc.hardCap)
+        return 'capped';
+    const done = doneNames(doc.acts);
+    done.delete(nameKey(name));
+    if (hasQuorum(doc, name, done))
+        return 'quorum';
+    return undefined;
+}
+async function cmdWatchNow(squarePath, name, opts) {
+    const result = await withSquareLock(squarePath, () => {
+        const doc = loadSquare(squarePath);
+        const at = nowMs();
+        const touched = touchPresenceCursor(doc, name, at, 'watch');
+        const delta = catchDelta(doc, name);
+        const peerPublic = peerPublicActs(delta, name);
+        const roomChanges = peerRoomChanges(delta, name);
+        const filteredActivities = filteredPeerActivities(delta, name, opts);
+        const matchingRoomChanges = filteredRoomChanges(delta, name, opts);
+        const hasDeliverable = peerPublic.length > 0 || roomChanges.length > 0;
+        const hasFilteredDeliverable = filteredActivities.length > 0 || matchingRoomChanges.length > 0;
+        const status = terminalStatus(doc, name);
+        if (hasDeliverable && hasFilteredDeliverable) {
+            return watchOutputResult(squarePath, doc, name, delta, {
+                participants: opts.participants,
+                mention: opts.mention,
+                ...(status ? { status } : {}),
+            });
+        }
+        if (hasDeliverable) {
+            const acked = ackPeerDelta(doc, name, delta);
+            if (acked || touched)
+                writeSquareDoc(squarePath, doc);
+        }
+        else if (touched) {
+            writeSquareDoc(squarePath, doc);
+        }
+        if (status)
+            return { type: 'terminal', status };
+        return { type: 'terminal', status: 'empty-now' };
+    });
+    if (result.type === 'output') {
+        writeWatchOutput(squarePath, name, result.stdout, result.status);
+        process.exitCode = watchStatusExitCode(result.status);
+        return;
+    }
+    if (result.type === 'terminal') {
+        const presence = loadPresence(squarePath);
+        process.stdout.write(withPathOutput(squarePath, renderWatchStatus({
+            status: result.status,
+            squarePath,
+            name,
+            presence,
+            showCatchHint: !hasAutomaticDeliveryIdentity(),
+        }), {
+            participantCount: loadHeaderCount(squarePath),
+        }));
+        process.exitCode = watchStatusExitCode(result.status);
+        return;
+    }
+}
+export async function cmdWatch(squarePath, name, opts) {
+    let initialDoc;
+    try {
+        initialDoc = loadSquare(squarePath);
+        name = resolveKnownName(initialDoc, name);
+        if (opts.mention !== undefined)
+            opts = { ...opts, mention: resolveKnownName(initialDoc, opts.mention) };
+        if (opts.participants !== undefined && opts.participants.length > 0) {
+            opts = { ...opts, participants: opts.participants.map((p) => resolveKnownName(initialDoc, p)) };
+        }
+    }
+    catch (err) {
+        if (err instanceof SquareError) {
+            process.stderr.write(err.message + '\n');
+            process.exit(err.code === 'not_found' ? 1 : 2);
+        }
+        throw err;
+    }
+    if (opts.now) {
+        if (opts.activityCount !== 1)
+            process.stderr.write('--count is ignored with --now\n');
+        await cmdWatchNow(squarePath, name, opts);
+        return;
+    }
+    const start = await beginWatch(squarePath, name, opts);
+    if (start.type === 'active') {
+        const presence = loadPresence(squarePath);
+        process.stdout.write(withPathOutput(squarePath, renderWatchAlreadyActive({ squarePath, name }), { participantCount: loadHeaderCount(squarePath) }));
+        process.exit(1);
+    }
+    let staleSince = nowMs();
+    let currentLeaseId = start.leaseId;
+    let nextHeartbeatAt = start.heartbeatAt + WATCH_HEARTBEAT_MS;
+    if (start.replaced) {
+        const presence = loadPresence(squarePath);
+        process.stdout.write(withPathOutput(squarePath, renderWatchForceTakeover({ squarePath, name }), { participantCount: loadHeaderCount(squarePath) }));
+    }
+    const idleMs = opts.idleMs ?? STALE_MS;
+    const removeInterruptHandler = installWatchInterruptHandler(squarePath, name, () => currentLeaseId);
+    try {
+        while (true) {
+            const result = await withSquareLock(squarePath, () => {
+                const doc = loadSquare(squarePath);
+                const at = nowMs();
+                if (!sameLease(doc, name, currentLeaseId, at))
+                    return { type: 'replaced' };
+                let mutated = false;
+                if (at >= nextHeartbeatAt) {
+                    setLease(doc, name, currentLeaseId, at, opts);
+                    mutated = touchPresenceCursor(doc, name, at, 'watch') || mutated;
+                    nextHeartbeatAt = at + WATCH_HEARTBEAT_MS;
+                    mutated = true;
+                }
+                const delta = catchDelta(doc, name);
+                const peerPublic = peerPublicActs(delta, name);
+                const roomChanges = peerRoomChanges(delta, name);
+                const filteredActivities = filteredPeerActivities(delta, name, opts);
+                const matchingRoomChanges = filteredRoomChanges(delta, name, opts);
+                const hasDeliverable = peerPublic.length > 0 || roomChanges.length > 0;
+                const hasFilteredDeliverable = filteredActivities.length > 0 || matchingRoomChanges.length > 0;
+                const status = terminalStatus(doc, name);
+                if (currentHold(doc.acts).active) {
+                    if (mutated)
+                        writeSquareDoc(squarePath, doc);
+                    return { type: 'held' };
+                }
+                if (hasDeliverable &&
+                    hasFilteredDeliverable &&
+                    (filteredActivities.length >= opts.activityCount || matchingRoomChanges.length > 0 || status !== undefined)) {
+                    return watchOutputResult(squarePath, doc, name, delta, {
+                        participants: opts.participants,
+                        mention: opts.mention,
+                        ...(status ? { status } : {}),
+                    });
+                }
+                if (hasDeliverable && !hasFilteredDeliverable)
+                    mutated = ackPeerDelta(doc, name, delta) || mutated;
+                if (status) {
+                    if (mutated)
+                        writeSquareDoc(squarePath, doc);
+                    return { type: 'terminal', status };
+                }
+                if (mutated)
+                    writeSquareDoc(squarePath, doc);
+                return { type: 'sleep' };
+            });
+            switch (result.type) {
+                case 'output': {
+                    const status = result.status;
+                    if (opts.follow === true && status === undefined) {
+                        writeWatchOutput(squarePath, name, result.stdout);
+                        staleSince = nowMs();
+                        break;
+                    }
+                    await endWatch(squarePath, name, currentLeaseId);
+                    currentLeaseId = undefined;
+                    writeWatchOutput(squarePath, name, result.stdout, status);
+                    process.exitCode = watchStatusExitCode(status);
+                    return;
+                }
+                case 'terminal':
+                    await endWatch(squarePath, name, currentLeaseId);
+                    currentLeaseId = undefined;
+                    const presence = loadPresence(squarePath);
+                    process.stdout.write(withPathOutput(squarePath, renderWatchStatus({
+                        status: result.status,
+                        squarePath,
+                        name,
+                        presence,
+                        showCatchHint: !hasAutomaticDeliveryIdentity(),
+                    }), {
+                        participantCount: loadHeaderCount(squarePath),
+                    }));
+                    process.exitCode = watchStatusExitCode(result.status);
+                    return;
+                case 'replaced':
+                    currentLeaseId = undefined;
+                    {
+                        const presence = loadPresence(squarePath);
+                        process.stdout.write(withPathOutput(squarePath, renderWatchReplaced({ squarePath, name }), { participantCount: loadHeaderCount(squarePath) }));
+                    }
+                    process.exitCode = 0;
+                    return;
+                case 'sleep':
+                    break;
+                case 'held':
+                    staleSince = nowMs();
+                    break;
+            }
+            if (nowMs() - staleSince >= idleMs) {
+                const result = await withSquareLock(squarePath, () => {
+                    const doc = loadSquare(squarePath);
+                    if (!sameLease(doc, name, currentLeaseId))
+                        return { type: 'replaced' };
+                    const delta = catchDelta(doc, name);
+                    const filteredActivities = filteredPeerActivities(delta, name, opts);
+                    if (filteredActivities.length > 0) {
+                        return watchOutputResult(squarePath, doc, name, delta, {
+                            stalePartial: true,
+                            participants: opts.participants,
+                            mention: opts.mention,
+                            idleMs,
+                        });
+                    }
+                    return { type: 'terminal', status: 'stale' };
+                });
+                if (result.type === 'replaced') {
+                    currentLeaseId = undefined;
+                    {
+                        const presence = loadPresence(squarePath);
+                        process.stdout.write(withPathOutput(squarePath, renderWatchReplaced({ squarePath, name }), { participantCount: loadHeaderCount(squarePath) }));
+                    }
+                    process.exitCode = 0;
+                    return;
+                }
+                if (result.type === 'output') {
+                    await endWatch(squarePath, name, currentLeaseId);
+                    currentLeaseId = undefined;
+                    writeWatchOutput(squarePath, name, result.stdout, result.status);
+                    process.exitCode = 0;
+                    return;
+                }
+                if (result.type === 'terminal') {
+                    await endWatch(squarePath, name, currentLeaseId);
+                    currentLeaseId = undefined;
+                    const presence = loadPresence(squarePath);
+                    process.stdout.write(withPathOutput(squarePath, renderWatchStatus({
+                        status: result.status,
+                        squarePath,
+                        name,
+                        idleMs,
+                        presence,
+                        showCatchHint: !hasAutomaticDeliveryIdentity(),
+                    }), {
+                        participantCount: loadHeaderCount(squarePath),
+                    }));
+                    process.exitCode = watchStatusExitCode(result.status);
+                    return;
+                }
+            }
+            await sleep(SLEEP_MS);
+        }
+    }
+    finally {
+        removeInterruptHandler();
+    }
+}

package/extensions/square-opencode.js

@@ -0,0 +1,87 @@
+import {
+  deferToActiveCatch,
+  opencodeHookResponse,
+  renderClaudeInboxContext,
+} from '../dist/claude-hook.js';
+import { sessionInbox } from '../dist/inbox.js';
+import { presentOnce } from '../dist/presented.js';
+
+function pendingSignature(sessionId) {
+  const keys = sessionInbox(sessionId).flatMap((membership) =>
+    membership.notifications.map(
+      (notification) =>
+        `${membership.squarePath}\u0000${membership.name.toLocaleLowerCase()}\u0000${notification.actIndex}`
+    )
+  );
+  return keys.sort().join('\n');
+}
+
+const IDLE_WAKE = [
+  '<system-reminder source="square">',
+  'Square activity is waiting. Process the Square context injected into this turn, then run its catch command.',
+  '</system-reminder>',
+].join('\n');
+
+export default async function squareOpenCodePlugin({ client }) {
+  const handledAtIdle = new Map();
+
+  return {
+    'shell.env': async (input, output) => {
+      if (input.sessionID) output.env.OPENCODE_SESSION_ID = input.sessionID;
+    },
+
+    'experimental.chat.system.transform': async (input, output) => {
+      if (!input.sessionID) return;
+      try {
+        // Membership comes only from explicit join/act/catch claims, never env inheritance.
+        presentOnce(
+          input.sessionID,
+          (sessionId) => deferToActiveCatch(sessionInbox(sessionId)),
+          (inbox) => output.system.push(renderClaudeInboxContext(inbox))
+        );
+
+        const signature = pendingSignature(input.sessionID);
+        if (signature === '') handledAtIdle.delete(input.sessionID);
+        else handledAtIdle.set(input.sessionID, signature);
+      } catch {
+        // Adapter failures leave attention unpresented for a later boundary.
+      }
+    },
+
+    event: async ({ event }) => {
+      if (event.type !== 'session.idle') return;
+      const sessionId = event.properties.sessionID;
+      try {
+        const signature = pendingSignature(sessionId);
+        if (signature === '') {
+          handledAtIdle.delete(sessionId);
+          return;
+        }
+        if (handledAtIdle.get(sessionId) === signature) return;
+
+        const response = opencodeHookResponse({
+          session_id: sessionId,
+          hook_event_name: 'Stop',
+          stop_hook_active: false,
+        });
+        if (response?.decision !== 'block') return;
+
+        handledAtIdle.set(sessionId, signature);
+        try {
+          await client.session.promptAsync({
+            path: { id: sessionId },
+            body: { parts: [{ type: 'text', text: IDLE_WAKE }] },
+          });
+        } catch {
+          handledAtIdle.delete(sessionId);
+        }
+      } catch {
+        // Idle acceleration is best-effort and must not break the host session.
+      }
+    },
+
+    dispose: async () => {
+      handledAtIdle.clear();
+    },
+  };
+}

package/extensions/square-pi.js

@@ -0,0 +1,167 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import { sessionInbox } from '../dist/inbox.js';
+import { presentOnce } from '../dist/presented.js';
+
+function quoteShell(value) {
+  return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
+
+export function pendingInbox(inbox) {
+  return inbox.filter((membership) => Array.isArray(membership.notifications) && membership.notifications.length > 0);
+}
+
+export function inboxKeys(inbox) {
+  return pendingInbox(inbox).flatMap((membership) =>
+    membership.notifications.map((notification) =>
+      `${membership.squarePath}\u0000${membership.name.toLocaleLowerCase()}\u0000${notification.actIndex}`
+    )
+  );
+}
+
+export function notificationMessageId(squarePath, actIndex) {
+  return `square:${squarePath}#act_${actIndex}`;
+}
+
+const INJECT_BODY_MAX = 2048;
+
+function injectBodyPreview(body, squarePath, name, actIndex) {
+  const compact = String(body ?? '').replace(/\r\n/g, '\n');
+  if (compact.length <= INJECT_BODY_MAX) return compact;
+  const pointer = `square --square-path ${quoteShell(squarePath)} --as ${quoteShell(name)} echo --ids act_${actIndex} --full`;
+  return `${compact.slice(0, INJECT_BODY_MAX).trimEnd()}\n… [truncated] full echo: ${pointer}`;
+}
+
+export function renderPiInbox(inbox) {
+  const pending = pendingInbox(inbox);
+  const count = pending.reduce((total, membership) => total + membership.notifications.length, 0);
+  const noun = count === 1 ? 'notification' : 'notifications';
+  return [
+    `<system-reminder source="square">You have ${count} unread Square ${noun}.`,
+    ...pending.flatMap((membership) => {
+      const command = `square --square-path ${quoteShell(membership.squarePath)} --as ${quoteShell(membership.name)} catch --now`;
+      return membership.notifications.map((item) => {
+        const id = notificationMessageId(membership.squarePath, item.actIndex);
+        const body = injectBodyPreview(item.body, membership.squarePath, membership.name, item.actIndex);
+        return [
+          `${id} · ${membership.squarePath}: @${membership.name} from @${item.actor} (${item.via})`,
+          body,
+          `Ack with: ${command}`,
+        ].join('\n');
+      });
+    }),
+    'Ids are stable across turns. If you already acted on an id, do not repeat the action; still run catch --now to mark delivered.',
+    'Read and respond in the square before finishing the current task.</system-reminder>',
+  ].join('\n');
+}
+
+export default function squarePiExtension(pi) {
+  let sessionId;
+  let previousSessionId;
+  let sessionContext;
+  let checkRunning = false;
+  let debounceTimer;
+  const watchers = new Map();
+
+  function present(deliver) {
+    if (!sessionId) return undefined;
+    return presentOnce(
+      sessionId,
+      (currentSessionId) => {
+        const inbox = sessionInbox(currentSessionId);
+        updateWatchers(inbox);
+        return inbox;
+      },
+      deliver
+    );
+  }
+
+  function scheduleAccelerate() {
+    if (debounceTimer) clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(() => {
+      debounceTimer = undefined;
+      void accelerateWake();
+    }, 75);
+  }
+
+  function watchDirectory(directory) {
+    const resolved = path.resolve(directory);
+    if (watchers.has(resolved)) return;
+    try {
+      const watcher = fs.watch(resolved, { persistent: false }, scheduleAccelerate);
+      watchers.set(resolved, watcher);
+    } catch {
+      // Accelerate-layer discovery is best-effort only.
+    }
+  }
+
+  function updateWatchers(inbox) {
+    const registry = process.env.SQUARE_REGISTRY || path.join(os.homedir(), '.square', 'sessions.ndjsonl');
+    try {
+      fs.mkdirSync(path.dirname(registry), { recursive: true });
+    } catch {}
+    watchDirectory(path.dirname(registry));
+    for (const membership of inbox) watchDirectory(path.dirname(membership.squarePath));
+  }
+
+  /** Accelerate tier: best-effort mid-turn wake. Failures only cost latency. */
+  async function accelerateWake() {
+    if (checkRunning || !sessionContext) return;
+    checkRunning = true;
+    try {
+      present((inbox) => {
+        const pending = pendingInbox(inbox);
+        const content = renderPiInbox(pending);
+        const options = sessionContext.isIdle()
+          ? { triggerTurn: true }
+          : { triggerTurn: true, deliverAs: 'steer' };
+        pi.sendMessage(
+          { customType: 'square', content, display: true, details: { keys: inboxKeys(pending) } },
+          options
+        );
+      });
+    } catch {
+      // Accelerate-layer failures must never break the session.
+    } finally {
+      checkRunning = false;
+    }
+  }
+
+  pi.on('session_start', async (_event, ctx) => {
+    sessionContext = ctx;
+    sessionId = ctx.sessionManager.getSessionId();
+    previousSessionId = process.env.SQUARE_PI_SESSION_ID;
+    process.env.SQUARE_PI_SESSION_ID = sessionId;
+    // Optional early accelerate wake if something is already pending.
+    await accelerateWake();
+  });
+
+  pi.on('before_agent_start', async () => {
+    try {
+      return present((inbox) => ({
+        message: {
+          customType: 'square',
+          content: renderPiInbox(pendingInbox(inbox)),
+          display: true,
+        },
+      }));
+    } catch {
+      return undefined;
+    }
+  });
+
+  pi.on('session_shutdown', async () => {
+    if (debounceTimer) clearTimeout(debounceTimer);
+    debounceTimer = undefined;
+    for (const watcher of watchers.values()) watcher.close();
+    watchers.clear();
+    if (process.env.SQUARE_PI_SESSION_ID === sessionId) {
+      if (previousSessionId === undefined) delete process.env.SQUARE_PI_SESSION_ID;
+      else process.env.SQUARE_PI_SESSION_ID = previousSessionId;
+    }
+    sessionContext = undefined;
+    sessionId = undefined;
+  });
+}