@tienne/gestalt 0.111.0 → 0.113.0

package/dist/src/peer/daemon.js

@@ -1,18 +1,26 @@
+import { execFileSync } from 'node:child_process';
 import { randomBytes } from 'node:crypto';
-import { chmodSync, existsSync, linkSync, lstatSync, realpathSync, statSync, unlinkSync, } from 'node:fs';
+import { chmodSync, existsSync, linkSync, lstatSync, readdirSync, realpathSync, renameSync, statSync, unlinkSync, writeFileSync, } from 'node:fs';
 import { createConnection, createServer } from 'node:net';
 import { isAbsolute, join } from 'node:path';
 import { isToolsLevel } from './redact.js';
-import { ensurePrivateDir, MAX_SOCKET_PATH_BYTES, socketPath, statePath } from './paths.js';
+import { ensurePrivateDir, MAX_SOCKET_PATH_BYTES, socketPath, statePath, watchingDir, } from './paths.js';
 import { PeerState } from './state.js';
-import { ShareStream } from './share.js';
+import { isTranscriptFormat, ShareStream } from './share.js';
 import { ViewerServer } from './viewer.js';
-import { DEFAULT_EXPIRES_MINUTES, MAX_EXPIRES_MINUTES, MAX_REQUEST_BYTES } from './protocol.js';
-import { isSessionId } from './locate.js';
-import { errMessage } from './errors.js';
+import { DEFAULT_EXPIRES_MINUTES, DEFAULT_FIRST_WATCH_APPROVAL, MAX_EXPIRES_MINUTES, MAX_REQUEST_BYTES, } from './protocol.js';
+import { claudeConfigDir, isSessionId, listSessions } from './locate.js';
+import { errMessage, PeerNetworkError } from './errors.js';
 import { loadOrCreateMachineKey } from './keys.js';
 import { acquireDaemonLock, releaseDaemonLock } from './lock.js';
-import { PeerNetwork, PeerNetworkError } from './network.js';
+import { PeerNetwork } from './network.js';
+import { DEFAULT_ASK_TTL_MS, MAX_ASK_TTL_MS, MIN_ASK_TTL_MS } from './questions.js';
+import { findInboxSocket, findSessionSocket, writeInbox } from './inbox.js';
+import { answerHeader, frameAnswer, frameHeader, frameMessage, plainLabel, stripQuestion, } from './message.js';
+import { redactText } from './redact.js';
+import { isPersonName, isShareId } from './roster.js';
+import { buildPeek, framePeek } from './peek.js';
+import { composeExcerpt, frameExcerpt, parseExcerptItems } from './excerpt.js';
 const DEFAULT_POLL_MS = 500;
 /** stop이 IPC 서버가 닫히길 기다리는 상한. 넘으면 기다리지 않고 정리를 마친다 */
 const STOP_TIMEOUT_MS = 2_000;
