@platys/relay 0.0.0-stage → 0.8.0-alpha.11

package/out/node/setup-web.js

@@ -0,0 +1,129 @@
+import { createServer } from 'node:http';
+import { randomBytes } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { userInfo } from 'node:os';
+import { spawn } from 'node:child_process';
+import { setupPage } from './setup-page.js';
+import { setupNetwork, detectClients } from './network-setup.js';
+import { networkDir } from './network-state.js';
+import { loadConnection } from './state.js';
+import { launchRemoteClaude, remoteSetupDir, setupRemote } from './remote-setup.js';
+export async function startSetupWeb(values, cli, execute = values.remote ? setupRemote : setupNetwork, launch = launchRemoteClaude) {
+    const dir = resolve(typeof values.dir === 'string' ? values.dir : values.remote ? remoteSetupDir() : networkDir());
+    const existing = existsSync(join(dir, 'connection.json')) ? loadConnection(dir) : undefined;
+    const token = randomBytes(32).toString('base64url');
+    let finish = () => { };
+    const completedSetup = new Promise(done => { finish = done; });
+    let origin = '', busy = false, completed = false;
+    let installed, launched = false;
+    const server = createServer(async (req, res) => {
+        res.setHeader('Cache-Control', 'no-store');
+        res.setHeader('X-Content-Type-Options', 'nosniff');
+        res.setHeader('X-Frame-Options', 'DENY');
+        res.setHeader('Referrer-Policy', 'no-referrer');
+        const json = (status, value) => { res.writeHead(status, { 'Content-Type': 'application/json' }); res.end(JSON.stringify(value)); };
+        if (req.headers.host !== origin.slice('http://'.length) || (req.headers.origin && req.headers.origin !== origin)) {
+            json(403, { error: 'Open setup using the link from the Relay installer.' });
+            return;
+        }
+        if (req.method === 'GET' && req.url === '/') {
+            const nonce = randomBytes(18).toString('base64url');
+            res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8', 'Content-Security-Policy': `default-src 'none'; script-src 'nonce-${nonce}'; style-src 'nonce-${nonce}'; connect-src 'self'; base-uri 'none'; form-action 'self'; frame-ancestors 'none'` });
+            res.end(setupPage(nonce));
+            return;
+        }
+        if (req.headers.authorization !== 'Bearer ' + token) {
+            json(403, { error: 'Reopen the Relay installer to continue setup.' });
+            return;
+        }
+        if (req.method === 'GET' && req.url === '/api/status') {
+            json(200, { clients: detectClients(), name: existing?.name ?? userInfo().username, connected: !!existing, remote: !!values.remote, invitation: typeof values.invite === 'string' ? values.invite : '' });
+            return;
+        }
+        if (req.method === 'POST' && req.url === '/api/launch') {
+            if (!installed?.launcher) {
+                json(409, { error: 'Connect Claude Code first.' });
+                return;
+            }
+            if (launched) {
+                json(200, { launched: true });
+                return;
+            }
+            launched = true;
+            try {
+                await launch(installed.launcher);
+                json(200, { launched: true });
+            }
+            catch {
+                launched = false;
+                json(400, { error: 'Open the Claude with Relay shortcut on your desktop. Make sure Claude Code is installed.' });
+            }
+            return;
+        }
+        if (req.method !== 'POST' || req.url !== '/api/setup') {
+            json(404, { error: 'Not found' });
+            return;
+        }
+        const result = () => ({ connected: true, ...(installed ? { remote: true, providers: installed.providers, canLaunch: !!installed.launcher, roomURL: installed.roomURL } : {}) });
+        if (completed) {
+            json(200, result());
+            return;
+        }
+        if (busy) {
+            json(409, { error: 'Setup is already running. Please wait.' });
+            return;
+        }
+        busy = true;
+        try {
+            if (req.headers['content-type'] !== 'application/json')
+                throw new Error('Send a JSON setup request.');
+            let body = '';
+            for await (const chunk of req) {
+                body += chunk;
+                if (body.length > 16000)
+                    throw new Error('The invitation is too long.');
+            }
+            const input = JSON.parse(body);
+            if (typeof input.name !== 'string' || (!existing && !input.name.trim()) || input.name.length > 80 || typeof input.invitation !== 'string' || !['auto', 'codex', 'claude', 'both'].includes(input.provider))
+                throw new Error('Enter your name and a valid Relay invitation.');
+            if (!existing && !input.invitation.trim())
+                throw new Error('Paste the Relay invitation from your friend.');
+            const configured = await execute({ ...values, dir, provider: input.provider, ...(!existing ? { name: input.name.trim(), invite: input.invitation.trim() } : {}) }, cli, { interactive: false, ask: async () => { throw new Error('Setup needs additional information.'); }, log: () => { } });
+            if ('remote' in configured)
+                installed = configured;
+            completed = true;
+            json(200, result());
+            finish();
+        }
+        catch (error) {
+            json(400, { error: error instanceof SyntaxError ? 'The setup request was not valid.' : error.message });
+        }
+        finally {
+            busy = false;
+        }
+    });
+    await new Promise((done, reject) => { server.once('error', reject); server.listen(0, '127.0.0.1', () => { server.off('error', reject); done(); }); });
+    origin = 'http://127.0.0.1:' + server.address().port;
+    return { url: origin + '/#' + token, completed: completedSetup, close: () => new Promise((done, reject) => { server.close(error => error ? reject(error) : done()); server.closeIdleConnections(); }) };
+}
+export async function openSetupWeb(values, cli) {
+    const web = await startSetupWeb(values, cli);
+    console.log(`Finish setting up Relay in your browser:\n${web.url}`);
+    if (!values['no-open']) {
+        const executable = process.platform === 'win32' ? 'rundll32.exe' : process.platform === 'darwin' ? 'open' : 'xdg-open';
+        const args = process.platform === 'win32' ? ['url.dll,FileProtocolHandler', web.url] : [web.url];
+        const child = spawn(executable, args, { windowsHide: true, stdio: 'ignore' });
+        child.on('error', () => console.error('Open the setup link above in your browser.'));
+        child.unref();
+    }
+    let stopped = false;
+    const stop = () => { if (stopped)
+        return; stopped = true; clearTimeout(timer); process.off('SIGINT', stop); process.off('SIGTERM', stop); void web.close(); };
+    const timer = setTimeout(stop, 15 * 60_000);
+    timer.unref();
+    process.once('SIGINT', stop);
+    process.once('SIGTERM', stop);
+    if (!values.remote)
+        void web.completed.then(() => { const finished = setTimeout(stop, 10000); finished.unref(); });
+}

