@tienne/gestalt 0.111.0 → 0.112.0

package/dist/src/peer/network.js

@@ -1,20 +1,80 @@
 import { randomBytes } from 'node:crypto';
 import { isRawKey } from './keys.js';
 import { MirrorFeed } from './mirror.js';
-import { checkRosterUpdate, decodeInvite, encodeInvite, formatShareLink, isAdmin, isPersonName, isRelayUrl, joinProofText, memberOf, nextRoster, parseShareLink, signRoster, } from './roster.js';
-import { aeadOpen, aeadSeal, canonical, deriveKey, hmac, openBox, safeEqual, sealBox, } from './seal.js';
+import { checkRosterUpdate, decodeInvite, encodeInvite, formatShareLink, isAdmin, isPersonName, isRelayUrl, isShareId, joinProofText, memberOf, nextRoster, parseShareLink, signRoster, } from './roster.js';
+import { aeadOpen, aeadSeal, canonical, deriveKey, hmac, openBox, safeEqual, sealBox, signText, verifyText, } from './seal.js';
 import { RelayTransport } from './transport.js';
 import { MAX_VIEWERS_PER_SHARE, REPLAY_CHUNK_BYTES } from './viewer.js';
 import { errMessage } from './errors.js';
+import { cleanQuestion, isMessageId, isQuestionId, MAX_MESSAGE_BYTES, MAX_QUESTION_BYTES, MESSAGE_RECEIVE_LIMIT, newMessageId, newQuestionId, plainLabel, RateLimiter, sanitizeMessageBody, } from './message.js';
+import { RelaySendError } from './transport.js';
+import { DEFAULT_FIRST_WATCH_APPROVAL } from './protocol.js';
 /** 초대 유효 시간. 설계 원문의 24시간 */
 export const INVITE_TTL_MS = 24 * 60 * 60 * 1000;
 /** 원격 구독 하나가 릴레이 소켓에 밀어 둘 수 있는 양 */
 export const MAX_REMOTE_BUFFERED_BYTES = 8 * 1024 * 1024;
 const WATCH_TIMEOUT_MS = 10_000;
+/** 답이 없거나 다시 청하면 되는 거절을 받았을 때 다시 청하는 횟수와 간격 상한 */
+const MAX_REWATCH_RETRIES = 6;
+const MAX_REWATCH_DELAY_MS = 60_000;
 const WATCH_NONCE_TTL_MS = 10 * 60 * 1000;
 const MAX_SEEN_WATCH = 4096;
+const MAX_SEEN_MESSAGES = 8192;
+const MAX_REFUSED_PER_SENDER = 256;
+const MAX_REFUSED_SENDERS = 1024;
+/** 첫 접속 승인을 기다리는 시한. 넘으면 보는 쪽에 approval_timeout으로 알린다 */
+export const APPROVAL_TTL_MS = 10 * 60 * 1000;
+/** 승인 대기를 알리는 시간. 이 동안은 긴 안내 문구를 붙이고 지나면 훅이 짧은 한 줄만 붙인다 */
+export const APPROVAL_NOTICE_MS = 60 * 1000;
+/** 한 데몬이 동시에 열어 두는 질문 수 */
+export const MAX_OPEN_QUESTIONS = 32;
+/** 질문 시한의 기본값과 범위 */
+export const DEFAULT_ASK_TTL_MS = 10 * 60 * 1000;
+export const MIN_ASK_TTL_MS = 60 * 1000;
+export const MAX_ASK_TTL_MS = 60 * 60 * 1000;
+/** 답의 서명 시각이 이만큼 어긋나도 받는다. 기기끼리 시계가 조금씩 다르다 */
+const ANSWER_CLOCK_SKEW_MS = 5 * 60 * 1000;
+/** Ed25519 서명을 base64url로 쓴 길이 */
+const SIGNATURE_CHARS = 86;
+/** 닫힌 질문 id를 기억하는 수. 늦게 온 답에 answered, expired로 답하려고 둔다 */
+const MAX_CLOSED_QUESTIONS = 256;
+/** 끝난 보기를 `peer watches`에 남겨 두는 개수. 거절이나 kick으로 끝난 이유를 CLI에서 보게 한다 */
+const MAX_CLOSED_WATCHES = 16;
+/** 보는 쪽이 다시 청하지 않고 보기를 끝내는 거절 이유 */
+const FINAL_REFUSALS = new Set([
+    'not_found',
+    'bad_proof',
+    'kicked',
+    'denied',
+    'approval_timeout',
+    'share_closed',
+]);
 export class PeerNetworkError extends Error {
 }
+/** 주인 데몬이 시한 안에 watch에 답하지 않았다 */
+export class WatchTimeout extends PeerNetworkError {
+}
+/** 주인 데몬이 watch를 거절했다. reason은 주인 데몬이 보낸 글자를 정리한 것이다 */
+export class WatchRefused extends PeerNetworkError {
+    reason;
+    constructor(reason) {
+        super(refusalText(reason));
+        this.reason = reason;
+    }
+}
+/** 거절 이유를 사람이 읽는 문장으로. 이유 글자는 끝에 괄호로 남겨 스크립트가 찾게 한다 */
+export function refusalText(reason) {
+    switch (reason) {
+        case 'denied':
+            return '주인이 거절했어요 (denied)';
+        case 'kicked':
+            return '주인이 이 공유에서 끊었어요 (kicked)';
+        case 'approval_timeout':
+            return '주인이 승인하지 않아 기다리다 끝났어요 (approval_timeout)';
+        default:
+            return `주인 데몬이 거절했어요: ${reason}`;
+    }
+}
 /**
  * 팀, 명단, 릴레이 통로, 원격 공유를 묶는다. 데몬이 하나 들고 있다.
  *
@@ -36,12 +96,58 @@ export class PeerNetwork {
     announced = [];
     /** 최근 받은 watch 요청의 `기기|nonce`와 받은 시각. 릴레이가 옛 요청을 다시 보내면 거절한다 */
     seenWatch = new Map();
+    /** 받은 메시지의 `기기|id`. 릴레이가 같은 봉인을 다시 보내면 버린다 */
+    seenMessages = new Set();
+    /**
+     * 수신 한도로 거절한 메시지 id를 `공유|기기`마다 따로 기억한다. 창이 지난 뒤 릴레이가 같은
+     * 봉인을 다시 보내도 넣지 않는다. 공용 seenMessages에 넣으면 한 사람이 맞는 증명으로
+     * 쏟아부어 다른 팀원의 기억을 밀어낼 수 있어서 나눈다
+     */
+    refusedMessages = new Map();
+    sendLimiter = new RateLimiter();
+    /** 보는 쪽이 12건으로 먼저 막는다. 주인 쪽은 릴레이에 쌓였다 한꺼번에 온 것도 받게 넉넉하다 */
+    receiveLimiter = new RateLimiter(MESSAGE_RECEIVE_LIMIT);
     maxBuffered;