@@ -41,6 +49,17 @@ export class PeerDaemon {
     /** listen할 임시 이름. 권한을 좁힌 뒤 진짜 이름으로 링크한다 */
     tmpSock;
     pollMs;
+    /** 훅 상태 파일을 다시 쓰기로 예약했는지. 한 틱 안의 바뀜을 한 번에 쓴다 */
+    watchingQueued = false;
+    /** 세션마다 마지막으로 쓴 훅 출력. 같으면 다시 안 쓴다 */
+    watchingWritten = new Map();
+    /**
+     * 이 프로세스가 시작한 시각을 ps로 읽은 글자. 훅이 같은 pid의 시작 시각과 맞춰 봐서 데몬이 죽은 뒤
+     * 그 pid를 받은 다른 프로세스를 데몬으로 믿지 않게 한다. ps를 못 부르면 빈 글자다
+     */
+    startStamp = processStartStamp(process.pid);
+    /** 보기마다 `peer watch`를 친 쪽의 Claude Code 설정 디렉토리. 발췌를 넣을 내 세션을 거기서 찾는다 */
+    watchConfigDirs = new Map();
     constructor(options) {
         this.options = options;
         this.sock = socketPath(options.root);
@@ -51,7 +70,15 @@ export class PeerDaemon {
                 const s = this.shares.get(id);
                 if (s)
                     return { stream: s.stream, token: s.token };
-                return this.network?.lookupWatch(id);
+                const w = this.network?.lookupWatch(id);
+                if (!w)
+                    return undefined;
+                // 원격 공유를 보는 중이면 고른 줄을 내 세션으로 넘길 수 있다. 내 공유는 내 세션이라 없다
+                return {
+                    ...w,
+                    sessions: () => this.localSessions(id),
+                    excerpt: (session, items) => this.sendExcerpt(id, session, items),
+                };
             },
             onConnect: (id) => this.state?.audit('viewer_connect', id),
             onDisconnect: (id) => this.state?.audit('viewer_disconnect', id),
@@ -80,6 +107,8 @@ export class PeerDaemon {
                 state.audit('share_close', id, 'daemon_restart');
             }
             this.key = loadOrCreateMachineKey(this.options.root);
+            // 죽은 데몬이 남긴 보는 중 표시를 치운다. 훅은 pid도 보지만 그 pid를 다른 프로세스가 받을 수 있다
+            this.clearWatching();
             await this.viewer.start(0);
             await this.listenIpc();
         }
@@ -98,9 +127,36 @@ export class PeerDaemon {
             key: this.key,
             lookupShare: (id) => {
                 const s = this.shares.get(id);
-                return s ? { stream: s.stream, shareKey: s.shareKey } : undefined;
+                if (!s)
+                    return undefined;
+                return {
+                    stream: s.stream,
+                    shareKey: s.shareKey,
+                    // 인박스 소켓은 세션 id로 찾으므로 --transcript로 연 공유는 메시지를 못 받는다
+                    ...(s.messages && s.sessionId
+                        ? {
+                            deliver: (m, onSeen) => this.deliverMessage(id, m, onSeen),
+                        }
+                        : {}),
+                    ...(s.agentPeek
+                        ? {
+                            peek: (since) => buildPeek({
+                                share: id,
+                                feed: s.stream,
+                                title: s.stream.sessionTitle,
+                                streamStatus: s.stream.currentStatus,
+                                since,
+                            }),
+                        }
+                        : {}),
+                };
             },
             transport: this.options.network,
+            approvalTtlMs: this.options.approvalTtlMs,
+            approvalNoticeMs: this.options.approvalNoticeMs,
+            peekNoticeMs: this.options.peekNoticeMs,
+            peekTimeoutMs: this.options.peekTimeoutMs,
+            onControlChange: () => this.scheduleWatching(),
         });
         this.network.start();
         this.startedAt = Date.now();