package/out/node/sqlite.js

@@ -0,0 +1,33 @@
+import { DatabaseSync } from 'node:sqlite';
+import { mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+export class SQLite {
+    db;
+    constructor(path) {
+        if (path !== ':memory:')
+            mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+        this.db = new DatabaseSync(path);
+        try {
+            this.db.exec('PRAGMA busy_timeout=5000; PRAGMA journal_mode=WAL; PRAGMA synchronous=FULL');
+        }
+        catch (error) {
+            this.db.close();
+            throw error;
+        }
+    }
+    all(sql, ...values) { return this.db.prepare(sql).all(...values); }
+    exec(sql, ...values) { this.db.prepare(sql).run(...values); }
+    transaction(body) {
+        this.db.exec('BEGIN IMMEDIATE');
+        try {
+            const result = body();
+            this.db.exec('COMMIT');
+            return result;
+        }
+        catch (error) {
+            this.db.exec('ROLLBACK');
+            throw error;
+        }
+    }
+    close() { this.db.close(); }
+}

package/out/node/state.js

@@ -0,0 +1,113 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync, renameSync, chmodSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { SQLite } from './sqlite.js';
+export class State {
+    dir;
+    sql;
+    constructor(dir) {
+        this.dir = dir;
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+        this.sql = new SQLite(join(dir, 'state.sqlite3'));
+        for (const statement of [
+            'CREATE TABLE IF NOT EXISTS kv(key TEXT PRIMARY KEY,value TEXT NOT NULL)',
+            'CREATE TABLE IF NOT EXISTS bindings(id TEXT PRIMARY KEY,data TEXT NOT NULL)',
+            'CREATE TABLE IF NOT EXISTS outbox(id TEXT PRIMARY KEY,action TEXT NOT NULL,body TEXT NOT NULL,created INTEGER NOT NULL)',
+            'CREATE TABLE IF NOT EXISTS cache(seq INTEGER PRIMARY KEY,id TEXT UNIQUE NOT NULL,data TEXT NOT NULL)',
+            "CREATE INDEX IF NOT EXISTS cache_target ON cache(json_extract(data,'$.targetSessionId'),seq)",
+            'CREATE TABLE IF NOT EXISTS current_context(id TEXT PRIMARY KEY,data TEXT NOT NULL)',
+            'CREATE TABLE IF NOT EXISTS supersessions(previous_id TEXT PRIMARY KEY,replacement_id TEXT NOT NULL)',
+            'CREATE VIRTUAL TABLE IF NOT EXISTS history_search USING fts5(event_id UNINDEXED, text, paths)',
+            'CREATE TABLE IF NOT EXISTS delivery(event_id TEXT NOT NULL,session_id TEXT NOT NULL,state TEXT NOT NULL,detail TEXT NOT NULL,PRIMARY KEY(event_id,session_id))',
+            'CREATE TABLE IF NOT EXISTS metrics(name TEXT PRIMARY KEY,count INTEGER NOT NULL,chars INTEGER NOT NULL,bytes INTEGER NOT NULL)',
+            'CREATE TABLE IF NOT EXISTS supplied(session_id TEXT NOT NULL,event_id TEXT NOT NULL,PRIMARY KEY(session_id,event_id))'
+        ])
+            this.sql.exec(statement);
+    }
+    measure(name, value) { this.sql.exec('INSERT INTO metrics VALUES (?,1,?,?) ON CONFLICT(name) DO UPDATE SET count=count+1,chars=chars+excluded.chars,bytes=bytes+excluded.bytes', name, value.length, Buffer.byteLength(value)); }
+    metrics() { return this.sql.all('SELECT name,count,chars,bytes FROM metrics ORDER BY name'); }
+    get(key) { const row = this.sql.all('SELECT value FROM kv WHERE key=?', key)[0]; return row ? JSON.parse(row.value) : undefined; }
+    set(key, value) { this.sql.exec('INSERT INTO kv VALUES (?,?) ON CONFLICT(key) DO UPDATE SET value=excluded.value', key, JSON.stringify(value)); }
+    bindings() { return this.sql.all('SELECT data FROM bindings').map(r => JSON.parse(r.data)); }
+    binding(sessionId) {
+        const result = this.bindings().find(s => s.id === sessionId);
+        if (!result)
+            throw new Error('This session is not connected to this repository. Run relay-next connect and resume the coding session.');
+        return result;
+    }
+    bind(binding) { this.sql.exec('INSERT INTO bindings VALUES (?,?) ON CONFLICT(id) DO UPDATE SET data=excluded.data', binding.id, JSON.stringify(binding)); }
+    enqueue(action, body, key = crypto.randomUUID()) {
+        if (action === 'receipts') {
+            const previous = this.sql.all('SELECT body FROM outbox WHERE id=?', key)[0];
+            if (previous && ['delivered', 'answered'].includes(JSON.parse(previous.body).state))
+                return key;
+        }
+        this.sql.exec('INSERT INTO outbox VALUES (?,?,?,?) ON CONFLICT(id) DO UPDATE SET body=excluded.body', key, action, JSON.stringify(body), Date.now());
+        return key;
+    }
+    pending() { return this.sql.all('SELECT id,action,body FROM outbox ORDER BY created,rowid LIMIT 100').map(r => ({ ...r, body: JSON.parse(r.body) })); }
+    remove(jobId) { this.sql.exec('DELETE FROM outbox WHERE id=?', jobId); }
+    cache(events) {
+        this.sql.transaction(() => {
+            for (const event of events) {
+                const known = this.sql.all('SELECT id FROM cache WHERE id=?', event.id).length;
+                this.sql.exec('INSERT INTO cache VALUES (?,?,?) ON CONFLICT(id) DO NOTHING', event.seq, event.id, JSON.stringify(event));
+                if (!known) {
+                    this.sql.exec('INSERT INTO history_search VALUES (?,?,?)', event.id, event.text, event.paths.join(' '));
+                    if (event.supersedes) {
+                        this.sql.exec('DELETE FROM current_context WHERE id=?', event.supersedes);
+                        this.sql.exec('INSERT OR REPLACE INTO supersessions VALUES (?,?)', event.supersedes, event.id);
+                    }
+                    if (['decision', 'contract'].includes(event.kind))
+                        this.sql.exec('INSERT OR IGNORE INTO current_context VALUES (?,?)', event.id, JSON.stringify(event));
+                }
+            }
+            if (events.length)
+                this.set('cursor', Math.max(this.get('cursor') ?? 0, ...events.map(e => e.seq)));
+        });
+    }
+    events() { return this.sql.all('SELECT data FROM cache ORDER BY seq DESC LIMIT 2000').map(r => JSON.parse(r.data)).reverse(); }
+    event(eventId) { const row = this.sql.all('SELECT data FROM cache WHERE id=?', eventId)[0]; return row ? JSON.parse(row.data) : undefined; }
+    decisions() { return this.sql.all('SELECT data FROM current_context ORDER BY rowid DESC LIMIT 500').map(r => JSON.parse(r.data)); }
+    superseded(eventId) { return !!this.sql.all('SELECT 1 FROM supersessions WHERE previous_id=?', eventId).length; }
+    search(query) {
+        const terms = query.match(/[\p{L}\p{N}_]+/gu)?.slice(0, 12).map(t => '"' + t + '"').join(' OR ');
+        if (!terms)
+            return [];
+        return this.sql.all('SELECT c.data FROM history_search h JOIN cache c ON c.id=h.event_id WHERE history_search MATCH ? ORDER BY rank LIMIT 100', terms).map(r => JSON.parse(r.data));
+    }
+    messages(sessionId) { return this.sql.all("SELECT c.data FROM cache c LEFT JOIN delivery d ON d.event_id=c.id AND d.session_id=? WHERE json_extract(c.data,'$.targetSessionId')=? AND (json_extract(c.data,'$.phase') IS NULL OR json_extract(c.data,'$.phase')!='progress' OR json_extract(c.data,'$.urgent')=1) AND (d.state IS NULL OR d.state='held') ORDER BY c.seq LIMIT 50", sessionId, sessionId).map(r => JSON.parse(r.data)); }
+    delivery(eventId, sessionId) { return this.sql.all('SELECT state,detail FROM delivery WHERE event_id=? AND session_id=?', eventId, sessionId)[0]; }
+    mark(eventId, sessionId, status, detail = '') {
+        const previous = this.delivery(eventId, sessionId);
+        if (previous && (previous.state === 'answered' || previous.state === 'delivered') && status !== 'answered')
+            return;
+        this.sql.exec('INSERT INTO delivery VALUES (?,?,?,?) ON CONFLICT(event_id,session_id) DO UPDATE SET state=excluded.state,detail=excluded.detail', eventId, sessionId, status, detail);
+    }
+    supplied(sessionId, eventId) { return !!this.sql.all('SELECT 1 FROM supplied WHERE session_id=? AND event_id=?', sessionId, eventId).length; }
+    supply(sessionId, eventId) { this.sql.exec('INSERT OR IGNORE INTO supplied VALUES (?,?)', sessionId, eventId); }
+    publish(event) {
+        const captured = { ...event, git: event.git ?? this.binding(event.sessionId).git, occurredAt: event.occurredAt ?? new Date().toISOString() };
+        this.enqueue('events', captured, event.id);
+        return { eventId: event.id, status: 'pending_sync' };
+    }
+    close() { this.sql.close(); }
+}
+export function stateDir(repo) { return join(resolve(repo), '.relay', 'next'); }
+export function loadConnection(dir) {
+    const path = join(dir, 'connection.json');
+    if (!existsSync(path))
+        throw new Error('This repository is not connected. Run relay-next connect.');
+    return JSON.parse(readFileSync(path, 'utf8'));
+}
+export function saveConnection(dir, config) {
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const temp = join(dir, `connection.${crypto.randomUUID()}.tmp`), target = join(dir, 'connection.json');
+    writeFileSync(temp, JSON.stringify(config, null, 2) + '\n', { mode: 0o600 });
+    renameSync(temp, target);
+    if (process.platform !== 'win32')
+        chmodSync(target, 0o600);
+}
+export function publicSession(binding) {
+    const { endpoint: _, inboxToken: __, transcriptPath: ___, hookSeenAt: ____, terminal: _____, workspace: ______, sessionKey: _______, ...session } = binding;
+    return session;
+}

package/out/node/terminal.js

@@ -0,0 +1,28 @@
+import { connect } from 'node:net';
+// Optional presentation only. Exact recorded targets; never type input, press keys,
+// change focus, expose sockets remotely, or relax a terminal's access policy.
+export async function terminalStatus(binding, status) {
+    const terminal = binding.terminal;
+    if (!terminal?.socket || !terminal.workspace || !terminal.surface)
+        return false;
+    if (!/^[\w:-]+$/.test(terminal.workspace) || !/^[\w:-]+$/.test(terminal.surface))
+        return false;
+    if (terminal.kind === 'wmux' && !terminal.token)
+        return false;
+    return new Promise(resolve => {
+        const socket = connect(terminal.socket);
+        let finished = false;
+        const finish = (success) => { if (finished)
+            return; finished = true; clearTimeout(timer); socket.destroy(); resolve(success); };
+        const timer = setTimeout(() => finish(false), 500);
+        socket.on('connect', () => {
+            const request = terminal.kind === 'wmux'
+                ? JSON.stringify({ id: crypto.randomUUID(), method: 'sidebar.set_status', params: { key: 'relay_next', value: status, caller: terminal.surface, workspaceId: terminal.workspace }, token: terminal.token })
+                : `set_status relay_next ${status} --tab=${terminal.workspace}`;
+            socket.write(request + '\n');
+        });
+        socket.on('data', data => { const text = String(data); finish(!/"ok"\s*:\s*false|"error"|^ERR/i.test(text)); });
+        socket.on('error', () => finish(false));
+        socket.on('end', () => finish(false));
+    });
+}

package/out/node/tools.js

@@ -0,0 +1,204 @@
+import { createHash } from 'node:crypto';
+import { createInterface } from 'node:readline';
+import { bounded, paths, redact, fresh } from '../core/types.js';
+import { context, conflicts, INSTRUCTIONS, compactCode, eventPage, integer } from './context.js';
+import { snapshot } from './git.js';
+import { advancedTools, callAdvanced } from './workflow.js';
+import { loadConnection } from './state.js';
+import { Remote } from './client.js';
+import { discover, NETWORK_INSTRUCTIONS, workspaceCode, sharedWorkspace } from './network-state.js';
+import { VERSION } from '../core/version.js';
+const string = { type: 'string' };
+const definition = (name, description, properties, required) => ({ name, description, inputSchema: { type: 'object', properties: { session_id: string, ...properties }, required: ['session_id', ...required], additionalProperties: false } });
+export const TOOLS = [
+    ...advancedTools,
+    definition('relay_event', 'Read an exact event preview or next character range; does not wake another model.', { event_id: string, offset: { type: 'integer' }, limit: { type: 'integer' } }, ['event_id']),
+    definition('relay_status', 'See peer activity, last sync, actual delivery receipts and overlapping work. Paginated; receipts only on request.', { offset: { type: 'integer' }, limit: { type: 'integer' }, include_receipts: { type: 'boolean' } }, []),
+    definition('relay_context', 'Retrieve source-attributed decisions and history relevant to the current work. Code presence is reported separately.', { query: string, max_chars: { type: 'integer' } }, []),
+    definition('relay_publish', 'Publish meaningful engineering intent, decisions, contracts or test evidence. Include why; never publish secrets.', { kind: { type: 'string', enum: ['intent', 'decision', 'contract', 'test'] }, text: string, paths: { type: 'array', items: string }, evidence: string, supersedes: string, urgent: { type: 'boolean' } }, ['kind', 'text', 'paths']),
+    definition('relay_ask', 'Ask an exact peer session. Returns a request ID immediately; the answer arrives asynchronously.', { target_session_id: string, question: string, paths: { type: 'array', items: string } }, ['target_session_id', 'question']),
+    definition('relay_reply', 'Answer a question addressed to this session using retained source knowledge; state uncertainties.', { question_id: string, answer: string, evidence: string, phase: { type: 'string', enum: ['progress', 'final'] } }, ['question_id', 'answer']),
+    definition('relay_ack', 'Acknowledge a direct message that was actually supplied to this session. This is receipt, not approval.', { event_id: string, event_ids: { type: 'array', items: string } }, [])
+];
+const NETWORK_NAMES = new Set(['relay_invite', 'relay_discover', 'relay_presence', 'relay_event', 'relay_status', 'relay_context', 'relay_ask', 'relay_reply', 'relay_ack']);
+export const NETWORK_TOOLS = [
+    definition('relay_invite', 'Create a single-use invitation when the user asks to add a friend. Owner/admin only. Return it to the user; never send it to peers automatically. The invite grants group membership, including access to shared network records.', {}, []),
+    definition('relay_discover', 'Find invited peers across workspaces by person and task/topic. Multiple matches require a session choice.', { person: string, topic: string, active_only: { type: 'boolean' }, offset: { type: 'integer' }, limit: { type: 'integer' } }, []),
+    definition('relay_presence', 'Share a brief, non-sensitive description of the current task. No prompt/transcript upload.', { task: string }, ['task']),
+    ...TOOLS.filter(t => NETWORK_NAMES.has(t.name))
+].map(tool => ({ ...tool, inputSchema: { ...tool.inputSchema, properties: { ...tool.inputSchema.properties, session_key: string }, required: [...tool.inputSchema.required, 'session_key'] } }));
+export function callTool(state, name, args) {
+    const binding = state.binding(String(args.session_id)), sessionId = binding.id;
+    const network = state.get('mode') === 'network';
+    if (network && !NETWORK_NAMES.has(name))
+        throw new Error('This tool requires a repository connection');
+    if (network && (!binding.sessionKey || args.session_key !== binding.sessionKey))
+        throw new Error('Use the session_id and local session_key supplied by this session\'s Relay Network hook');
+    if (network && (!binding.workspace || !sharedWorkspace(state, binding.workspace) || binding.state === 'closed'))
+        throw new Error('This session is no longer shared; resume it in an allowed workspace');
+    if (name === 'relay_invite') {
+        if (!network)
+            throw new Error('Inviting a friend requires a network connection');
+        const config = loadConnection(state.dir);
+        return new Remote(config).call('invite', {}).then(invite => ({
+            invitation: 'relay:network:v1:' + Buffer.from(JSON.stringify({ server: config.server, projectId: config.projectId, repository: config.repository, code: invite.code })).toString('base64url'),
+            expiresAt: new Date(invite.expiresAt).toISOString(), singleUse: true,
+            instructions: 'Give this invitation to your friend. They run Relay setup and paste it when asked. All network members can access shared network records.'
+        }));
+    }
+    if (name === 'relay_discover')
+        return discover(state, sessionId, args);
+    if (name === 'relay_presence') {
+        binding.task = redact(bounded(args.task, 1000));
+        binding.updatedAt = new Date().toISOString();
+        state.bind(binding);
+        return { sessionId, task: binding.task, status: 'pending_sync' };
+    }
+    if (name === 'relay_status') {
+        const saved = state.get('snapshot');
+        const sessions = saved?.sessions ?? [];
+        const offset = integer(args.offset, 0, 0, 10000), limit = integer(args.limit, 8, 1, 20);
+        return { sessions: sessions.slice(offset, offset + limit).map(s => ({ id: s.id, name: s.name, provider: s.provider, state: s.state, task: s.task.slice(0, 300), updatedAt: s.updatedAt, freshActivity: fresh(s), git: compactCode(s.git), scopes: s.scopes.slice(0, 8) })), nextOffset: offset + limit < sessions.length ? offset + limit : null, totalSessions: sessions.length, receipts: args.include_receipts ? saved?.receipts?.slice(offset, offset + limit) ?? [] : [], overlaps: conflicts(sessions).slice(0, 8), lastSync: state.get('lastSync') ?? null, syncError: state.get('syncError') ?? null, pendingUploads: state.pending().length, rejectedUploads: state.sql.all("SELECT value FROM kv WHERE key LIKE 'rejected:%' LIMIT 8").map(r => JSON.parse(r.value)) };
+    }
+    if (name === 'relay_event') {
+        const event = state.event(String(args.event_id));
+        if (!event)
+            throw new Error('Event not in local cache; wait for synchronization');
+        if (network && event.sessionId !== sessionId && event.targetSessionId !== sessionId)
+            throw new Error('This message belongs to another conversation');
+        state.supply(sessionId, event.id);
+        return eventPage(event, integer(args.offset, 0, 0, 11000), integer(args.limit, 2000, 100, 4000));
+    }
+    if (name === 'relay_context') {
+        const budget = integer(args.max_chars, 5000, 1500, 12000), pack = context(state, sessionId, String(args.query ?? ''), true, budget - 700);
+        const result = { expand: 'relay_event(event_id, offset) for full evidence', text: pack.text, eventIds: pack.events.map(e => e.id), omitted: pack.omitted, cursor: pack.cursor, lastSync: pack.lastSync, coverage: pack.coverage };
+        // Bound the serialized response, not only the readable body.
+        while (JSON.stringify(result).length > budget && result.text.length) {
+            result.text = result.text.slice(0, -100);
+        }
+        for (const event of pack.events)
+            state.supply(sessionId, event.id);
+        return result;
+    }
+    if (name === 'relay_ack') {
+        const ids = args.event_ids ?? [args.event_id];
+        if (!Array.isArray(ids) || !ids.length || ids.length > 50)
+            throw new Error('Supply 1..50 event IDs');
+        const events = ids.map(id => state.event(String(id)));
+        if (events.some(event => !event || event.targetSessionId !== sessionId))
+            throw new Error('This message is not addressed to this session');
+        state.sql.transaction(() => { for (const event of events) {
+            state.supply(sessionId, event.id);
+            state.mark(event.id, sessionId, 'delivered', 'Recipient acknowledged receipt');
+            state.enqueue('receipts', { eventId: event.id, sessionId, state: 'delivered', detail: 'Recipient acknowledged receipt' }, `receipt:${event.id}:${sessionId}`);
+        } });
+        return { received: true, eventIds: ids };
+    }
+    const repo = binding.workspace ?? state.get('repo');
+    if (!repo)
+        throw new Error('Missing connected repository');
+    binding.git = network ? workspaceCode(repo) : snapshot(repo, binding.git.repository);
+    binding.updatedAt = new Date().toISOString();
+    const event = { id: crypto.randomUUID(), sessionId, kind: 'decision', text: '', paths: paths(args.paths ?? []) };
+    if (name === 'relay_publish') {
+        if (!['intent', 'decision', 'contract', 'test'].includes(args.kind))
+            throw new Error('Invalid publication kind');
+        event.kind = args.kind;
+        event.text = redact(bounded(args.text, 8000));
+        if (args.evidence)
+            event.evidence = redact(bounded(args.evidence, 3000));
+        if (args.supersedes)
+            event.supersedes = args.supersedes;
+        event.urgent = args.urgent === true;
+        if (event.kind === 'intent') {
+            binding.task = event.text.slice(0, 1000);
+            binding.scopes = event.paths;
+        }
+    }
+    else if (name === 'relay_ask') {
+        const target = state.get('snapshot')?.sessions.find(s => s.id === args.target_session_id);
+        if (!target || target.id === sessionId)
+            throw new Error('Choose a peer session ID from relay_status');
+        event.kind = 'question';
+        event.targetSessionId = target.id;
+        event.text = redact(bounded(args.question, 8000));
+    }
+    else if (name === 'relay_reply') {
+        const question = state.event(args.question_id);
+        if (question?.kind !== 'question' || question.targetSessionId !== sessionId)
+            throw new Error('Question was not addressed to this session');
+        event.kind = 'reply';
+        event.replyTo = question.id;
+        event.targetSessionId = question.sessionId;
+        event.text = redact(bounded(args.answer, 8000));
+        if (args.evidence)
+            event.evidence = redact(bounded(args.evidence, 3000));
+        if (args.phase !== undefined && !['progress', 'final'].includes(args.phase))
+            throw new Error('Invalid reply phase');
+        event.phase = args.phase ?? 'final';
+        if (event.phase === 'final') {
+            event.id = 'answer_' + createHash('sha256').update(sessionId + question.id).digest('hex').slice(0, 40);
+            const previous = state.get('answer:' + event.id) ?? state.event(event.id) ?? state.pending().map(j => j.body).find(e => e.id === event.id);
+            if (previous) {
+                if (previous.text !== event.text || previous.evidence !== event.evidence)
+                    throw new Error('Final answer already recorded; use progress for an explicit correction/update');
+                return { eventId: event.id, status: 'already_recorded' };
+            }
+        }
+        state.supply(sessionId, question.id);
+        state.mark(question.id, sessionId, event.phase === 'final' ? 'answer_pending' : 'delivered', 'Reply in durable local outbox');
+    }
+    else
+        throw new Error('Unknown Relay tool');
+    return state.sql.transaction(() => { state.bind(binding); const result = state.publish(event); if (event.kind === 'reply' && event.phase === 'final')
+        state.set('answer:' + event.id, event); return result; });
+}
+export async function callRelayTool(state, name, args) {
+    if (state.get('mode') === 'network' && !NETWORK_NAMES.has(name))
+        throw new Error('This tool requires a repository connection');
+    const result = advancedTools.some(t => t.name === name) ? await callAdvanced(state, name, args) : await callTool(state, name, args);
+    state.measure('tool:' + name, JSON.stringify(result));
+    return result;
+}
+export async function serveMcp(state, input = process.stdin, output = process.stdout) {
+    const lines = createInterface({ input, crlfDelay: Infinity });
+    for await (const line of lines) {
+        if (line.length > 100_000)
+            continue;
+        let request;
+        try {
+            request = JSON.parse(line);
+        }
+        catch {
+            output.write(JSON.stringify({ jsonrpc: '2.0', id: null, error: { code: -32700, message: 'Parse error' } }) + '\n');
+            continue;
+        }
+        if (request.id === undefined)
+            continue;
+        let result;
+        try {
+            if (request.method === 'initialize')
+                result = { protocolVersion: '2025-06-18', capabilities: { tools: {} }, serverInfo: { name: state.get('mode') === 'network' ? 'relay-network' : 'relay-next', version: VERSION }, instructions: state.get('mode') === 'network' ? NETWORK_INSTRUCTIONS : INSTRUCTIONS };
+            else if (request.method === 'ping')
+                result = {};
+            else if (request.method === 'tools/list')
+                result = { tools: state.get('mode') === 'network' ? NETWORK_TOOLS : TOOLS };
+            else if (request.method === 'tools/call') {
+                try {
+                    result = { content: [{ type: 'text', text: JSON.stringify(await callRelayTool(state, request.params.name, request.params.arguments ?? {})) }] };
+                }
+                catch (error) {
+                    result = { isError: true, content: [{ type: 'text', text: error.message }] };
+                }
+            }
+            else {
+                output.write(JSON.stringify({ jsonrpc: '2.0', id: request.id, error: { code: -32601, message: 'Method not found' } }) + '\n');
+                continue;
+            }
+            output.write(JSON.stringify({ jsonrpc: '2.0', id: request.id, result }) + '\n');
+        }
+        catch {
+            output.write(JSON.stringify({ jsonrpc: '2.0', id: request.id, error: { code: -32603, message: 'Relay request failed' } }) + '\n');
+        }
+    }
+}

package/out/node/workflow.js

@@ -0,0 +1,60 @@
+import { loadConnection, publicSession } from './state.js';
+import { Remote } from './client.js';
+import { snapshot } from './git.js';
+import { exportArtifact, receiveArtifact, readArtifact } from './artifacts.js';
+import { prepare, validate } from './integration.js';
+import { integer, compactCode } from './context.js';
+const str = { type: 'string' }, num = { type: 'integer' }, bool = { type: 'boolean' }, strings = { type: 'array', items: str };
+const tool = (name, description, properties, required = []) => ({ name, description, inputSchema: { type: 'object', properties: { session_id: str, ...properties }, required: ['session_id', ...required], additionalProperties: false } });
+export const advancedTools = [
+    tool('relay_project', 'Read the local shared project view without waking peers. Source claims and freshness remain explicit.', {}),
+    tool('relay_task', 'Reserve file scopes with an expiring lease. Refresh versions before renew/handoff/complete/release. Native edits outside Relay are not locked.', { operation: { type: 'string', enum: ['list', 'claim', 'renew', 'handoff', 'complete', 'release', 'block'] }, id: str, version: num, title: str, paths: strings, dependencies: strings, target_session_id: str, ttl_seconds: num, offset: num, limit: num }, ['operation']),
+    tool('relay_artifact', 'Transfer exact selected file bytes, not source text in replies. Export requires local user sharing authorization. Read returns a bounded range; receiving never applies files.', { operation: { type: 'string', enum: ['list', 'export', 'receive', 'read', 'abort'] }, artifact_id: str, paths: strings, share: bool, allow_untracked: bool, base_ref: str, summary: str, target_session_id: str, path: str, offset: num, limit: num }, ['operation']),
+    tool('relay_integration', 'Prepare an artifact in an isolated Git worktree or validate using an explicit local command. Accept is a separate developer-authorized CLI step.', { operation: { type: 'string', enum: ['prepare', 'validate'] }, artifact_id: str, id: str, command: strings, timeout_ms: num }, ['operation']),
+    tool('relay_metrics', 'Read local payload sizes and operation counts. These are not provider tokens or billing.', {})
+];
+export async function callAdvanced(state, name, args) {
+    const session = state.binding(args.session_id), remote = new Remote(loadConnection(state.dir)), repo = state.get('repo');
+    if (name === 'relay_metrics')
+        return { counters: state.metrics(), unit: 'characters and UTF-8 bytes; no model token or billing claim', providerUsage: 'Not collected' };
+    if (name === 'relay_project') {
+        const shared = state.get('snapshot') ?? {};
+        return { project: shared.project ?? { repository: session.git.repository }, acceptedRevision: shared.acceptedRevision ?? null, lastSync: state.get('lastSync') ?? null, tasks: (shared.tasks ?? []).filter((t) => t.status !== 'released' && t.status !== 'complete').slice(0, 12).map((t) => ({ ...t, leaseExpired: t.expiresAt <= Date.now() })), decisions: state.decisions().slice(-8).reverse().map(e => ({ id: e.id, kind: e.kind, text: e.text.slice(0, 300), source: e.sessionId, at: e.createdAt, head: e.git.head, dirty: e.git.dirty })), coverage: 'Up to 12 unfinished tasks and 8 current decisions; use context search for more. Recorded facts are not a fresh owner answer.' };
+    }
+    if (name === 'relay_task') {
+        if (args.operation === 'list') {
+            const saved = await remote.call('tasks'), offset = integer(args.offset, 0, 0, 10000), limit = integer(args.limit, 10, 1, 25);
+            return { tasks: saved.tasks.slice(offset, offset + limit), total: saved.tasks.length, nextOffset: offset + limit < saved.tasks.length ? offset + limit : null, acceptedRevision: saved.acceptedRevision };
+        }
+        session.git = snapshot(repo, session.git.repository);
+        state.bind(session);
+        await remote.call('sessions', publicSession(session));
+        return remote.call('tasks', { ...args, sessionId: session.id, targetSessionId: args.target_session_id, ttlSeconds: args.ttl_seconds, baseHead: session.git.head });
+    }
+    if (name === 'relay_artifact') {
+        if (args.operation === 'list') {
+            const saved = await remote.call('artifacts'), offset = integer(args.offset, 0, 0, 10000), limit = integer(args.limit, 10, 1, 25);
+            return { artifacts: saved.artifacts.slice(offset, offset + limit).map((a) => ({ ...a, source: compactCode(a.source), paths: a.paths.slice(0, 5), pathCount: a.paths.length })), total: saved.artifacts.length, nextOffset: offset + limit < saved.artifacts.length ? offset + limit : null };
+        }
+        if (args.operation === 'abort')
+            return remote.call('artifacts', { operation: 'abort', id: args.artifact_id, sessionId: session.id });
+        if (args.operation === 'export') {
+            const result = await exportArtifact(state, args);
+            return { ...result, artifact: { ...result.artifact, source: compactCode(result.artifact.source) } };
+        }
+        const { artifact, bundle } = await receiveArtifact(state, String(args.artifact_id));
+        if (args.operation === 'receive')
+            return { artifact, files: bundle.files.map(f => ({ path: f.path, before: f.before, after: f.after, bytes: f.data ? Buffer.from(f.data, 'base64').length : 0 })), applied: false };
+        if (args.operation === 'read')
+            return readArtifact(bundle, String(args.path), integer(args.offset, 0, 0, 2_000_000), integer(args.limit, 2000, 100, 4000));
+        throw new Error('Invalid artifact operation');
+    }
+    if (name === 'relay_integration') {
+        if (args.operation === 'prepare')
+            return prepare(state, String(args.artifact_id));
+        if (args.operation === 'validate')
+            return validate(state, String(args.id), args.command, integer(args.timeout_ms, 60000, 1000, 120000));
+        throw new Error('Acceptance requires the separate local CLI operation');
+    }
+    throw new Error('Unknown workflow tool');
+}