@clearlysh/beehaven 0.8.16

package/dist/dep-installer.js

@@ -0,0 +1,286 @@
+/**
+ * dep-installer — daemon-side handler for dependency framework installs.
+ *
+ * Invoked by daemon.ts when relay broadcasts `agent:deps-install`. Dispatches
+ * by `spec.installMethod` to the right download/extract logic, writes to the
+ * shared root (`~/Library/Application Support/Clearly/{bin,models,venv}/`),
+ * reports progress via a streaming callback the daemon pipes back to the
+ * worker's deps-install-progress RPC.
+ *
+ * Install methods supported:
+ *   - binary-download    — fetch a single executable, mark +x, write to bin/
+ *   - huggingface-model  — fetch N files from a HF repo to models/<variant>/
+ *   - pip-package        — pip install into the shared Python venv
+ *   - npm-package        — informational only (npm deps bundled at app pack time)
+ *
+ * All writes land under ~/Library/Application Support/Clearly/ — never inside
+ * a specific hive's appDir. Rationale + path layout in:
+ *   docs/ARCHITECTURE-LOCAL-WORKSPACES.md §3
+ *   docs/HIVE-DEP-VERIFICATION.md
+ *
+ * SHA256 verification runs when spec.installArgs.sha256 is populated. Until
+ * Sprint C2 lands real hashes for the vtracer binary etc., the verify path
+ * is best-effort.
+ */
+import { existsSync, mkdirSync, createWriteStream, unlinkSync, chmodSync, statSync, rmSync, } from 'fs';
+import { join, dirname } from 'path';
+import { homedir } from 'os';
+import { createHash } from 'crypto';
+import { Readable } from 'stream';
+import { pipeline } from 'stream/promises';
+// ── Paths ──────────────────────────────────────────────────────────────
+/**
+ * Shared root for all dep installs. macOS-canonical app data directory.
+ * Per-platform shimming would go here for non-Mac if the SDK ever ships
+ * cross-platform.
+ */
+function sharedRoot() {
+    return join(homedir(), 'Library', 'Application Support', 'Clearly');
+}
+function binDir() {
+    return join(sharedRoot(), 'bin');
+}
+function modelsDir() {
+    return join(sharedRoot(), 'models');
+}
+function venvDir() {
+    return join(sharedRoot(), 'venv');
+}
+/** Resolve a `~/Library/...` style path to an absolute path. */
+function expandTilde(p) {
+    if (p.startsWith('~/'))
+        return join(homedir(), p.slice(2));
+    return p;
+}
+// ── Public API ─────────────────────────────────────────────────────────
+/**
+ * Install a dependency. Returns the install path on success.
+ * Throws on failure (caller catches + reports back to the worker).
+ */
+export async function installDep(spec, onProgress) {
+    mkdirSync(sharedRoot(), { recursive: true });
+    switch (spec.installMethod) {
+        case 'binary-download':
+            return installBinary(spec, onProgress);
+        case 'huggingface-model':
+            return installHuggingfaceModel(spec, onProgress);
+        case 'pip-package':
+            return installPipPackage(spec, onProgress);
+        case 'npm-package':
+            // npm deps ship bundled with the app. This branch reports "installed"
+            // immediately — useful so the worker's dep state stays in sync with
+            // what's actually available at runtime.
+            onProgress(100, 'npm package — bundled at app pack time');
+            return '<bundled>';
+        default:
+            throw new Error(`unsupported installMethod: ${spec.installMethod}`);
+    }
+}
+/**
+ * Uninstall a dep — delete its install path. No-op if missing.
+ * Returns nothing; throws on permission errors.
+ */
+export async function uninstallDep(spec) {
+    const path = resolveInstallPath(spec);
+    if (!path)
+        return;
+    if (!existsSync(path))
+        return;
+    try {
+        rmSync(path, { recursive: true, force: true });
+    }
+    catch (e) {
+        throw new Error(`uninstall-failed: ${e?.message ?? e}`);
+    }
+}
+/** Resolve the install path the dep would land at, from its spec. */
+export function resolveInstallPath(spec) {
+    const args = spec.installArgs ?? {};
+    // Caller-supplied installPath wins.
+    if (typeof args.installPath === 'string')
+        return expandTilde(args.installPath);
+    // Per-method defaults.
+    if (spec.installMethod === 'binary-download')
+        return join(binDir(), spec.id);
+    if (spec.installMethod === 'huggingface-model') {
+        const variant = args.variant || spec.id;
+        return join(modelsDir(), variant);
+    }
+    if (spec.installMethod === 'pip-package')
+        return venvDir();
+    return null;
+}
+// ── Binary download ────────────────────────────────────────────────────
+async function installBinary(spec, onProgress) {
+    const args = spec.installArgs ?? {};
+    let url = args.downloadUrl;
+    // installArgs.downloadUrl can be a string OR a per-arch map like
+    //   { 'apple-silicon-m1+': '…', 'intel-x86_64': '…' }
+    if (typeof url === 'object' && url !== null) {
+        const arch = process.arch === 'arm64' ? 'apple-silicon-m1+' : 'intel-x86_64';
+        url = url[arch];
+    }
+    if (typeof url !== 'string') {
+        throw new Error(`binary-download: installArgs.downloadUrl missing or not a string for arch=${process.arch}`);
+    }
+    const installPath = resolveInstallPath(spec);
+    mkdirSync(dirname(installPath), { recursive: true });
+    const tmpPath = `${installPath}.partial`;
+    onProgress(0, `Downloading ${spec.id}…`);
+    await downloadToFile(url, tmpPath, spec.downloadBytes, onProgress);
+    // Optional SHA256 check
+    const expectedSha = args.sha256?.[process.arch === 'arm64' ? 'apple-silicon-m1+' : 'intel-x86_64'];
+    if (expectedSha) {
+        onProgress(95, 'Verifying SHA256…');
+        const actual = await fileSha256(tmpPath);
+        if (actual !== expectedSha) {
+            try {
+                unlinkSync(tmpPath);
+            }
+            catch { }
+            throw new Error(`sha256-mismatch: expected ${expectedSha}, got ${actual}`);
+        }
+    }
+    // Atomic rename
+    try {
+        unlinkSync(installPath);
+    }
+    catch { } // best-effort, in case existed
+    await import('fs').then((fs) => fs.promises.rename(tmpPath, installPath));
+    if (args.executable !== false) {
+        chmodSync(installPath, 0o755);
+    }
+    onProgress(100, 'Installed');
+    return installPath;
+}
+// ── HuggingFace model ──────────────────────────────────────────────────
+async function installHuggingfaceModel(spec, onProgress) {
+    const args = spec.installArgs ?? {};
+    const repo = args.repo;
+    const variant = args.variant;
+    const files = Array.isArray(args.files) ? args.files : [];
+    if (!repo)
+        throw new Error('huggingface-model: installArgs.repo required');
+    if (files.length === 0)
+        throw new Error('huggingface-model: installArgs.files (string[]) required');
+    const installPath = resolveInstallPath(spec);
+    mkdirSync(installPath, { recursive: true });
+    const totalBytes = spec.downloadBytes ?? 0;
+    let downloadedBytes = 0;
+    for (let i = 0; i < files.length; i++) {
+        const file = files[i];
+        const url = `https://huggingface.co/${repo}/resolve/main/${file}` +
+            (variant ? `?variant=${encodeURIComponent(variant)}` : '');
+        const dest = join(installPath, file);
+        mkdirSync(dirname(dest), { recursive: true });
+        const tmp = `${dest}.partial`;
+        onProgress(Math.round((downloadedBytes / Math.max(1, totalBytes)) * 100), `Downloading ${file} (${i + 1}/${files.length})…`);
+        await downloadToFile(url, tmp, undefined, (filePct, fileMsg) => {
+            // filePct is 0..100 for this single file; project onto overall %.
+            const fileShare = totalBytes > 0 ? spec.downloadBytes / files.length : 0;
+            const projected = ((downloadedBytes + (filePct / 100) * fileShare) / Math.max(1, totalBytes)) * 100;
+            onProgress(Math.min(99, Math.round(projected)), fileMsg);
+        });
+        try {
+            unlinkSync(dest);
+        }
+        catch { }
+        await import('fs').then((fs) => fs.promises.rename(tmp, dest));
+        try {
+            downloadedBytes += statSync(dest).size;
+        }
+        catch { }
+    }
+    onProgress(100, 'Installed');
+    return installPath;
+}
+// ── Pip package ────────────────────────────────────────────────────────
+async function installPipPackage(spec, onProgress) {
+    const args = spec.installArgs ?? {};
+    const pkgName = args.package;
+    if (!pkgName)
+        throw new Error('pip-package: installArgs.package (string) required');
+    // Shared venv path. Caller should have created it via the hive's setup.sh
+    // before triggering installs. If it doesn't exist, abort with guidance.
+    const pythonBin = join(venvDir(), 'bin', 'python');
+    if (!existsSync(pythonBin)) {
+        throw new Error(`pip-package: shared venv missing at ${venvDir()}. ` +
+            `Run \`beehaven app setup <hive>\` first to bootstrap it.`);
+    }
+    onProgress(0, `pip install ${pkgName}…`);
+    const { spawn } = await import('child_process');
+    await new Promise((resolve, reject) => {
+        const proc = spawn(pythonBin, ['-m', 'pip', 'install', pkgName + (args.version ? `==${args.version}` : '')], {
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let stderr = '';
+        proc.stderr?.on('data', (chunk) => {
+            stderr += chunk.toString();
+        });
+        proc.on('close', (code) => {
+            if (code === 0)
+                resolve();
+            else
+                reject(new Error(`pip-install exit=${code}: ${stderr.slice(0, 500)}`));
+        });
+        proc.on('error', reject);
+    });
+    onProgress(100, 'Installed');
+    return venvDir();
+}
+// ── Helpers ────────────────────────────────────────────────────────────
+/**
+ * Stream a URL to a file with progress reporting. Throws on non-2xx
+ * status, network errors, or partial writes. Uses node:fs streams +
+ * stream/promises pipeline for backpressure-safe writes.
+ */
+async function downloadToFile(url, destPath, expectedBytes, onProgress) {
+    const res = await fetch(url);
+    if (!res.ok)
+        throw new Error(`download-failed: HTTP ${res.status} ${res.statusText} for ${url}`);
+    if (!res.body)
+        throw new Error('download-failed: no response body');
+    // Prefer the Content-Length header for progress accuracy.
+    const totalBytes = expectedBytes ?? (Number(res.headers.get('content-length')) || 0);
+    let received = 0;
+    let lastReport = 0;
+    // Wrap the web stream in a transform that ticks the progress callback.
+    const reader = res.body.getReader();
+    const file = createWriteStream(destPath);
+    const nodeStream = new Readable({
+        async read() {
+            try {
+                const { done, value } = await reader.read();
+                if (done) {
+                    this.push(null);
+                    return;
+                }
+                received += value.byteLength;
+                const now = Date.now();
+                if (now - lastReport > 500) {
+                    lastReport = now;
+                    const pct = totalBytes > 0 ? Math.min(99, Math.round((received / totalBytes) * 100)) : 0;
+                    onProgress(pct, totalBytes > 0
+                        ? `${(received / 1_000_000).toFixed(1)} MB / ${(totalBytes / 1_000_000).toFixed(1)} MB`
+                        : `${(received / 1_000_000).toFixed(1)} MB`);
+                }
+                this.push(Buffer.from(value));
+            }
+            catch (e) {
+                this.destroy(e);
+            }
+        },
+    });
+    await pipeline(nodeStream, file);
+}
+async function fileSha256(path) {
+    const hash = createHash('sha256');
+    const fs = await import('fs');
+    await new Promise((resolve, reject) => {
+        const s = fs.createReadStream(path);
+        s.on('data', (chunk) => hash.update(chunk));
+        s.on('end', resolve);
+        s.on('error', reject);
+    });
+    return hash.digest('hex');
+}

package/dist/dev-mode.js

@@ -0,0 +1,67 @@
+/**
+ * DEV MODE — the agent is working ON Clearly, not just in it.
+ *
+ * ON by default. Turn it off for a session with `CLEARLY_DEV_MODE=0`.
+ *
+ * WHY IT EXISTS. An agent that hits a broken verb and quietly finds another way is
+ * doing its job and destroying the only evidence we get. Every real defect found in
+ * the agent stack so far was found by a HUMAN reading code, never reported by the
+ * agent that hit it: the pi room ran every turn as Claude for its whole life;
+ * `canvas.create-node type:"image"` answered "unknown type" so agents shipped rects
+ * standing in for pictures; the system prompt taught a `style:{}` node shape that
+ * silently ate every text body it was given. An agent walked into all three and said
+ * nothing, because nothing ever asked it to.
+ *
+ * THE TWIN. apps/electron/electron/treehouse-agents.ts carries the same instruction
+ * for the maid chat's Claude, and it must stay in sync BY HAND. That is not laziness:
+ * the desktop app does not depend on this package, it COPIES the built dist into
+ * Resources/beehaven at package time (electron-builder-dev.yml), so there is no
+ * import either direction. Two processes, two builds, one instruction — keep them
+ * matching, and if you change one, change the other.
+ *
+ * There are genuinely TWO Claudes and this is the honest reason both need it:
+ *   • the maid chat's  — electron main, treehouse-agents.ts ClaudeSession
+ *   • the daemon's     — `beehaven claude "<task>"`, daemon-omni.ts promptOmni
+ * They are separate Claude Agent SDK integrations in separate processes. Unifying
+ * them is a real refactor; giving them the same instruction is not.
+ */
+/** Is dev mode on? Default YES; `CLEARLY_DEV_MODE=0` (or `false`) turns it off. */
+export function devModeEnabled() {
+    const v = process.env.CLEARLY_DEV_MODE;
+    return v !== '0' && v !== 'false';
+}
+/**
+ * The instruction itself. Kept byte-identical to the electron twin so the two
+ * Claudes behave the same — diff them if you touch either.
+ */
+export const DEV_MODE_INSTRUCTION = [
+    `# Dev mode`,
+    ``,
+    `You are working ON Clearly, not just in it. You are the only one who sees this system from the outside, while using it, and that view disappears the moment you route around a problem.`,
+    ``,
+    `So: when something fights you, REPORT IT rather than quietly finding another way. Specifically —`,
+    `- a verb/arg that doesn't exist, or exists and is ignored`,
+    `- a doc, skill or tool description that says something untrue (the shape, the arg name, the default)`,
+    `- a call that "succeeds" but doesn't do what it said`,
+    `- a step you only got right by guessing, or by reading source you shouldn't have needed`,
+    `- anything you had to do twice because the first, obvious way failed`,
+    ``,
+    `Report it with the \`dev-report\` action — one call per issue:`,
+    `  beehaven call dev-report '{"kind":"bug","title":"…","tried":"the exact call","got":"what happened","expected":"what you expected","file":"path/if/known.ts"}'`,
+    `\`kind\` is "bug" (it lies or loses work) or "request" (it's merely missing). Each report lands as a card on the "claude dev mode" board; \`beehaven call dev-report '{"list":true}'\` shows what's already filed, so check before duplicating.`,
+    ``,
+    `If \`dev-report\` comes back unknown/unavailable, the verb is not deployed on this workspace yet — do NOT drop the report: put the same fields on a canvas composition called "claude dev mode" (one text node per issue, TRIED / GOT / EXPECTED / file) with canvas-act, and say in your reply that dev-report was unreachable.`,
+    `Before you file: PROVE IT. Re-run the exact call in isolation and confirm the failure is the tool's, not your first attempt's. Two of the first twelve reports filed this way were wrong — a "missing" feature that existed and was merely undocumented, and a "broken" output that was fine once read properly. A false report costs more than silence: someone fixes what was never broken. If you cannot reproduce it, file it as a DOC gap ("I could not find how to X"), which is true, instead of a BUG ("X is broken"), which may not be.`,
+    ``,
+    `A working workaround is still a bug report: note that you found one. Do not soften this into "some users might" — you hit it; say so plainly, once, with the evidence. And don't stop the task to report: finish what was asked, then file.`,
+].join('\n');
+/**
+ * `appendSystemPrompt` for a daemon Claude turn: the caller's own append (if any)
+ * plus dev mode. Returns undefined when there is nothing to append, so callers can
+ * spread it without sending an empty string.
+ */
+export function withDevMode(append) {
+    if (!devModeEnabled())
+        return append || undefined;
+    return append ? `${append}\n\n---\n\n${DEV_MODE_INSTRUCTION}` : DEV_MODE_INSTRUCTION;
+}

package/dist/doc-indexer.js

@@ -0,0 +1,169 @@
+/**
+ * DocIndexer — indexes documentation from linked projects for cloud agent context.
+ *
+ * Reads the `docs` field from beehaven.json, chunks files into digestible
+ * summaries, and sends them to the cloud DO via the `remember` action.
+ * Re-indexes on file change via chokidar.
+ *
+ * Keys are namespaced: `doc:<project>:<filepath>` so they don't collide
+ * with user memories and can be bulk-cleared on unlink.
+ */
+import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
+import { join, relative, extname } from 'path';
+import { createHash } from 'crypto';
+import { EventEmitter } from 'events';
+/** Max size per doc chunk sent to the DO (characters) */
+const MAX_CHUNK_SIZE = 4000;
+/** File extensions to index */
+const INDEXABLE_EXTENSIONS = new Set([
+    '.md',
+    '.txt',
+    '.rst',
+    '.adoc',
+    '.org',
+    '.ts',
+    '.js',
+    '.py',
+    '.rs',
+    '.go',
+    '.java',
+    '.rb',
+    '.sh',
+    '.json',
+    '.yaml',
+    '.yml',
+    '.toml',
+    '.html',
+    '.css',
+    '.sql',
+]);
+export class DocIndexer extends EventEmitter {
+    projectDir;
+    projectName;
+    docPaths;
+    callAction;
+    hashes = new Map();
+    constructor(opts) {
+        super();
+        this.projectDir = opts.projectDir;
+        this.projectName = opts.projectName;
+        this.docPaths = opts.docPaths;
+        this.callAction = opts.callAction;
+    }
+    /** Run a full index pass. Returns count of documents indexed. */
+    async index() {
+        const files = this.resolveFiles();
+        let indexed = 0;
+        for (const filePath of files) {
+            try {
+                const abs = join(this.projectDir, filePath);
+                if (!existsSync(abs))
+                    continue;
+                const content = readFileSync(abs, 'utf8');
+                const hash = createHash('md5').update(content).digest('hex');
+                // Skip if unchanged
+                if (this.hashes.get(filePath) === hash)
+                    continue;
+                this.hashes.set(filePath, hash);
+                // Chunk large files
+                const chunks = this.chunk(content, filePath);
+                for (let i = 0; i < chunks.length; i++) {
+                    const key = chunks.length === 1
+                        ? `doc:${this.projectName}:${filePath}`
+                        : `doc:${this.projectName}:${filePath}:${i + 1}`;
+                    await this.callAction('remember', {
+                        key,
+                        value: chunks[i],
+                        category: 'documentation',
+                    });
+                }
+                indexed++;
+            }
+            catch (err) {
+                this.emit('error', `Failed to index ${filePath}: ${err.message}`);
+            }
+        }
+        return indexed;
+    }
+    /** Index a single file (for watch-triggered updates) */
+    async indexFile(filePath) {
+        const abs = join(this.projectDir, filePath);
+        if (!existsSync(abs))
+            return;
+        const content = readFileSync(abs, 'utf8');
+        const hash = createHash('md5').update(content).digest('hex');
+        if (this.hashes.get(filePath) === hash)
+            return;
+        this.hashes.set(filePath, hash);
+        const chunks = this.chunk(content, filePath);
+        for (let i = 0; i < chunks.length; i++) {
+            const key = chunks.length === 1
+                ? `doc:${this.projectName}:${filePath}`
+                : `doc:${this.projectName}:${filePath}:${i + 1}`;
+            await this.callAction('remember', { key, value: chunks[i], category: 'documentation' });
+        }
+    }
+    /** Resolve glob-like doc paths to actual file paths */
+    resolveFiles() {
+        const files = [];
+        for (const docPath of this.docPaths) {
+            const abs = join(this.projectDir, docPath);
+            if (!existsSync(abs))
+                continue;
+            const stat = statSync(abs);
+            if (stat.isDirectory()) {
+                // Recursively find indexable files
+                this.walkDir(abs, files);
+            }
+            else if (stat.isFile() && this.isIndexable(abs)) {
+                files.push(relative(this.projectDir, abs));
+            }
+        }
+        return files;
+    }
+    walkDir(dir, files, depth = 0) {
+        if (depth > 5)
+            return; // Prevent deep recursion
+        try {
+            for (const entry of readdirSync(dir, { withFileTypes: true })) {
+                if (entry.name.startsWith('.') || entry.name === 'node_modules')
+                    continue;
+                const full = join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    this.walkDir(full, files, depth + 1);
+                }
+                else if (this.isIndexable(full)) {
+                    files.push(relative(this.projectDir, full));
+                }
+            }
+        }
+        catch {
+            /* permission errors, etc. */
+        }
+    }
+    isIndexable(filePath) {
+        return INDEXABLE_EXTENSIONS.has(extname(filePath).toLowerCase());
+    }
+    /** Chunk content into pieces that fit in agent memory */
+    chunk(content, filePath) {
+        const header = `[${this.projectName}] ${filePath}\n---\n`;
+        if (content.length + header.length <= MAX_CHUNK_SIZE) {
+            return [header + content];
+        }
+        // Split by sections (## headers in markdown, or every N chars)
+        const sections = content.split(/(?=^##\s)/m);
+        const chunks = [];
+        let current = header;
+        for (const section of sections) {
+            if (current.length + section.length > MAX_CHUNK_SIZE && current.length > header.length) {
+                chunks.push(current.trim());
+                current = header;
+            }
+            current += section;
+        }
+        if (current.length > header.length) {
+            chunks.push(current.trim());
+        }
+        return chunks.length > 0 ? chunks : [header + content.slice(0, MAX_CHUNK_SIZE - header.length)];
+    }
+}

package/dist/e2e-crypto.js

@@ -0,0 +1,94 @@
+// ============================================================================
+// Beehaven Daemon — End-to-End Encryption
+// ECDH key exchange + AES-256-GCM payload encryption.
+// The Cloudflare relay Worker sees only opaque ciphertext.
+// ============================================================================
+import { createECDH, createCipheriv, createDecipheriv, createHash, randomBytes } from 'crypto';
+export class E2ECrypto {
+    ecdh;
+    sharedSecret = null;
+    _ready = false;
+    constructor() {
+        this.ecdh = createECDH('prime256v1');
+        this.ecdh.generateKeys();
+    }
+    /** Get our public key (base64) to send in handshake */
+    getPublicKey() {
+        return this.ecdh.getPublicKey('base64');
+    }
+    /** Derive shared secret from the peer's public key */
+    deriveSecret(peerPublicKeyBase64) {
+        const peerKey = Buffer.from(peerPublicKeyBase64, 'base64');
+        const shared = this.ecdh.computeSecret(peerKey);
+        // SHA-256 of the raw ECDH secret -> 32-byte AES key
+        this.sharedSecret = createHash('sha256').update(shared).digest();
+        this._ready = true;
+    }
+    /** Is the E2E channel established? */
+    get ready() {
+        return this._ready;
+    }
+    /** Encrypt a message object -> { _e2e: true, iv, ct } */
+    encrypt(message) {
+        if (!this.sharedSecret)
+            throw new Error('E2E not established — call deriveSecret first');
+        const iv = randomBytes(12); // 96-bit nonce for GCM
+        const cipher = createCipheriv('aes-256-gcm', this.sharedSecret, iv);
+        const plaintext = JSON.stringify(message);
+        const encrypted = Buffer.concat([cipher.update(plaintext, 'utf8'), cipher.final()]);
+        const tag = cipher.getAuthTag(); // 16-byte authentication tag
+        return {
+            _e2e: true,
+            iv: iv.toString('base64'),
+            ct: Buffer.concat([encrypted, tag]).toString('base64'), // ciphertext || authTag
+        };
+    }
+    /** Decrypt a { _e2e, iv, ct } envelope -> original message object */
+    decrypt(envelope) {
+        if (!this.sharedSecret)
+            throw new Error('E2E not established');
+        const iv = Buffer.from(envelope.iv, 'base64');
+        const data = Buffer.from(envelope.ct, 'base64');
+        // Last 16 bytes are the GCM auth tag
+        const tag = data.subarray(data.length - 16);
+        const ciphertext = data.subarray(0, data.length - 16);
+        const decipher = createDecipheriv('aes-256-gcm', this.sharedSecret, iv);
+        decipher.setAuthTag(tag);
+        const decrypted = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+        return JSON.parse(decrypted.toString('utf8'));
+    }
+    /** Reset state for a fresh connection (new ephemeral keypair) */
+    reset() {
+        this.ecdh = createECDH('prime256v1');
+        this.ecdh.generateKeys();
+        this.sharedSecret = null;
+        this._ready = false;
+    }
+    /** Check if a message is an E2E encrypted envelope */
+    static isEncrypted(msg) {
+        return msg && msg._e2e === true && typeof msg.iv === 'string' && typeof msg.ct === 'string';
+    }
+}
+// ── Message Classification ──────────────────────────────────────────────────
+/**
+ * Message types that carry sensitive data and MUST be encrypted.
+ * Handshake/routing messages stay plaintext so the relay can route them.
+ */
+const SENSITIVE_TYPES = new Set([
+    'daemon:fs:response', // file contents
+    'agent-tool-exec-result', // code, file contents from tool execution
+    'local-agent:response', // agent output
+    'local-agent:chunk', // streaming agent output
+    'local-agent:step', // agent step details
+    'raw-event', // may contain code snippets
+    'file-teleport-delivery', // file contents (inbound)
+    'file-teleport-ack', // file paths + content confirmations
+    'telemetry', // system metrics, git info
+    'session-events', // session activity
+    'pty-output', // terminal output
+    'pty-exit', // terminal exit (may leak info via exit codes)
+]);
+/** Returns true if this message type should be encrypted when E2E is available */
+export function shouldEncrypt(msgType) {
+    return SENSITIVE_TYPES.has(msgType);
+}