@@ -136,6 +192,7 @@ export class PeerDaemon {
             }
         }
         finally {
+            this.clearWatching();
             this.removeOwnSocket();
             this.state?.close();
             this.state = null;
@@ -156,7 +213,11 @@ export class PeerDaemon {
                 const { unknownGrew } = share.stream.poll();
                 if (unknownGrew) {
                     const added = share.stream.unknownLines - before;
-                    this.state?.audit('unknown_lines', id, JSON.stringify({ added, claudeVersion: share.stream.claudeVersion ?? null }));
+                    this.state?.audit('unknown_lines', id, JSON.stringify({
+                        added,
+                        format: share.stream.format,
+                        version: share.stream.toolVersion ?? null,
+                    }));
                 }
             }
             catch (err) {
@@ -192,11 +253,21 @@ export class PeerDaemon {
                 return this.openShare(req);
             case 'unshare': {
                 if (typeof req.id !== 'string' || !this.shares.has(req.id)) {
-                    return { ok: false, error: `열린 공유가 아니에요: ${String(req.id)}` };
+                    return { ok: false, error: `열린 공유가 아니에요: ${plainLabel(req.id) ?? ''}` };
                 }
+                // 끊기는 사람을 닫기 전에 센다. 닫으면 구독이 끝나 목록이 빈다
+                const ended = this.network?.shareControl(req.id).watchers ?? [];
                 this.closeShareSafely(req.id, 'unshare');
-                return { ok: true, result: { id: req.id } };
+                return { ok: true, result: { id: req.id, watchers: ended } };
             }
+            case 'kick':
+            case 'approve':
+            case 'deny':
+                return this.control(req);
+            case 'config':
+                return this.config(req);
+            case 'ask':
+                return this.ask(req);
             case 'init':
                 return this.withNetwork((n) => n.init(String(req.person), String(req.relay)));
             case 'invite':
@@ -212,25 +283,225 @@ export class PeerDaemon {
             case 'watch':
                 return this.withNetworkAsync(async (n) => {
                     const w = await n.watch(String(req.link));
-                    return { id: w.id, share: w.share, owner: w.owner, url: this.viewerUrl(w.id, w.token) };
+                    // 끝난 보기의 설정 디렉토리는 여기서 치운다. 보기는 kick이나 공유 종료로도 끝난다
+                    for (const id of [...this.watchConfigDirs.keys()]) {
+                        if (!n.lookupWatch(id))
+                            this.watchConfigDirs.delete(id);
+                    }
+                    if (typeof req.configDir === 'string' && isAbsolute(req.configDir)) {
+                        this.watchConfigDirs.set(w.id, req.configDir);
+                    }
+                    return {
+                        id: w.id,
+                        share: w.share,
+                        owner: w.owner,
+                        url: this.viewerUrl(w.id, w.token),
+                        ...(w.waiting ? { waiting: true } : {}),
+                    };
                 });
             case 'watches':
-                return this.withNetwork((n) => n.listWatches().map((w) => ({
-                    ...w,
-                    url: this.viewerUrl(w.id, n.lookupWatch(w.id).token),
-                })));
+                return this.withNetwork((n) => n.listWatches().map((w) => {
+                    const live = n.lookupWatch(w.id);
+                    return live ? { ...w, url: this.viewerUrl(w.id, live.token) } : w;
+                }));
+            case 'send': {
+                const watch = String(req.watch);
+                const body = req.body;
+                return this.withNetworkAsync((n) => n.sendMessage(watch, String(body), 'human'));
+            }
+            case 'messages': {
+                if (req.watch !== undefined) {
+                    const watch = String(req.watch);
+                    return this.withNetwork((n) => n.listMessages(watch));
+                }
+                return { ok: true, result: this.state?.messageLog() ?? [] };
+            }
             case 'unwatch': {
                 const id = String(req.id);
                 return this.withNetwork((n) => {
                     if (!n.unwatch(id))
                         throw new PeerNetworkError(`보고 있는 공유가 아니에요: ${id}`);
+                    this.watchConfigDirs.delete(id);
                     return { id };
                 });
             }
+            case 'peek':
+                return this.peek(req);
             default:
                 return { ok: false, error: `모르는 요청이에요: ${String(req.op)}` };
         }
     }
+    /** kick, approve, deny. share가 없으면 열린 공유 전부에 건다 */
+    control(req) {
+        if (!isPersonName(req.person))
+            return { ok: false, error: '이름 꼴이 아니에요' };
+        let ids;
+        if (req.share !== undefined) {
+            if (!isShareId(req.share) || !this.shares.has(req.share)) {
+                return { ok: false, error: `열린 공유가 아니에요: ${plainLabel(req.share) ?? ''}` };
+            }
+            ids = [req.share];
+        }
+        else {
+            ids = [...this.shares.keys()];
+            if (ids.length === 0)
+                return { ok: false, error: '열린 공유가 없어요' };
+        }
+        const { op, person } = req;
+        return this.withNetwork((n) => CONTROL_OPS[op](n, person, ids));
+    }
+    config(req) {
+        const state = this.state;
+        if (!state)
+            return { ok: false, error: '데몬이 아직 안 떴어요' };
+        if (req.firstWatch !== undefined) {
+            if (req.firstWatch !== 'ask' && req.firstWatch !== 'team') {
+                return { ok: false, error: '--first-watch는 ask, team 중 하나예요' };
+            }
+            state.setSettings({ ...state.getSettings(), firstWatch: req.firstWatch });
+            const revoked = this.network?.setFirstWatch(req.firstWatch) ?? 0;
+            return { ok: true, result: { firstWatch: req.firstWatch, revoked } };
+        }
+        return {
+            ok: true,
+            result: { firstWatch: state.getSettings().firstWatch ?? DEFAULT_FIRST_WATCH_APPROVAL },
+        };
+    }
+    /**
+     * ges_peer ask_user. 그 세션 id로 연 Claude Code 공유를 찾아 지금 보는 팀원에게 질문을 보낸다.
+     * 메시지를 끈 공유는 고르지 않는다. 답이 메시지와 같은 길로 들어가는데 주인이 그 길을 막았다.
+     * 질문 글자는 이 머신을 떠나므로 대화 기록과 같은 가리기를 건다.
+     */
+    ask(req) {
+        if (typeof req.sessionId !== 'string' || !isSessionId(req.sessionId)) {
+            return { ok: false, error: 'sessionId 형식이 아니에요' };
+        }
+        if (typeof req.question !== 'string')
+            return { ok: false, error: '질문이 없어요' };
+        if (req.to !== undefined && !isPersonName(req.to)) {
+            return { ok: false, error: '이름 꼴이 아니에요' };
+        }
+        let ttl = DEFAULT_ASK_TTL_MS;
+        if (req.timeoutSecs !== undefined) {
+            ttl = Number(req.timeoutSecs) * 1000;
+            if (!Number.isFinite(ttl) || ttl < MIN_ASK_TTL_MS || ttl > MAX_ASK_TTL_MS) {
+                return {
+                    ok: false,
+                    error: `timeoutSecs는 ${MIN_ASK_TTL_MS / 1000}~${MAX_ASK_TTL_MS / 1000}초예요`,
+                };
+            }
+        }
+        const mine = [...this.shares].filter(([, s]) => s.sessionId === req.sessionId && s.format === 'claude');
+        if (mine.length === 0)
+            return { ok: false, error: '이 세션을 공유하고 있지 않아요' };
+        const open = mine.filter(([, s]) => s.messages).map(([id]) => id);
+        if (open.length === 0) {
+            return {
+                ok: false,
+                error: '팀원 메시지를 끈 공유(--no-messages)라 답을 받을 수 없어서 질문도 못 보내요',
+            };
+        }
+        // 보이지 않는 글자를 먼저 지우고 가린다. 거꾸로 하면 토큰 사이에 끼운 폭 없는 공백이 가리기를
+        // 피한 뒤 지워진다. 길이 검사와 자르기는 가린 뒤 network.ask가 한다
+        const question = redactText(stripQuestion(req.question) ?? '', { home: this.options.home });
+        const to = req.to;
+        return this.withNetwork((n) => n.ask(open, question, to, ttl));
+    }
+    /**
+     * ges_peer peek. 보고 있는 원격 공유의 요약을 주인 데몬에 청해 틀로 감싼 글자로 돌려준다. 받아 줄지는
+     * 주인 데몬이 정한다. 보는 쪽은 받은 요약의 꼴과 크기를 다시 본 뒤에 감싼다.
+     */
+    peek(req) {
+        const share = req.share;
+        const since = req.since;
+        return this.withNetworkAsync(async (n) => {
+            if (typeof share !== 'string')
+                throw new PeerNetworkError('share가 없어요');
+            if (since !== undefined && typeof since !== 'string') {
+                throw new PeerNetworkError('since는 앞 peek이 돌려준 cursor예요');
+            }
+            const r = await n.peek(share, since);
+            return {
+                share: r.peek.share,
+                owner: r.owner,
+                cursor: r.peek.cursor,
+                text: framePeek(r.owner, r.peek, Date.now()),
+            };
+        });
+    }
+    /**
+     * 고른 줄을 보는 사람 머신의 세션에 `<peer-excerpt>`로 넣는다. 글자는 브라우저가 보낸 것을 쓰지
+     * 않고 보기가 들고 있는 이벤트에서 다시 만든다. 넣는 길은 주인 데몬의 메시지와 같은 인박스 소켓
+     * 쓰기다. 데몬은 그 세션의 자식이 아니라서 내 세션이라도 수신 규칙(crossSessionInbound)을 탄다.
+     * 그 세션 대화 기록은 따라 읽지 않으므로 들어갔는지는 확인하지 않는다.
+     */
+    async sendExcerpt(watchId, session, rawItems) {
+        const w = this.network?.lookupWatch(watchId);
+        if (!w)
+            return { ok: false, error: '보고 있는 공유가 아니에요' };
+        if (typeof session !== 'string' || !isSessionId(session)) {
+            return { ok: false, error: '보낼 세션을 골라 주세요' };
+        }
+        const items = parseExcerptItems(rawItems);
+        if (!items)
+            return { ok: false, error: '고른 줄 꼴이 맞지 않아요' };
+        const composed = composeExcerpt(w.stream, items);
+        if (!composed.ok)
+            return { ok: false, error: composed.reason };
+        const found = findSessionSocket(session, this.sessionConfigDirs(watchId));
+        if (!found.ok)
+            return { ok: false, error: `보낼 ${found.reason}` };
+        const text = frameExcerpt({
+            owner: w.owner,
+            share: w.share,
+            pickedBy: this.network?.person ?? '?',
+            ...(composed.from ? { from: composed.from } : {}),
+            ...(composed.to ? { to: composed.to } : {}),
+            body: composed.body,
+        });
+        const result = await writeInbox(found.path, text);
+        // 붙은 뒤 실패면 들어갔을 수 있다. 다시 보내면 겹치므로 넣음으로 알리고 그 사실을 감사 행에 남긴다
+        if (!result.ok && !result.maybeWritten)
+            return { ok: false, error: result.reason };
+        const bytes = Buffer.byteLength(composed.body);
+        this.state?.audit('excerpt_send', null, JSON.stringify({
+            watch: watchId,
+            share: w.share,
+            session,
+            items: items.length,
+            bytes,
+            ...(result.ok ? {} : { maybeWritten: true }),
+        }));
+        return { ok: true, bytes };
+    }
+    /** 발췌를 넣을 수 있는 내 세션. 인박스 소켓이 있고 프로세스가 살아 있는 것만 */
+    localSessions(watchId) {
+        const seen = new Set();
+        const out = [];
+        for (const dir of this.sessionConfigDirs(watchId)) {
+            for (const rec of listSessions(dir)) {
+                if (seen.has(rec.sessionId) || !rec.messagingSocketPath)
+                    continue;
+                if (rec.pid !== undefined && !processAlive(rec.pid))
+                    continue;
+                seen.add(rec.sessionId);
+                out.push({
+                    sessionId: rec.sessionId,
+                    cwd: redactText(rec.cwd, { home: this.options.home }),
+                    ...(rec.pid !== undefined ? { pid: rec.pid } : {}),
+                });
+            }
+        }
+        return out;
+    }
+    /** 발췌를 넣을 세션을 찾는 설정 디렉토리. `peer watch`를 친 쪽 것이 먼저고 데몬 것이 다음이다 */
+    sessionConfigDirs(watchId) {
+        const dirs = [
+            this.watchConfigDirs.get(watchId),
+            this.options.configDir ?? claudeConfigDir(),
+        ].filter((d) => d !== undefined);
+        return [...new Set(dirs)];
+    }
     withNetwork(fn) {
         if (!this.network)
             return { ok: false, error: '데몬이 아직 안 떴어요' };
@@ -251,6 +522,43 @@ export class PeerDaemon {
             return { ok: false, error: errMessage(err) };
         }
     }
+    /**
+     * 팀원이 보낸 메시지나 서명을 확인한 답을 주인 세션 인박스에 쓴다. 들어간 게 대화 기록에 보이면
+     * 대화 흐름에 끼우고 onSeen을 부른다. 지켜보는 일은 쓰기 전에 걸어야 쓰자마자 생긴 줄을 놓치지 않는다.
+     */
+    async deliverMessage(shareId, m, onSeen) {
+        const share = this.shares.get(shareId);
+        if (!share)
+            return { ok: false, reason: 'share_closed' };
+        const found = findInboxSocket(share.stream.transcriptPath, share.sessionId);
+        if (!found.ok)
+            return { ok: false, reason: found.reason };
+        const stream = share.stream;
+        const header = m.kind === 'answer'
+            ? answerHeader(m.person, m.question)
+            : frameHeader(m.person, m.origin, m.id);
+        stream.awaitMessage(header, () => {
+            if (m.kind === 'answer') {
+                stream.pushPeerAnswer({ question: m.question, from: m.person, text: m.body });
+            }
+            else {
+                stream.pushPeerMessage({ id: m.id, from: m.person, origin: m.origin, text: m.body });
+            }
+            onSeen();
+        });
+        let result = { ok: false, reason: 'deliver_failed' };
+        try {
+            result = await writeInbox(found.path, m.kind === 'answer'
+                ? frameAnswer({ from: m.person, question: m.question, body: m.body })
+                : frameMessage({ from: m.person, origin: m.origin, id: m.id, body: m.body }));
+        }
+        finally {
+            // 붙은 뒤 실패했으면 줄이 들어갔을 수 있다. 지켜보기를 남겨 들어갔으면 대화 흐름에 끼운다
+            if (!result.ok && !result.maybeWritten)
+                stream.cancelAwait(header);
+        }
+        return result;
+    }
     viewerUrl(id, token) {
         return `http://127.0.0.1:${this.viewer.port}/s/${id}?t=${token}`;
     }
@@ -285,6 +593,16 @@ export class PeerDaemon {
         if (req.sessionId !== undefined && !isSessionId(req.sessionId)) {
             return { ok: false, error: 'sessionId 형식이 아니에요' };
         }
+        const format = req.format ?? 'claude';
+        if (!isTranscriptFormat(format))
+            return { ok: false, error: 'format은 claude, codex 중 하나예요' };
+        // Codex 세션에는 메시지를 넣는 길이 없다. sessionId는 Claude Code 인박스를 찾는 데만 쓴다
+        if (format === 'codex' && req.sessionId !== undefined) {
+            return { ok: false, error: 'Codex 공유는 sessionId를 받지 않아요' };
+        }
+        const messages = format === 'claude' && req.messages !== false;
+        // 요약은 주인이 켜야만 된다. Codex 공유도 같은 규칙이다. 요약은 뷰어로 나간 이벤트에서만 추린다
+        const agentPeek = req.agentPeek === true;
         const tools = req.tools ?? 'summary';
         if (!isToolsLevel(tools))
             return { ok: false, error: '--tools는 full, summary, none 중 하나예요' };
@@ -297,13 +615,22 @@ export class PeerDaemon {
         const shareKey = randomBytes(32).toString('base64url');
         const createdAt = Date.now();
         const expiresAt = createdAt + Math.round(minutes * 60_000);
-        const stream = new ShareStream({ id, transcriptPath: real, tools, home: this.options.home });
+        const stream = new ShareStream({
+            id,
+            transcriptPath: real,
+            tools,
+            format,
+            home: this.options.home,
+        });
         stream.poll();
         this.shares.set(id, {
             stream,
             token,
             shareKey,
             sessionId: req.sessionId ?? null,
+            format,
+            messages,
+            agentPeek,
             createdAt,
             expiresAt,
         });
@@ -315,7 +642,7 @@ export class PeerDaemon {
             createdAt,
             expiresAt,
         });
-        this.state.audit('share_open', id, JSON.stringify({ tools, expiresAt }));
+        this.state.audit('share_open', id, JSON.stringify({ tools, format, expiresAt, messages, agentPeek }));
         this.announceShares();
         return { ok: true, result: this.info(id) };
     }
@@ -325,6 +652,8 @@ export class PeerDaemon {
             return;
         this.shares.delete(id);
         share.stream.close(reason);
+        this.network?.forgetShare(id);
+        this.scheduleWatching();
         this.announceShares();
         this.state?.closeShare(id, reason);
         this.state?.audit('share_close', id, reason);
@@ -338,6 +667,9 @@ export class PeerDaemon {
             sessionId: s.sessionId,
             transcriptPath: s.stream.transcriptPath,
             tools: s.stream.tools,
+            format: s.format,
+            messages: s.messages && s.sessionId !== null,
+            agentPeek: s.agentPeek,
             createdAt: s.createdAt,
             expiresAt: s.expiresAt,
             status: s.stream.currentStatus,
@@ -350,8 +682,103 @@ export class PeerDaemon {
             title: s.stream.sessionTitle,
             url: this.viewerUrl(id, s.token),
             link: this.network?.linkFor(id, s.shareKey),
+            ...(this.network?.shareControl(id) ?? { watchers: [], pending: [], blocked: [], peeks: [] }),
         };
     }
+    scheduleWatching() {
+        if (this.watchingQueued)
+            return;
+        this.watchingQueued = true;
+        setImmediate(() => {
+            this.watchingQueued = false;
+            this.writeWatching();
+        });
+    }
+    /**
+     * 보는 중 표시 훅이 읽을 세션별 상태 파일을 다시 쓴다. 원격으로 보는 사람이나 승인을 기다리는
+     * 사람이 있거나 최근 10분(PEEK_NOTICE_MS) 안에 팀원의 에이전트가 요약을 가져간 세션만 파일이 있다. 훅은 파일이 있으면 적힌 데몬이 살아 있는 한 그 내용을 그대로
+     * 내보낸다. 아무도 없는 세션은 파일을 지워서 끊긴 사람이 다음 프롬프트에 계속 보이지 않게 한다.
+     * `--transcript`로 연 공유는 세션 id가 없어서 표시하지 않는다.
+     *
+     * 마지막에 쓴 내용을 세션마다 기억해 같은 내용이면 건너뛰고 쓰기와 지우기는 파일마다 따로 실패를
+     * 처리한다. 디렉토리를 못 만들면 그 차례는 아무것도 안 쓴다.
+     */
+    writeWatching() {
+        const network = this.network;
+        if (!network || !this.state)
+            return;
+        const sessions = new Map();
+        for (const [id, s] of this.shares) {
+            if (!s.sessionId)
+                continue;
+            const c = network.shareControl(id);
+            if (c.watchers.length === 0 && c.pending.length === 0 && c.peeks.length === 0)
+                continue;
+            let entry = sessions.get(s.sessionId);
+            if (!entry) {
+                entry = { watchers: new Set(), pending: [], peeks: [] };
+                sessions.set(s.sessionId, entry);
+            }
+            for (const w of c.watchers)
+                entry.watchers.add(w);
+            entry.pending.push(...c.pending);
+            entry.peeks.push(...c.peeks);
+        }
+        const dir = watchingDir(this.options.root);
+        for (const sessionId of [...this.watchingWritten.keys()]) {
+            if (sessions.has(sessionId))
+                continue;
+            try {
+                unlinkSync(join(dir, sessionId));
+                this.watchingWritten.delete(sessionId);
+            }
+            catch (err) {
+                if (err.code === 'ENOENT')
+                    this.watchingWritten.delete(sessionId);
+                else
+                    process.stderr.write(`[peer] watching remove failed: ${errMessage(err)}\n`);
+            }
+        }
+        if (sessions.size === 0)
+            return;
+        try {
+            ensurePrivateDir(dir);
+        }
+        catch (err) {
+            process.stderr.write(`[peer] watching dir failed: ${errMessage(err)}\n`);
+            return;
+        }
+        for (const [sessionId, e] of sessions) {
+            const context = watchingContext([...e.watchers], e.pending, e.peeks);
+            const line = JSON.stringify({
+                hookSpecificOutput: { hookEventName: 'UserPromptSubmit', additionalContext: context },
+            });
+            if (this.watchingWritten.get(sessionId) === line)
+                continue;
+            try {
+                const tmp = join(dir, `.${sessionId}.tmp`);
+                writeFileSync(tmp, `${process.pid}\n${this.startStamp}\n${line}\n`, { mode: 0o600 });
+                renameSync(tmp, join(dir, sessionId));
+                this.watchingWritten.set(sessionId, line);
+            }
+            catch (err) {
+                process.stderr.write(`[peer] watching state failed: ${errMessage(err)}\n`);
+            }
+        }
+    }
+    clearWatching() {
+        this.watchingWritten.clear();
+        const dir = watchingDir(this.options.root);
+        try {
+            if (!existsSync(dir))
+                return;
+            for (const name of readdirSync(dir))
+                unlinkSync(join(dir, name));
+        }
+        catch (err) {
+            process.stderr.write(`[peer] watching cleanup failed: ${errMessage(err)}\n`);
+        }
+    }
     status() {
         let viewers = 0;
         for (const s of this.shares.values())
@@ -504,6 +931,71 @@ export class PeerDaemon {
         }
     }
 }
+/**
+ * 훅이 주인 세션 모델에 붙일 글자. 이름은 명단에서 온 값이지만 모델 컨텍스트로 들어가므로 한 줄
+ * 라벨로 정리하고 이름 꼴이 아니면 뺀다. 승인 명령은 모델이 직접 치지 않게 적는다. 주인이
+ * 받아 주는 자리를 모델이 대신 채우면 승인이 뜻이 없다.
+ */
+export function watchingContext(watchers, pending, peeks = []) {
+    const names = (list) => [...new Set(list.map((n) => plainLabel(n, 32)).filter(isPersonName))].sort();
+    const lines = [];
+    const who = names(watchers);
+    if (who.length > 0) {
+        lines.push(`[gestalt peer] ${who.join(', ')} 님이 이 세션의 대화를 보는 중이다.`);
+    }
+    // 긴 안내는 대기가 생기고 잠깐만 붙인다(brief가 서기 전). 프롬프트마다 같은 문장이 컨텍스트에
+    // 쌓이지 않게 그 뒤로는 줄인다
+    const fresh = names(pending.filter((p) => !p.brief).map((p) => p.person));
+    const old = names(pending.map((p) => p.person)).filter((n) => !fresh.includes(n));
+    if (fresh.length > 0) {
+        lines.push(`[gestalt peer] ${fresh.join(', ')} 님이 이 세션을 보려고 주인 승인을 기다린다. ` +
+            '사용자에게 알리기만 하고 승인이나 거절 명령은 직접 실행하지 않는다. ' +
+            `사용자가 \`gestalt peer approve ${fresh[0]}\`나 \`gestalt peer deny ${fresh[0]}\`로 정한다.`);
+    }
+    if (old.length > 0) {
+        lines.push(`[gestalt peer] 승인 대기: ${old.join(', ')}. 사용자가 정할 일이다.`);
+    }
+    // 요약을 가져간 사람은 알리는 시간(10분) 동안만 붙는다. 그 뒤로는 데몬이 줄을 뺀다
+    const peekers = names(peeks.map((p) => p.person));
+    if (peekers.length > 0) {
+        lines.push(`[gestalt peer] ${peekers.join(', ')} 님의 에이전트가 이 세션의 요약을 가져갔다.`);
+    }
+    return lines.join('\n');
+}
+/**
+ * pid의 시작 시각을 ps로 읽어 공백을 뺀 글자로. 훅(`scripts/peer-watching-hook.sh`)이 같은 명령으로
+ * 읽어 맞춰 본다. 로캘과 시간대에 따라 글자가 달라지지 않게 LC_ALL=C, TZ=UTC로 부른다. 데몬과 세션이
+ * 다른 TZ로 떠도 같은 프로세스면 같은 글자가 나와야 한다.
+ */
+export function processStartStamp(pid) {
+    try {
+        const out = execFileSync('ps', ['-o', 'lstart=', '-p', String(pid)], {
+            encoding: 'utf8',
+            env: { ...process.env, LC_ALL: 'C', TZ: 'UTC' },
+            stdio: ['ignore', 'pipe', 'ignore'],
+            timeout: 2_000,
+        });
+        return out.replace(/\s+/g, '');
+    }
+    catch {
+        return '';
+    }
+}
+const CONTROL_OPS = {
+    kick: (n, person, shares) => n.kick(person, shares),
+    approve: (n, person, shares) => n.approve(person, shares),
+    deny: (n, person, shares) => n.deny(person, shares),
+};
+/** pid가 살아 있는지. 남의 프로세스라 신호를 못 보내도(EPERM) 살아 있는 것이다 */
+function processAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        return err.code === 'EPERM';
+    }
+}
 function sameFile(path, id) {
     try {
         const st = lstatSync(path);