+    approvalTtl;
+    approvalNotice;
+    /**
+     * 주인 쪽 통제 상태. 전부 공유가 열려 있는 동안만 메모리에 둔다. 공유는 데몬이 다시 뜨면
+     * 닫히므로 DB에 남길 필요가 없고 forgetShare가 공유를 닫을 때 같이 버린다.
+     * - pending: 첫 접속 승인을 기다리는 요청. 키는 `공유|기기`
+     * - approved: 공유마다 받아 준 기기
+     * - blocked: 공유마다 끊거나 거절한 기기. 공유가 열려 있는 동안 다시 못 붙고 메시지도 못 넣는다
+     */
+    pending = new Map();
+    approved = new Map();
+    /** 첫 접속 설정. 메시지마다 읽으므로 DB가 아니라 메모리에 두고 setFirstWatch로만 바꾼다 */
+    firstWatchMode;
+    /** 거절 답과 감사 행을 쓰는 양의 상한. 끊긴 사람이 새 id로 계속 보내도 디스크와 릴레이를 못 채운다 */
+    rejectLimiter = new RateLimiter(MESSAGE_RECEIVE_LIMIT);
+    blocked = new Map();
+    closedWatches = [];
+    /** 주인 쪽. 열린 질문. 공유처럼 데몬이 다시 뜨면 사라진다 */
+    questions = new Map();
+    /** 주인 쪽. 닫힌 질문과 닫힌 이유. 늦게 온 답의 거절 이유로 쓴다 */
+    closedQuestions = new Map();
+    /**
+     * 보는 쪽. 주인 기기마다 받는 새 질문 수. 질문마다 감사 행과 뷰어 알림이 따른다. 주인 쪽이 열린
+     * 질문 32개와 최소 시한 60초를 허용하므로 메시지 수신 한도(10분에 36건)를 쓴다
+     */
+    askLimiter = new RateLimiter(MESSAGE_RECEIVE_LIMIT);
+    /**
+     * 주인 쪽. 같은 기기가 같은 공유(`공유|기기`)에서 인박스에 답을 넣으려는 수를 10분에 36번으로 센다.
+     * 인박스가 없는 동안 다시 열린 질문에 계속 답하는 경우를 위해 뒀다. network.test.ts의 "같은 기기가
+     * 인박스에 계속 못 넣는 답을 보내면 36번 뒤에 rate_limited로 막는다"가 본다
+     */
+    answerLimiter = new RateLimiter(MESSAGE_RECEIVE_LIMIT);
     constructor(options) {
         this.options = options;
         this.team = options.state.getTeam();
         this.roster = options.state.getRoster();
         this.maxBuffered = options.maxBufferedBytes ?? MAX_REMOTE_BUFFERED_BYTES;
+        this.approvalTtl = options.approvalTtlMs ?? APPROVAL_TTL_MS;
+        this.approvalNotice = options.approvalNoticeMs ?? APPROVAL_NOTICE_MS;
+        this.firstWatchMode = options.state.getSettings().firstWatch ?? DEFAULT_FIRST_WATCH_APPROVAL;
     }
     get key() {
         return this.options.key;
@@ -52,6 +158,17 @@ export class PeerNetwork {
             this.connect();
     }
     async stop() {
+        for (const p of this.pending.values()) {
+            clearTimeout(p.timer);
+            clearTimeout(p.shorten);
+        }
+        this.pending.clear();
+        for (const q of this.questions.values())
+            clearTimeout(q.timer);
+        this.questions.clear();
+        for (const w of this.watches.values())
+            if (w.retry)
+                clearTimeout(w.retry);
         for (const s of [...this.subs.values()])
             this.endSub(s, 'daemon_stop', false);
         for (const w of [...this.watches.values()])
@@ -145,8 +262,15 @@ export class PeerNetwork {
      */
     async join(code, timeoutMs = 60_000) {
         const invite = decodeInvite(code);
-        if (this.team && this.roster && memberOf(this.roster.roster, this.key.id)) {
-            throw new PeerNetworkError(`이미 팀에 들어 있어요 (${this.team.team})`);
+        // 명단에서 빠지면 릴레이가 바로 끊어서 새 명단을 못 받는다. 그래서 들고 있는 명단에는 아직 내가
+        // 있다. 릴레이가 removed로 끊었으면 같은 팀, 같은 관리자의 재초대만 받는다. removed는 릴레이가
+        // 정하는 값이라 이걸로 다른 팀에 옮겨 가는 길까지 열지 않는다
+        const removed = this.transport?.state === 'removed';
+        const rejoin = removed && this.team?.team === invite.team && this.team.anchor === invite.admin;
+        if (this.team && this.roster && memberOf(this.roster.roster, this.key.id) && !rejoin) {
+            throw new PeerNetworkError(removed
+                ? `명단에서 빠진 팀(${this.team.team})의 관리자가 새로 만든 초대로만 다시 들어올 수 있어요`
+                : `이미 팀에 들어 있어요 (${this.team.team})`);
         }
         if (Date.now() >= invite.expiresAt)
             throw new PeerNetworkError('초대 코드가 만료됐어요');
@@ -248,16 +372,39 @@ export class PeerNetwork {
     }
     lookupWatch(id) {
         const w = this.watches.get(id);
-        return w ? { stream: w.feed, token: w.token } : undefined;
+        if (!w)
+            return undefined;
+        return {
+            stream: w.feed,
+            token: w.token,
+            answer: (question, text) => this.answer(id, question, text).then((r) => ({ ok: true, question: r.question }), (err) => ({ ok: false, error: errMessage(err) })),
+            // 승인을 기다리는 동안 연 뷰어도 받아 준 뒤에 입력창이 있어야 한다. 페이지는 열 때 한 번
+            // 그려지므로 기다리는 중에는 입력창을 두고 보내기는 sendMessage가 막는다
+            ...(w.messages || w.feed.currentStatus === 'waiting'
+                ? {
+                    send: (text) => this.sendMessage(id, text, 'human').then((r) => ({ ok: true, id: r.id }), (err) => ({ ok: false, error: errMessage(err) })),
+                }
+                : {}),
+        };
     }
+    /** 보고 있는 공유와 최근에 끝난 보기. 끝난 것은 closed에 이유가 있다 */
     listWatches() {
-        return [...this.watches.values()].map((w) => ({
+        const live = [...this.watches.values()].map((w) => ({
             id: w.id,
             share: w.share,
             owner: w.feed.ownerPerson,
             status: w.feed.currentStatus,
             events: w.feed.eventCount,
         }));
+        const ended = this.closedWatches.map((c) => ({
+            id: c.id,
+            share: c.share,
+            owner: c.owner,
+            status: 'closed',
+            events: c.events,
+            closed: c.reason,
+        }));
+        return [...live, ...ended];
     }
     /** 링크로 원격 공유를 보기 시작한다. 주인 데몬이 받아 줄 때까지 기다린다 */
     async watch(link) {
@@ -288,23 +435,27 @@ export class PeerNetwork {
             shareKey: Buffer.from(parsed.shareKey, 'base64url'),
             owner,
             feed: new MirrorFeed(id, owner, ownerMember.person, parsed.shareId),
+            messages: false,
+            retries: 0,
         };
         this.watches.set(id, w);
+        let waiting;
         try {
-            await this.requestWatch(w);
+            waiting = (await this.requestWatch(w)) === 'waiting';
         }
         catch (err) {
             this.watches.delete(id);
             w.feed.close('watch_failed');
             throw err;
         }
-        this.options.state.audit('watch_open', null, JSON.stringify({ watch: id, share: w.share, owner: ownerMember.person }));
-        return { id, share: w.share, owner: ownerMember.person, feed: w.feed, token: w.token };
+        this.options.state.audit('watch_open', null, JSON.stringify({ watch: id, share: w.share, owner: ownerMember.person, waiting }));
+        return { id, share: w.share, owner: ownerMember.person, feed: w.feed, token: w.token, waiting };
     }
     unwatch(id) {
         const w = this.watches.get(id);
         if (!w)
             return false;
+        // 승인을 기다리는 중이면 sub가 없다. 그때 주인에게 알리는 건 closeWatch가 watch_cancel로 한다
         if (w.sub)
             this.sendBox(w.owner, { t: 'unwatch', share: w.share, sub: w.sub });
         this.closeWatch(w, 'unwatch');
@@ -411,6 +562,17 @@ export class PeerNetwork {
             if (!memberOf(r, sub.watcher))
                 this.endSub(sub, 'removed', false);
         }
+        for (const [key, p] of [...this.pending]) {
+            if (!memberOf(r, p.watcher))
+                this.dropApproval(key);
+        }
+        // 빠진 기기가 같은 키로 다시 초대돼 와도 묻지 않고 붙지 않게 승인은 지운다. 막은 목록은
+        // 공유가 닫힐 때까지 둔다. 지우면 kick한 기기가 다시 들어와 풀린다
+        for (const map of this.approved.values()) {
+            for (const machine of [...map.keys()])
+                if (!memberOf(r, machine))
+                    map.delete(machine);
+        }
         for (const w of [...this.watches.values()]) {
             if (!memberOf(r, w.owner))
                 this.closeWatch(w, 'owner_removed');
@@ -462,19 +624,526 @@ export class PeerNetwork {
                 return this.onWatchRequest(from, msg);
             case 'watch_ok':
             case 'watch_err':
+            case 'watch_wait':
                 return this.onWatchReply(from, msg);
             case 'watch_end':
                 return this.onWatchEnd(from, msg);
+            case 'watch_cancel':
+                return this.onWatchCancel(from, msg);
             case 'unwatch': {
                 const sub = this.subs.get(msg.sub);
                 if (sub && sub.watcher === from)
                     this.endSub(sub, 'unwatch', false);
                 return;
             }
+            case 'msg':
+                return void this.onMessageRequest(from, msg).catch((err) => {
+                    process.stderr.write(`[peer] message failed: ${errMessage(err)}\n`);
+                });
+            case 'msg_status':
+                return this.onMessageStatus(from, msg);
+            case 'ask':
+                return this.onAsk(from, msg);
+            case 'ask_close':
+                return this.onAskClose(from, msg);
+            case 'answer':
+                return void this.onAnswer(from, msg).catch((err) => {
+                    process.stderr.write(`[peer] answer failed: ${errMessage(err)}\n`);
+                });
+            case 'answer_status':
+                return this.onAnswerStatus(from, msg);
             default:
                 return;
         }
     }
+    /**
+     * 보는 쪽: 원격 공유 주인 세션에 메시지를 보낸다. 주인 데몬이 오프라인이면 릴레이가 7일까지
+     * 들고 있는다. 상태는 보기의 MirrorFeed에 쌓여 뷰어로 간다.
+     */
+    async sendMessage(watchId, raw, origin = 'human') {
+        const w = this.watches.get(watchId);
+        if (!w)
+            throw new PeerNetworkError(`보고 있는 공유가 아니에요: ${watchId}`);
+        if (w.feed.currentStatus === 'waiting')
+            throw new PeerNetworkError('주인 승인을 기다리는 중이라 아직 메시지를 못 보내요');
+        if (!w.messages)
+            throw new PeerNetworkError('이 공유는 주인이 메시지를 받지 않게 열었어요');
+        const clean = sanitizeMessageBody(raw);
+        if (!clean.ok)
+            throw new PeerNetworkError(clean.reason);
+        const member = this.roster ? memberOf(this.roster.roster, w.owner) : undefined;
+        const t = this.transport;
+        if (!member)
+            throw new PeerNetworkError('공유 주인이 명단에 없어요');
+        if (!t || t.state !== 'online')
+            throw new PeerNetworkError('릴레이에 안 붙어 있어요');
+        // 보내기 직전에 센다. 명단이나 연결 때문에 못 보낸 시도는 한도를 안 깎는다.
+        // 주인 쪽 수신 한도는 MESSAGE_RECEIVE_LIMIT로 따로 정한다
+        if (!this.sendLimiter.take(`${w.share}|${w.owner}`)) {
+            throw new PeerNetworkError('메시지를 너무 자주 보냈어요. 10분에 12건까지예요');
+        }
+        const id = newMessageId();
+        const body = {
+            t: 'msg',
+            share: w.share,
+            id,
+            body: clean.text,
+            origin,
+            proof: hmac(w.shareKey, messageProofText(w.share, this.key.id, id, clean.text)),
+        };
+        // 릴레이 답보다 주인 데몬의 상태가 먼저 올 수 있어서 레코드를 미리 둔다. 알리는 건 답을 받은 뒤다
+        w.feed.reserveMessage(id, clean.text, Date.now());
+        const box = sealBox(this.key, w.owner, member.boxKey, JSON.stringify(body));
+        let result;
+        try {
+            result = await t.send(w.owner, Buffer.from(JSON.stringify(box)), { queue: true });
+        }
+        catch (err) {
+            const reason = err instanceof RelaySendError ? err.reason : errMessage(err);
+            w.feed.setMessage(id, { status: 'rejected', reason });
+            throw new PeerNetworkError(`메시지를 못 보냈어요: ${errMessage(err)}`);
+        }
+        w.feed.setMessage(id, { status: result === 'queued' ? 'queued' : 'sent' });
+        return { id, status: w.feed.getMessage(id)?.status ?? 'sent' };
+    }
+    listMessages(watchId) {
+        const w = this.watches.get(watchId);
+        if (!w)
+            throw new PeerNetworkError(`보고 있는 공유가 아니에요: ${watchId}`);
+        return w.feed.messages;
+    }
+    /** 주인 쪽: 받은 메시지를 검사하고 주인 세션 인박스에 쓴다 */
+    async onMessageRequest(from, msg) {
+        // 꼴이 틀린 공유 id는 감사 로그와 CLI 출력으로 흘러가지 않게 답 없이 버린다
+        if (!isShareId(msg.share) || !isMessageId(msg.id))
+            return;
+        // 릴레이가 같은 봉인을 다시 보내면 한 번만 넣는다. 기억은 검사를 다 통과한 뒤에 한다.
+        // 앞에서 기억하면 증명 없는 가짜 id로 칸을 밀어내 옛 봉인을 다시 넣게 할 수 있다
+        const dedupe = `${from}|${msg.id}`;
+        const sender = `${msg.share}|${from}`;
+        if (this.seenMessages.has(dedupe) || this.refusedMessages.get(sender)?.has(msg.id))
+            return;
+        const status = (s, reason) => {
+            this.sendBox(from, {
+                t: 'msg_status',
+                share: msg.share,
+                id: msg.id,
+                status: s,
+                ...(reason ? { reason } : {}),
+            });
+        };
+        const person = (this.roster ? memberOf(this.roster.roster, from)?.person : undefined) ?? '?';
+        const reject = (reason) => {
+            // 거절은 증명 없이도 탈 수 있는 길이 있어서 보낸 기기마다 상한을 둔다. 넘으면 답도 기록도 없이 버린다
+            if (!this.rejectLimiter.take(from))
+                return;
+            status('rejected', reason);
+            this.options.state.audit('message_reject', msg.share, JSON.stringify({ id: msg.id, person, reason }));
+        };
+        const owned = this.options.lookupShare(msg.share);
+        if (!owned || owned.stream.isClosed)
+            return reject('share_closed');
+        if (typeof msg.body !== 'string' || typeof msg.proof !== 'string')
+            return reject('bad_frame');
+        const expected = hmac(Buffer.from(owned.shareKey, 'base64url'), messageProofText(msg.share, from, msg.id, msg.body));
+        if (!safeEqual(msg.proof, expected))
+            return reject('bad_proof');
+        // 메시지는 구독이 아니라 링크 증명으로 받아서 구독을 끊어도 링크는 남는다. 끊거나 거절한 사람과
+        // 아직 안 받아 준 사람은 여기서 막는다. 릴레이가 들고 있다 나중에 넘긴 봉인도 같은 규칙을 탄다
+        const refusal = this.messageRefusal(msg.share, from);
+        if (refusal) {
+            this.rememberRefused(sender, msg.id);
+            return reject(refusal);
+        }
+        const clean = sanitizeMessageBody(msg.body);
+        if (!clean.ok)
+            return reject(clean.reason);
+        if (!this.receiveLimiter.take(sender)) {
+            this.rememberRefused(sender, msg.id);
+            return reject('rate_limited');
+        }
+        if (!owned.deliver)
+            return reject('messages_off');
+        // deliver의 첫 await 전에 기억해야 동시에 온 같은 봉인이 둘 다 들어가지 않는다
+        this.seenMessages.add(dedupe);
+        if (this.seenMessages.size > MAX_SEEN_MESSAGES) {
+            const oldest = this.seenMessages.values().next().value;
+            if (oldest !== undefined)
+                this.seenMessages.delete(oldest);
+        }
+        const origin = msg.origin === 'agent' ? 'agent' : 'human';
+        this.options.state.audit('message_receive', msg.share, JSON.stringify({ id: msg.id, person, origin, bytes: Buffer.byteLength(clean.text) }));
+        status('arrived');
+        const inbound = {
+            kind: 'message',
+            id: msg.id,
+            share: msg.share,
+            from,
+            person,
+            origin,
+            body: clean.text,
+        };
+        const delivered = () => {
+            status('delivered');
+            this.options.state.audit('message_deliver', msg.share, JSON.stringify({ id: msg.id, person }));
+        };
+        // 들어갔는지 지켜보는 일은 쓰기 전에 걸어 둔다. 그래서 쓰기가 끝나기 전에 보일 수 있고 그때는
+        // 넣음을 먼저 알린 뒤 들어감을 알린다
+        let inserted = false;
+        let seenEarly = false;
+        const result = await owned.deliver(inbound, () => {
+            if (inserted)
+                delivered();
+            else
+                seenEarly = true;
+        });
+        // 소켓에 붙은 뒤 실패했으면 줄이 들어갔을 수 있다. 거절로 알리면 보낸 사람이 다시 보내 겹칠 수 있어서
+        // 넣음으로 알리고 대화 기록에 보이면 들어감으로 올린다
+        if (!result.ok && !result.maybeWritten)
+            return reject(result.reason);
+        status('inserted');
+        this.options.state.audit('message_insert', msg.share, JSON.stringify({ id: msg.id, person, ...(result.ok ? {} : { maybeWritten: true }) }));
+        inserted = true;
+        if (seenEarly)
+            delivered();
+    }
+    rememberRefused(sender, id) {
+        let ids = this.refusedMessages.get(sender);
+        if (!ids) {
+            ids = new Set();
+            this.refusedMessages.set(sender, ids);
+            if (this.refusedMessages.size > MAX_REFUSED_SENDERS) {
+                const oldest = this.refusedMessages.keys().next().value;
+                if (oldest !== undefined)
+                    this.refusedMessages.delete(oldest);
+            }
+        }
+        ids.add(id);
+        if (ids.size > MAX_REFUSED_PER_SENDER) {
+            const oldest = ids.values().next().value;
+            if (oldest !== undefined)
+                ids.delete(oldest);
+        }
+    }
+    /** 보는 쪽: 주인 데몬이 알려 온 상태를 반영한다 */
+    onMessageStatus(from, msg) {
+        if (!isMessageId(msg.id) || !isMessageStatus(msg.status))
+            return;
+        for (const w of this.watches.values()) {
+            if (w.owner !== from || w.share !== msg.share || !w.feed.getMessage(msg.id))
+                continue;
+            // 주인 데몬이 보낸 글자라 CLI 터미널에 찍히기 전에 제어 문자를 지운다
+            const reason = plainLabel(msg.reason);
+            w.feed.setMessage(msg.id, { status: msg.status, ...(reason ? { reason } : {}) });
+        }
+    }
+    // ── ask_user ──────────────────────────────────────────────
+    /**
+     * 주인 쪽: 주인 세션 모델의 질문을 그 세션 공유를 지금 보고 있는 팀원에게 보낸다. to를 주면 그
+     * 사람 기기만이다. 구독이 열린 기기만 받으므로 승인 전, 거절, kick된 기기에는 안 간다. 질문
+     * 글자는 부르는 쪽이 가린 뒤 넘긴다. 답은 나중에 onAnswer가 받아 주인 세션에 넣는다.
+     */
+    ask(shares, raw, to, ttlMs) {
+        // 말없이 자르면 모델은 질문이 다 갔다고 여긴다. 넘으면 거절해서 줄여 다시 내게 한다
+        if (Buffer.byteLength(raw) > MAX_QUESTION_BYTES) {
+            throw new PeerNetworkError(`질문이 ${MAX_QUESTION_BYTES / 1024}KB를 넘어요. 줄여서 다시 보내 주세요`);
+        }
+        const text = cleanQuestion(raw);
+        if (!text)
+            throw new PeerNetworkError('질문이 비었어요');
+        if (this.questions.size >= MAX_OPEN_QUESTIONS) {
+            throw new PeerNetworkError(`열린 질문이 ${MAX_OPEN_QUESTIONS}개라 더 못 내요`);
+        }
+        const only = to === undefined ? undefined : new Set(this.machinesOf(to));
+        const targets = new Map();
+        for (const sub of this.subs.values()) {
+            if (sub.ended || !shares.includes(sub.share))
+                continue;
+            if (only && !only.has(sub.watcher))
+                continue;
+            targets.set(`${sub.share}|${sub.watcher}`, sub);
+        }
+        if (targets.size === 0) {
+            throw new PeerNetworkError(to === undefined
+                ? '지금 이 세션을 보는 팀원이 없어요'
+                : `${plainLabel(to, 32) ?? '?'} 님은 지금 이 세션을 보고 있지 않아요`);
+        }
+        const id = newQuestionId();
+        const askedAt = Date.now();
+        const expiresAt = askedAt + ttlMs;
+        const asked = new Set();
+        for (const [key, sub] of targets) {
+            const sent = this.sendBox(sub.watcher, {
+                t: 'ask',
+                share: sub.share,
+                q: id,
+                text,
+                expiresAt,
+            });
+            if (sent)
+                asked.add(key);
+        }
+        if (asked.size === 0)
+            throw new PeerNetworkError('릴레이에 안 붙어 있어요');
+        const timer = setTimeout(() => this.expireQuestion(id), ttlMs);
+        timer.unref();
+        this.questions.set(id, { id, asked, askedAt, expiresAt, timer, answering: false });
+        const sent = [...asked].map((key) => targets.get(key));
+        const persons = unique(sent.map((s) => this.personOf(s.watcher)));
+        const sentShares = unique(sent.map((s) => s.share));
+        for (const share of sentShares) {
+            this.options.state.audit('ask_open', share, JSON.stringify({
+                question: id,
+                persons: unique(sent.filter((s) => s.share === share).map((s) => this.personOf(s.watcher))),
+                expiresAt,
+            }));
+        }
+        return { question: id, to: persons, shares: sentShares, expiresAt };
+    }
+    expireQuestion(id) {
+        const q = this.questions.get(id);
+        if (!q)
+            return;
+        this.closeQuestion(q, 'expired');
+        try {
+            this.options.state.audit('ask_expire', null, JSON.stringify({ question: id }));
+        }
+        catch {
+            // 데몬이 멈추는 중이면 DB가 이미 닫혔을 수 있다
+        }
+    }
+    /** 질문을 끝내고 받은 사람 뷰어에 알린다. except 자리(먼저 답한 기기)에는 안 알린다 */
+    closeQuestion(q, reason, except) {
+        if (this.questions.get(q.id) !== q)
+            return;
+        clearTimeout(q.timer);
+        this.questions.delete(q.id);
+        this.closedQuestions.set(q.id, reason);
+        if (this.closedQuestions.size > MAX_CLOSED_QUESTIONS) {
+            const oldest = this.closedQuestions.keys().next().value;
+            if (oldest !== undefined)
+                this.closedQuestions.delete(oldest);
+        }
+        for (const key of q.asked) {
+            if (key === except)
+                continue;
+            const [share, watcher] = key.split('|');
+            this.sendBox(watcher, { t: 'ask_close', share, q: q.id, reason });
+        }
+    }
+    /**
+     * 주인 쪽: 답을 검사하고 주인 세션 인박스에 `<peer-answer … verified>`로 넣는다. 검사 순서는
+     * 제안서 "ask_user 서명 답" 절의 표와 같다. 하나라도 걸리면 넣지 않는다. network.test.ts의 "ask_user 서명
+     * 답" 블록이 kicked, not_approved, not_asked, answered, bad_signature, bad_frame, bad_time, expired, 길이
+     * 검사, rate_limited, 인박스 실패 뒤 처리를 넣어 본다.
+     */
+    async onAnswer(from, msg) {
+        // 꼴이 틀린 id는 감사 로그와 답으로 흘러가지 않게 답 없이 버린다
+        if (!isShareId(msg.share) || !isQuestionId(msg.q))
+            return;
+        const person = this.personOf(from);
+        const status = (s, reason) => {
+            this.sendBox(from, {
+                t: 'answer_status',
+                share: msg.share,
+                q: msg.q,
+                status: s,
+                ...(reason ? { reason } : {}),
+            });
+        };
+        const reject = (reason) => {
+            if (!this.rejectLimiter.take(from))
+                return;
+            status('rejected', reason);
+            this.options.state.audit('answer_reject', msg.share, JSON.stringify({ question: msg.q, person, reason }));
+        };
+        const owned = this.options.lookupShare(msg.share);
+        if (!owned || owned.stream.isClosed)
+            return reject('share_closed');
+        if (!owned.deliver)
+            return reject('messages_off');
+        // 승인과 kick은 구독이 아니라 공유 단위 기록으로 본다. 질문을 받은 뒤 끊긴 기기도 여기서 막힌다
+        const refusal = this.messageRefusal(msg.share, from);
+        if (refusal)
+            return reject(refusal);
+        const q = this.questions.get(msg.q);
+        if (!q)
+            return reject(this.closedQuestions.get(msg.q) ?? 'unknown_question');
+        const seat = `${msg.share}|${from}`;
+        if (!q.asked.has(seat))
+            return reject('not_asked');
+        if (q.answering)
+            return reject('answered');
+        if (typeof msg.body !== 'string' ||
+            typeof msg.sig !== 'string' ||
+            !Number.isSafeInteger(msg.at))
+            return reject('bad_frame');
+        if (msg.sig.length !== SIGNATURE_CHARS)
+            return reject('bad_signature');
+        // 서명 검증 비용이 본문 크기에 비례해서 상한을 먼저 본다. UTF-16 길이는 바이트 수보다 크지 않다
+        if (msg.body.length > MAX_MESSAGE_BYTES) {
+            return reject(`본문이 ${MAX_MESSAGE_BYTES / 1024}KB를 넘어요`);
+        }
+        if (!verifyText(from, answerSignedText(msg.share, msg.q, msg.body, from, msg.at), msg.sig)) {
+            return reject('bad_signature');
+        }
+        const now = Date.now();
+        if (msg.at < q.askedAt - ANSWER_CLOCK_SKEW_MS || msg.at > now + ANSWER_CLOCK_SKEW_MS) {
+            return reject('bad_time');
+        }
+        if (now >= q.expiresAt)
+            return reject('expired');
+        const clean = sanitizeMessageBody(msg.body);
+        if (!clean.ok)
+            return reject(clean.reason);
+        if (!this.answerLimiter.take(seat))
+            return reject('rate_limited');
+        // 인박스 쓰기를 기다리는 사이에 온 다른 답은 answered로 막는다. 소켓에 붙기 전에 실패했거나 deliver가
+        // 던졌으면 질문을 열어 두고 답한 기기에 reopened로 알려 다시 답하게 한다. 이 알림은 거절 상한을 타지
+        // 않는다. 붙은 뒤 실패했으면 줄이 들어갔을 수 있어서 메시지처럼 넣음으로 알리고 질문을 끝낸다.
+        // 대화 기록에 보이면 들어감으로 올린다
+        let inserted = false;
+        let seenEarly = false;
+        const delivered = () => {
+            status('delivered');
+            this.options.state.audit('answer_deliver', msg.share, JSON.stringify({ question: q.id, person }));
+        };
+        let result;
+        q.answering = true;
+        try {
+            this.options.state.audit('answer_receive', msg.share, JSON.stringify({ question: q.id, person, bytes: Buffer.byteLength(clean.text) }));
+            result = await owned.deliver({ kind: 'answer', question: q.id, share: msg.share, from, person, body: clean.text }, () => {
+                if (inserted)
+                    delivered();
+                else
+                    seenEarly = true;
+            });
+        }
+        catch (err) {
+            result = { ok: false, reason: 'deliver_failed' };
+            process.stderr.write(`[peer] answer deliver failed: ${errMessage(err)}\n`);
+        }
+        finally {
+            q.answering = false;
+        }
+        if (!result.ok && !result.maybeWritten) {
+            const reopened = this.questions.get(q.id) === q;
+            this.sendBox(from, {
+                t: 'answer_status',
+                share: msg.share,
+                q: msg.q,
+                status: 'rejected',
+                reason: result.reason,
+                ...(reopened ? { reopened: true } : {}),
+            });
+            this.options.state.audit('answer_reject', msg.share, JSON.stringify({ question: msg.q, person, reason: result.reason }));
+            return;
+        }
+        this.closeQuestion(q, 'answered', seat);
+        status('inserted');
+        this.options.state.audit('answer_insert', msg.share, JSON.stringify({ question: q.id, person, ...(result.ok ? {} : { maybeWritten: true }) }));
+        inserted = true;
+        if (seenEarly)
+            delivered();
+    }
+    /** 보는 쪽: 내가 보는 공유의 주인 데몬이 보낸 질문을 뷰어에 띄운다 */
+    onAsk(from, msg) {
+        if (!isQuestionId(msg.q) || !Number.isSafeInteger(msg.expiresAt))
+            return;
+        // 주인 데몬이 보낸 글자라 보여주기 전에 제어 문자를 지운다
+        const text = cleanQuestion(msg.text);
+        const now = Date.now();
+        if (!text || msg.expiresAt <= now)
+            return;
+        const targets = [...this.watches.values()].filter((w) => w.owner === from && w.share === msg.share && w.sub && !w.feed.getQuestion(msg.q));
+        if (targets.length === 0)
+            return;
+        // 새 질문 수를 주인 기기마다 10분에 36개로 센다. 질문마다 감사 행과 뷰어 알림이 따른다
+        if (!this.askLimiter.take(from)) {
+            process.stderr.write('[peer] ask dropped: rate limited\n');
+            return;
+        }
+        for (const w of targets) {
+            w.feed.addQuestion(msg.q, text, Math.min(msg.expiresAt, now + MAX_ASK_TTL_MS));
+            this.options.state.audit('ask_receive', null, JSON.stringify({ watch: w.id, share: w.share, question: msg.q }));
+        }
+    }
+    onAskClose(from, msg) {
+        if (!isQuestionId(msg.q))
+            return;
+        const reason = plainLabel(msg.reason, 32);
+        for (const w of this.watches.values()) {
+            if (w.owner === from && w.share === msg.share)
+                w.feed.setQuestion(msg.q, 'closed', reason);
+        }
+    }
+    onAnswerStatus(from, msg) {
+        if (!isQuestionId(msg.q))
+            return;
+        if (msg.status !== 'inserted' && msg.status !== 'delivered' && msg.status !== 'rejected')
+            return;
+        const reason = plainLabel(msg.reason);
+        for (const w of this.watches.values()) {
+            if (w.owner !== from || w.share !== msg.share)
+                continue;
+            if (msg.status === 'rejected' && msg.reopened === true)
+                w.feed.reopenQuestion(msg.q, reason);
+            else
+                w.feed.setQuestion(msg.q, msg.status, reason);
+        }
+    }
+    /**
+     * 보는 쪽: 뷰어에서 사람이 쓴 답을 기기 키로 서명해 주인 데몬에 보낸다. 부르는 곳은 lookupWatch가
+     * 뷰어에 넘기는 answer 하나다. IPC에 답 요청이 없는 건 network.test.ts의 "IPC와 MCP 도구에는 답을
+     * 서명하는 길이 없다"가 본다. 주인 데몬이 오프라인이면 릴레이가 메시지처럼 들고 있는다.
+     */
+    async answer(watchId, question, raw) {
+        const w = this.watches.get(watchId);
+        if (!w)
+            throw new PeerNetworkError(`보고 있는 공유가 아니에요: ${watchId}`);
+        const q = isQuestionId(question) ? w.feed.getQuestion(question) : undefined;
+        if (!q || q.state !== 'open')
+            throw new PeerNetworkError('답할 수 있는 질문이 아니에요');
+        if (Date.now() >= q.expiresAt) {
+            w.feed.setQuestion(q.id, 'closed', 'expired');
+            throw new PeerNetworkError('시한이 지난 질문이에요');
+        }
+        const clean = sanitizeMessageBody(raw);
+        if (!clean.ok)
+            throw new PeerNetworkError(clean.reason);
+        const member = this.roster ? memberOf(this.roster.roster, w.owner) : undefined;
+        const t = this.transport;
+        if (!member)
+            throw new PeerNetworkError('공유 주인이 명단에 없어요');
+        if (!t || t.state !== 'online')
+            throw new PeerNetworkError('릴레이에 안 붙어 있어요');
+        const at = Date.now();
+        const box = {
+            t: 'answer',
+            share: w.share,
+            q: q.id,
+            body: clean.text,
+            at,
+            sig: signText(this.key, answerSignedText(w.share, q.id, clean.text, this.key.id, at)),
+        };
+        // 상태를 옮기는 건 봉인 뒤, 첫 await 앞이다. 여기까지가 동기로 돌아서 같은 질문의 두 번째 호출은
+        // 위 open 검사에서 걸린다
+        const sealed = sealBox(this.key, w.owner, member.boxKey, JSON.stringify(box));
+        w.feed.setQuestion(q.id, 'queued');
+        let result;
+        try {
+            result = await t.send(w.owner, Buffer.from(JSON.stringify(sealed)), { queue: true });
+        }
+        catch (err) {
+            const reason = err instanceof RelaySendError ? err.reason : errMessage(err);
+            w.feed.setQuestion(q.id, 'rejected', plainLabel(reason));
+            throw new PeerNetworkError(`답을 못 보냈어요: ${errMessage(err)}`);
+        }
+        if (result === 'delivered')
+            w.feed.setQuestion(q.id, 'sent');
+        this.options.state.audit('answer_send', null, JSON.stringify({ watch: w.id, share: w.share, question: q.id }));
+        return { question: q.id };
+    }
     onJoinRequest(from, data) {
         try {
             this.handleJoin(from, data);
@@ -550,20 +1219,40 @@ export class PeerNetwork {
         }
         if (!this.rememberWatchNonce(from, msg.nonce))
             return reply('replay');
+        const block = this.blocked.get(msg.share)?.get(from);
+        if (block)
+            return reply(block);
+        const after = Number.isSafeInteger(msg.after) && msg.after > 0 ? msg.after : 0;
+        // 승인은 salt와 세션 키를 정하기 전에 본다. 키를 보낸 뒤에 막으면 보는 쪽이 이미 대화를 열어 읽을 수 있다
+        if (!this.approved.get(msg.share)?.has(from)) {
+            if (this.firstWatchMode === 'ask') {
+                return this.holdForApproval(from, msg.share, msg.nonce, after);
+            }
+            // 기다리는 사이 설정을 team으로 바꿨으면 남은 대기를 치운다. 안 치우면 목록과 훅에 계속 보인다
+            this.dropApproval(`${msg.share}|${from}`);
+            this.grant(msg.share, from, 'team');
+        }
+        this.startSub(from, msg.share, msg.nonce, after, owned);
+    }
+    /** 받아 준 사람의 구독을 연다. 공유 세션 키는 여기서 처음 정한다 */
+    startSub(from, share, nonce, after, owned) {
         // 같은 사람이 다시 청하면 앞의 구독을 바꾼다. 보는 쪽이 모르는 교체일 수 있어서 알린다
         for (const s of [...this.subs.values()]) {
-            if (s.watcher === from && s.share === msg.share)
+            if (s.watcher === from && s.share === share)
                 this.endSub(s, 'replaced', true);
         }
-        if (owned.stream.viewerCount >= MAX_VIEWERS_PER_SHARE)
-            return reply('too_many');
+        if (owned.stream.viewerCount >= MAX_VIEWERS_PER_SHARE) {
+            this.sendBox(from, { t: 'watch_err', share, nonce, reason: 'too_many' });
+            return;
+        }
         const sub = randomBytes(9).toString('base64url');
         const salt = randomBytes(32);
+        const shareKey = Buffer.from(owned.shareKey, 'base64url');
         const remote = {
             sub,
-            share: msg.share,
+            share,
             watcher: from,
-            key: streamKey(shareKey, salt, msg.share, from, sub),
+            key: streamKey(shareKey, salt, share, from, sub),
             stream: owned.stream,
             unsubscribe: () => { },
             ended: false,
@@ -571,14 +1260,280 @@ export class PeerNetwork {
         this.subs.set(sub, remote);
         this.sendBox(from, {
             t: 'watch_ok',
-            share: msg.share,
-            nonce: msg.nonce,
+            share,
+            nonce,
             sub,
             salt: salt.toString('base64url'),
+            messages: owned.deliver !== undefined,
         });
-        const person = this.roster ? memberOf(this.roster.roster, from)?.person : undefined;
-        this.options.state.audit('remote_watch', msg.share, JSON.stringify({ person: person ?? null, sub }));
-        this.pump(remote, Number.isSafeInteger(msg.after) && msg.after > 0 ? msg.after : 0);
+        this.options.state.audit('remote_watch', share, JSON.stringify({ person: this.personOf(from), sub }));
+        this.changed();
+        this.pump(remote, after);
+    }
+    /**
+     * 첫 접속을 주인이 받아 줄 때까지 붙잡아 둔다. 보는 쪽에는 watch_wait로 알린다. 같은 사람이
+     * 다시 청하면(주인이나 보는 쪽이 릴레이에 다시 붙은 경우) 시한은 그대로 두고 nonce만 바꾼다.
+     */
+    holdForApproval(from, share, nonce, after) {
+        const key = `${share}|${from}`;
+        let p = this.pending.get(key);
+        if (p) {
+            p.nonce = nonce;
+            p.after = after;
+        }
+        else {
+            let waiting = 0;
+            for (const q of this.pending.values())
+                if (q.share === share)
+                    waiting++;
+            if (waiting >= MAX_VIEWERS_PER_SHARE) {
+                this.sendBox(from, { t: 'watch_err', share, nonce, reason: 'too_many' });
+                return;
+            }
+            const at = Date.now();
+            const timer = setTimeout(() => this.expireApproval(key), this.approvalTtl);
+            timer.unref();
+            // 긴 안내 문구는 처음 한동안만 붙이고 그 뒤로는 짧게 줄인다. 시각 비교는 타이머가 몇 ms 일찍
+            // 울리면 어긋나서 울린 사실을 표시로 남기고 훅 파일을 다시 쓴다
+            const shorten = setTimeout(() => {
+                const q = this.pending.get(key);
+                if (!q)
+                    return;
+                q.brief = true;
+                this.changed();
+            }, this.approvalNotice);
+            shorten.unref();
+            p = {
+                share,
+                watcher: from,
+                nonce,
+                after,
+                at,
+                expiresAt: at + this.approvalTtl,
+                timer,
+                shorten,
+                brief: false,
+            };
+            this.pending.set(key, p);
+            this.options.state.audit('approval_request', share, JSON.stringify({ person: this.personOf(from) }));
+            this.changed();
+        }
+        this.sendBox(from, { t: 'watch_wait', share, nonce, expiresAt: p.expiresAt });
+    }
+    /**
+     * 승인 대기 하나를 치운다. 타이머 둘을 풀고 훅 파일을 다시 쓰게 한다. reason을 주면 보는 쪽에
+     * 그 이유로 거절을 알린다. 치운 대기를 돌려준다.
+     */
+    dropApproval(key, reason) {
+        const p = this.pending.get(key);
+        if (!p)
+            return undefined;
+        clearTimeout(p.timer);
+        clearTimeout(p.shorten);
+        this.pending.delete(key);
+        if (reason) {
+            this.sendBox(p.watcher, { t: 'watch_err', share: p.share, nonce: p.nonce, reason });
+        }
+        this.changed();
+        return p;
+    }
+    expireApproval(key) {
+        const p = this.dropApproval(key, 'approval_timeout');
+        if (!p)
+            return;
+        try {
+            this.options.state.audit('approval_expire', p.share, JSON.stringify({ person: this.personOf(p.watcher) }));
+        }
+        catch {
+            // 데몬이 멈추는 중이면 DB가 이미 닫혔을 수 있다
+        }
+    }
+    /** 보는 쪽이 승인을 기다리다 그만뒀다. 그 요청의 nonce가 맞을 때만 치운다 */
+    onWatchCancel(from, msg) {
+        if (typeof msg.share !== 'string' || typeof msg.nonce !== 'string')
+            return;
+        const key = `${msg.share}|${from}`;
+        // 릴레이가 옛 취소를 다시 보내도 그 뒤에 새로 청한 대기는 안 지워진다
+        if (this.pending.get(key)?.nonce !== msg.nonce)
+            return;
+        const p = this.dropApproval(key);
+        this.options.state.audit('approval_cancel', p.share, JSON.stringify({ person: this.personOf(from) }));
+    }
+    grant(share, machine, by) {
+        let map = this.approved.get(share);
+        if (!map) {
+            map = new Map();
+            this.approved.set(share, map);
+        }
+        map.set(machine, by);
+        this.options.state.audit('approval_grant', share, JSON.stringify({ person: this.personOf(machine), by }));
+    }
+    block(share, machine, reason) {
+        let map = this.blocked.get(share);
+        if (!map) {
+            map = new Map();
+            this.blocked.set(share, map);
+        }
+        map.set(machine, reason);
+        this.approved.get(share)?.delete(machine);
+    }
+    /** 이 공유로 이 기기가 보낸 메시지를 막을 이유. 받을 수 있으면 undefined */
+    messageRefusal(share, from) {
+        const block = this.blocked.get(share)?.get(from);
+        if (block)
+            return block;
+        if (this.firstWatchMode === 'ask' && !this.approved.get(share)?.has(from)) {
+            return 'not_approved';
+        }
+        return undefined;
+    }
+    /**
+     * 첫 접속 설정을 바꾼다. ask로 조이면 팀 설정으로 들어온 사람의 승인을 거두고 구독을 끝낸다.
+     * 보는 쪽은 approval_revoked를 받고 다시 청해 승인 대기에 오른다. 거둔 구독 수를 돌려준다.
+     */
+    setFirstWatch(mode) {
+        this.firstWatchMode = mode;
+        if (mode !== 'ask')
+            return 0;
+        let revoked = 0;
+        for (const [share, map] of this.approved) {
+            const machines = [...map].filter(([, by]) => by === 'team').map(([m]) => m);
+            if (machines.length === 0)
+                continue;
+            for (const m of machines)
+                map.delete(m);
+            for (const sub of [...this.subs.values()]) {
+                if (sub.share !== share || !machines.includes(sub.watcher))
+                    continue;
+                this.endSub(sub, 'approval_revoked', true);
+                revoked++;
+            }
+            this.options.state.audit('approval_revoke', share, JSON.stringify({ persons: unique(machines.map((m) => this.personOf(m))) }));
+        }
+        this.changed();
+        return revoked;
+    }
+    /** 명단의 이름을 한 줄 라벨로. 감사 로그와 CLI, 훅 출력으로 나간다 */
+    personOf(machine) {
+        const person = this.roster ? memberOf(this.roster.roster, machine)?.person : undefined;
+        return plainLabel(person, 32) ?? '?';
+    }
+    machinesOf(person) {
+        if (!this.roster)
+            throw new PeerNetworkError('아직 팀에 안 들었어요');
+        const keys = this.roster.roster.members
+            .filter((m) => m.person === person)
+            .map((m) => m.machineKey);
+        if (keys.length === 0)
+            throw new PeerNetworkError(`명단에 없는 이름이에요: ${person}`);
+        return keys;
+    }
+    changed() {
+        try {
+            this.options.onControlChange?.();
+        }
+        catch (err) {
+            process.stderr.write(`[peer] control change failed: ${errMessage(err)}\n`);
+        }
+    }
+    /** 주인 쪽: 공유 하나를 누가 보고 누가 기다리고 누가 막혔는지 */
+    shareControl(share) {
+        const watchers = new Set();
+        for (const s of this.subs.values()) {
+            if (s.share === share)
+                watchers.add(this.personOf(s.watcher));
+        }
+        const pending = [];
+        for (const p of this.pending.values()) {
+            if (p.share === share) {
+                pending.push({
+                    person: this.personOf(p.watcher),
+                    at: p.at,
+                    expiresAt: p.expiresAt,
+                    brief: p.brief,
+                });
+            }
+        }
+        const blocked = [...(this.blocked.get(share) ?? new Map())].map(([machine, reason]) => ({ person: this.personOf(machine), reason }));
+        return { watchers: [...watchers], pending, blocked };
+    }
+    /** 주인 쪽: 승인을 기다리는 그 사람의 요청을 받아 준다. 받아 준 기기는 공유가 열린 동안 기억한다 */
+    approve(person, shares) {
+        const hits = this.pendingOf(person, shares);
+        for (const p of hits) {
+            this.dropApproval(`${p.share}|${p.watcher}`);
+            this.grant(p.share, p.watcher, 'owner');
+            const owned = this.options.lookupShare(p.share);
+            if (owned && !owned.stream.isClosed) {
+                this.startSub(p.watcher, p.share, p.nonce, p.after, owned);
+            }
+            else {
+                this.sendBox(p.watcher, {
+                    t: 'watch_err',
+                    share: p.share,
+                    nonce: p.nonce,
+                    reason: 'not_found',
+                });
+            }
+        }
+        return { person, shares: unique(hits.map((p) => p.share)), count: hits.length };
+    }
+    /** 주인 쪽: 승인을 기다리는 그 사람의 요청을 거절한다. 그 공유가 열린 동안 다시 못 붙는다 */
+    deny(person, shares) {
+        const hits = this.pendingOf(person, shares);
+        for (const p of hits) {
+            this.block(p.share, p.watcher, 'denied');
+            this.dropApproval(`${p.share}|${p.watcher}`, 'denied');
+            this.options.state.audit('approval_deny', p.share, JSON.stringify({ person }));
+        }
+        return { person, shares: unique(hits.map((p) => p.share)), count: hits.length };
+    }
+    pendingOf(person, shares) {
+        const machines = new Set(this.machinesOf(person));
+        const hits = [...this.pending.values()].filter((p) => machines.has(p.watcher) && shares.includes(p.share));
+        if (hits.length === 0)
+            throw new PeerNetworkError(`승인을 기다리는 사람이 아니에요: ${person}`);
+        return hits;
+    }
+    /**
+     * 주인 쪽: 그 사람의 기기 전부를 공유에서 끊는다. 구독을 끝내고 그 구독 몫의 세션 키를 메모리에서
+     * 지운다. 지금 안 보고 있어도 막아 둔다. 공유가 열린 동안 다시 붙지 못하고 메시지도 못 넣는다.
+     */
+    kick(person, shares) {
+        const machines = this.machinesOf(person);
+        if (machines.includes(this.key.id))
+            throw new PeerNetworkError('자기 자신은 끊을 수 없어요');
+        let count = 0;
+        for (const share of shares) {
+            let ended = 0;
+            for (const machine of machines) {
+                this.block(share, machine, 'kicked');
+                this.dropApproval(`${share}|${machine}`, 'kicked');
+            }
+            for (const sub of [...this.subs.values()]) {
+                if (sub.share !== share || !machines.includes(sub.watcher))
+                    continue;
+                this.endSub(sub, 'kicked', true);
+                ended++;
+            }
+            this.options.state.audit('kick', share, JSON.stringify({ person, ended }));
+            count += ended;
+        }
+        this.changed();
+        return { person, shares, count };
+    }
+    /**
+     * 주인 쪽: 공유가 닫혔다. 승인을 기다리던 사람에게 알리고 그 공유의 승인과 막은 목록을 버린다.
+     * 붙어 있던 구독은 공유 스트림의 closed 프레임으로 끝난다.
+     */
+    forgetShare(share) {
+        for (const [key, p] of [...this.pending]) {
+            if (p.share === share)
+                this.dropApproval(key, 'share_closed');
+        }
+        this.approved.delete(share);
+        this.blocked.delete(share);
+        this.changed();
     }
     /**
      * 처음 보는 nonce면 기억하고 true. 공유는 데몬이 다시 뜨면 닫히므로 메모리에만 둔다.
@@ -653,6 +1608,10 @@ export class PeerNetwork {
             this.endSub(remote, 'share_closed', false);
     }
     post(remote, frames) {
+        // 끊긴 구독은 키를 지웠다. 지금 부르는 쪽(pump의 step, onLocalFrame)이 ended를 먼저 보지만
+        // 호출부가 늘어도 지운 키로 봉인한 프레임이 나가지 않게 여기서도 막는다
+        if (remote.ended)
+            return;
         const env = {
             k: 's',
             share: remote.share,
@@ -667,6 +1626,9 @@ export class PeerNetwork {
         remote.ended = true;
         remote.unsubscribe();
         this.subs.delete(remote.sub);
+        // 이 구독 몫의 세션 키를 메모리에서 지운다. 새 프레임은 ended를 보는 앞 경로가 거르고 post가 한 번 더 막는다
+        remote.key.fill(0);
+        this.changed();
         if (notify)
             this.sendBox(remote.watcher, {
                 t: 'watch_end',
@@ -682,19 +1644,24 @@ export class PeerNetwork {
         }
     }
     // ── 보는 쪽 ──────────────────────────────────────────────
+    /**
+     * 주인 데몬에 보기를 청한다. watch_ok면 'ok', 주인 승인을 기다리면 'waiting'으로 끝난다.
+     * 기다리는 동안 pending.nonce는 남겨 두고 나중에 오는 watch_ok나 watch_err를 그 nonce로 맞춘다.
+     */
     requestWatch(w) {
         return new Promise((resolve, reject) => {
-            if (w.pending) {
-                clearTimeout(w.pending.timer);
-                w.pending.reject(new PeerNetworkError('다시 청해서 앞 요청을 버렸어요'));
-            }
+            this.dropPending(w, '다시 청해서 앞 요청을 버렸어요');
+            if (w.retry)
+                clearTimeout(w.retry);
+            w.retry = undefined;
             const nonce = randomBytes(16).toString('base64url');
             const timer = setTimeout(() => {
-                w.pending = undefined;
-                reject(new PeerNetworkError('주인 데몬이 답하지 않았어요'));
+                if (w.pending?.nonce === nonce)
+                    w.pending = undefined;
+                reject(new WatchTimeout('주인 데몬이 답하지 않았어요'));
             }, WATCH_TIMEOUT_MS);
             timer.unref();
-            w.pending = { nonce, resolve, reject, timer };
+            w.pending = { nonce, settle: { resolve, reject, timer } };
             w.sub = undefined;
             w.key = undefined;
             const sent = this.sendBox(w.owner, {
@@ -711,41 +1678,114 @@ export class PeerNetwork {
             }
         });
     }
+    dropPending(w, why) {
+        const settle = w.pending?.settle;
+        w.pending = undefined;
+        if (!settle)
+            return;
+        clearTimeout(settle.timer);
+        settle.reject(new PeerNetworkError(why));
+    }
     rewatch(w) {
-        this.requestWatch(w).catch((err) => {
-            if (err instanceof PeerNetworkError && /not_found|bad_proof/.test(err.message)) {
-                this.closeWatch(w, 'share_closed');
-            }
-            else {
-                w.feed.markOffline();
-            }
+        this.requestWatch(w)
+            .then((r) => {
+            if (r === 'waiting')
+                w.feed.markWaiting();
+        })
+            .catch((err) => {
+            if (err instanceof WatchRefused)
+                return this.onRefused(w, err.reason);
+            w.feed.markOffline();
+            // 앞 요청을 버려서 실패한 건 새 요청이 이미 나갔으니 다시 걸지 않는다
+            if (err instanceof WatchTimeout)
+                this.scheduleRewatch(w);
         });
     }
+    /**
+     * 조금 뒤에 다시 청한다. 주인 데몬이 답하지 않았거나 too_many처럼 다시 청하면 되는 거절일 때다.
+     * 이게 없으면 다음 presence가 올 때까지 보기가 offline에 멈춘다. 간격은 두 배씩 늘리고 횟수는
+     * 구독이 열릴 때만 0으로 돌아간다. 상한에 닿으면 멈추고 주인이 릴레이에 다시 붙을 때 다시 청한다.
+     */
+    scheduleRewatch(w) {
+        if (w.retry || w.retries >= MAX_REWATCH_RETRIES || !this.watches.has(w.id))
+            return;
+        const delay = Math.min(MAX_REWATCH_DELAY_MS, 1000 * 2 ** w.retries);
+        w.retries++;
+        w.retry = setTimeout(() => {
+            w.retry = undefined;
+            if (this.watches.has(w.id) && !w.pending)
+                this.rewatch(w);
+        }, delay);
+        w.retry.unref();
+    }
+    /** 주인 데몬이 보기를 거절했다. 다시 청해도 안 되는 이유면 보기를 끝낸다 */
+    onRefused(w, reason) {
+        if (!FINAL_REFUSALS.has(reason)) {
+            w.feed.markOffline();
+            this.scheduleRewatch(w);
+            return;
+        }
+        const closeAs = reason === 'not_found' || reason === 'bad_proof' ? 'share_closed' : reason;
+        this.closeWatch(w, closeAs);
+    }
     onWatchReply(from, msg) {
         const w = [...this.watches.values()].find((x) => x.owner === from && x.share === msg.share && x.pending?.nonce === msg.nonce);
-        if (!w || !w.pending)
+        if (!w || !w.pending) {
+            // 기다리다 그만둔 뒤 취소와 승인이 엇갈리면 맞는 보기가 없는 watch_ok가 온다. 주인 쪽에
+            // 구독이 열린 채로 남지 않게 그 구독을 끊어 달라고 돌려보낸다
+            if (msg.t === 'watch_ok' && typeof msg.sub === 'string' && isShareId(msg.share)) {
+                this.sendBox(from, { t: 'unwatch', share: msg.share, sub: msg.sub });
+            }
+            return;
+        }
+        const settle = w.pending.settle;
+        if (msg.t === 'watch_wait') {
+            w.feed.markWaiting();
+            if (settle) {
+                clearTimeout(settle.timer);
+                w.pending.settle = undefined;
+                settle.resolve('waiting');
+            }
             return;
-        const pending = w.pending;
+        }
         w.pending = undefined;
-        clearTimeout(pending.timer);
+        if (settle)
+            clearTimeout(settle.timer);
         if (msg.t === 'watch_err') {
-            pending.reject(new PeerNetworkError(`주인 데몬이 거절했어요: ${msg.reason}`));
+            // 주인 데몬이 보낸 글자라 CLI와 뷰어에 찍히기 전에 정리한다
+            const err = new WatchRefused(plainLabel(msg.reason, 64) ?? 'unknown');
+            if (settle)
+                settle.reject(err);
+            else
+                this.onRefused(w, err.reason);
             return;
         }
         if (typeof msg.sub !== 'string' || typeof msg.salt !== 'string') {
-            pending.reject(new PeerNetworkError('주인 데몬 답이 맞지 않아요'));
+            const err = new PeerNetworkError('주인 데몬 답이 맞지 않아요');
+            if (settle)
+                settle.reject(err);
+            else
+                w.feed.markOffline();
             return;
         }
         w.sub = msg.sub;
+        // 재청 횟수는 구독이 실제로 열렸을 때만 지운다. 거절 답에서 지우면 too_many가 이어질 때 간격이
+        // 늘지 않고 상한에도 안 닿아 1초마다 끝없이 청한다
+        w.retries = 0;
+        w.messages = msg.messages === true;
         w.key = streamKey(w.shareKey, Buffer.from(msg.salt, 'base64url'), w.share, this.key.id, msg.sub);
-        pending.resolve();
+        settle?.resolve('ok');
     }
     onWatchEnd(from, msg) {
         const w = [...this.watches.values()].find((x) => x.owner === from && x.sub === msg.sub);
         if (!w)
             return;
         w.sub = undefined;
+        w.key?.fill(0);
         w.key = undefined;
+        // 주인이 끊었으면 다시 청하지 않는다. 다시 청해도 주인 데몬이 kicked로 거절한다
+        if (msg.reason === 'kicked')
+            return this.closeWatch(w, 'kicked');
         this.rewatch(w);
     }
     onStream(from, env) {
@@ -774,11 +1814,25 @@ export class PeerNetwork {
         if (!this.watches.has(w.id))
             return;
         this.watches.delete(w.id);
-        if (w.pending) {
-            clearTimeout(w.pending.timer);
-            w.pending.reject(new PeerNetworkError(`보기가 끝났어요: ${reason}`));
-            w.pending = undefined;
+        if (w.retry)
+            clearTimeout(w.retry);
+        w.retry = undefined;
+        // 승인을 기다리던 중이면 주인 쪽 대기가 시한까지 남지 않게 그 nonce로 취소를 보낸다
+        if (w.pending && !w.sub) {
+            this.sendBox(w.owner, { t: 'watch_cancel', share: w.share, nonce: w.pending.nonce });
         }
+        this.dropPending(w, `보기가 끝났어요: ${reason}`);
+        w.key?.fill(0);
+        w.key = undefined;
+        this.closedWatches.push({
+            id: w.id,
+            share: w.share,
+            owner: w.feed.ownerPerson,
+            events: w.feed.eventCount,
+            reason,
+        });
+        if (this.closedWatches.length > MAX_CLOSED_WATCHES)
+            this.closedWatches.shift();
         w.feed.close(reason);
         try {
             this.options.state.audit('watch_close', null, JSON.stringify({ watch: w.id, share: w.share, reason }));
@@ -800,6 +1854,28 @@ export class PeerNetwork {
 function watchProofText(share, watcher, nonce) {
     return canonical({ p: 'gestalt-peer-watch-v1', share, watcher, nonce });
 }
+/** 링크를 가진 쪽만 만드는 메시지 증명. 본문까지 넣어 릴레이가 내용을 바꾸지 못하게 한다 */
+function messageProofText(share, from, id, body) {
+    return canonical({ p: 'gestalt-peer-msg-v1', share, from, id, body });
+}
+/**
+ * 답에 거는 기기 서명의 대상. 질문 id와 공유, 본문, 답한 기기, 시각을 한 덩어리로 묶어 어느 질문에
+ * 무엇이라고 답했는지를 그 기기가 보증한다. 봉인 상자의 서명은 통로의 서명이라 따로 둔다.
+ */
+export function answerSignedText(share, question, body, device, at) {
+    return canonical({ p: 'gestalt-peer-answer-v1', share, question, body, device, at });
+}
+function unique(items) {
+    return [...new Set(items)];
+}
+function isMessageStatus(v) {
+    return (v === 'queued' ||
+        v === 'sent' ||
+        v === 'arrived' ||
+        v === 'inserted' ||
+        v === 'delivered' ||
+        v === 'rejected');
+}
 function streamKey(shareKey, salt, share, watcher, sub) {
     return deriveKey(shareKey, salt, `gestalt-peer-stream-v1|${share}|${watcher}|${sub}`);
 }