@agentshouse/kit 0.2.1-cf110d15f69c8 → 0.2.1-cf268dff1869b

package/dist/instructions.js

@@ -1,10 +1,6 @@
+import { agentInstructions } from '@agentshouse/skills';
 import { HOUSE_REF } from './git.js';
-import { HOW_WE_WORK } from './skills.js';
-const SOURCE_LINE = "From House:";
-const HOUSE_LINE = "Work with House through the `house` CLI: run `house --help`, and `house find_command` for House's guides and formats.";
-const FILE_LINE = 'To give the User a file, upload it with `house upload` and link it; for an App, a Site or a website, follow `house find_command \'{"query":"app"}\'`. Never start a server.';
-const READ_LINE = "Optional per-Room instructions: `/rooms/private/rooms/<handle>/AGENTS.md`.";
-const COPIES_LINE = `House Local copies; before work run \`house fetch\` and rebase onto \`${HOUSE_REF}\`; after it commit, then \`house push\`:`;
+const OWNER_RULES = '/rooms/private/owner-rules.md';
 const UNREADABLE = /^(?:\S+: )?(?:path_not_found|room_not_found|operation_denied)\b/;
 const FAILED = /^exit: [1-9]\d*$/;
 const CUT = /^stderr: shell: output_cut (\d+) of \d+ bytes; continue with: (.+)$/;
@@ -12,9 +8,9 @@ function cutOf(lines) {
     const cut = CUT.exec(lines[0] ?? '');
     return cut !== null && Buffer.byteLength(lines.slice(1).join('\n')) === Number(cut[1]) ? cut : null;
 }
-async function howWeWork(bridge) {
+async function readOwnerRules(bridge) {
     let document = '';
-    for (let command = `cat ${HOW_WE_WORK}`; command !== undefined;) {
+    for (let command = `cat ${OWNER_RULES}`; command !== undefined;) {
         const read = await bridge.tool('shell', { command });
         const text = read.content.map((content) => content.text).join('\n');
         const lines = text.split('\n');
@@ -28,9 +24,9 @@ async function howWeWork(bridge) {
         document += lines.slice(cut === null ? 0 : 1).join('\n');
         command = cut?.[2];
     }
-    return document.replace(/\n$/, '');
+    return document;
 }
 export async function instructions(bridge, base, copies) {
-    const lines = [SOURCE_LINE, HOUSE_LINE, FILE_LINE, READ_LINE, ...(copies.length === 0 ? [] : [COPIES_LINE, ...copies])];
-    return [lines.join('\n'), base, await howWeWork(bridge)].filter((part) => part !== '').join('\n\n');
+    const lines = agentInstructions(HOUSE_REF, copies);
+    return [lines.join('\n'), base, (await readOwnerRules(bridge)).replace(/\n$/, '')].filter((part) => part !== '').join('\n\n');
 }

package/dist/kit-cli.js

@@ -0,0 +1,68 @@
+import { parseArgs } from 'node:util';
+import { answerGitCredential } from './app-git.js';
+import { chatgpt } from './chatgpt.js';
+import { login } from './login.js';
+import { logout } from './logout.js';
+import { proxyUnlessRelayed } from './relay.js';
+import { resident } from './resident.js';
+const USAGE = 'usage: kit <login|logout|resident|chatgpt>\n';
+const COMMANDS = new Map([
+    [
+        'logout',
+        {
+            usage: 'usage: kit logout',
+            about: "disconnects this computer, stops the Kit process and ends your own agent's connection",
+            operands: 0,
+            run: logout,
+        },
+    ],
+    [
+        'resident',
+        {
+            usage: 'usage: kit resident',
+            about: "keeps this Environment connected; Kit's service runs it",
+            operands: 0,
+            run: resident,
+        },
+    ],
+    [
+        'git-credential',
+        {
+            usage: 'usage: kit git-credential <get|store|erase>',
+            about: "answers git with your own agent's House credential; git runs it",
+            operands: 1,
+            run: ([operation]) => answerGitCredential(operation),
+        },
+    ],
+]);
+const [command, ...argv] = process.argv.slice(2);
+proxyUnlessRelayed();
+async function run() {
+    if (command === 'login')
+        return login(argv);
+    if (command === 'chatgpt')
+        return chatgpt(argv);
+    if (command === '--help') {
+        parseArgs({ args: argv });
+        process.stdout.write(USAGE);
+        return;
+    }
+    const chosen = COMMANDS.get(command ?? '');
+    if (chosen === undefined) {
+        process.stderr.write(USAGE);
+        process.exitCode = 2;
+        return;
+    }
+    const { values, positionals } = parseArgs({ args: argv, options: { help: { type: 'boolean', default: false } }, allowPositionals: true });
+    if (positionals.length > chosen.operands)
+        throw new Error(`unexpected argument ${positionals[chosen.operands]}; ${chosen.usage}`);
+    if (values.help) {
+        process.stdout.write(`${chosen.usage}\n  ${chosen.about}\n`);
+        return;
+    }
+    return chosen.run(positionals);
+}
+run().catch((error) => {
+    process.stderr.write(`kit: ${error instanceof Error ? error.message : String(error)}\n`);
+    process.exitCode = 1;
+});

package/dist/kit-main.js

@@ -1,24 +1,10 @@
 #!/usr/bin/env node
-import { setGlobalProxyFromEnv } from 'node:http';
-import { answerGitCredential } from './app-git.js';
-import { login } from './login.js';
-import { logout } from './logout.js';
-import { resident } from './resident.js';
-const [command, ...argv] = process.argv.slice(2);
-setGlobalProxyFromEnv();
-async function run() {
-    if (command === 'login')
-        return login(argv);
-    if (command === 'logout')
-        return logout();
-    if (command === 'resident')
-        return resident();
-    if (command === 'git-credential')
-        return answerGitCredential(argv[0]);
-    process.stderr.write('usage: kit <login|logout|resident>\n');
-    process.exitCode = 2;
-}
-run().catch((error) => {
-    process.stderr.write(`kit: ${error instanceof Error ? error.message : String(error)}\n`);
+const [major = 0, minor = 0, patch = 0] = process.versions.node.split('.').map(Number);
+if (major < 24 || (major === 24 && (minor < 22 || (minor === 22 && patch < 1)))) {
+    process.stderr.write(`kit: the Kit needs Node 24.22.1 or newer; this is ${process.versions.node}\n`);
     process.exitCode = 1;
-});
+}
+else {
+    await import('./kit-cli.js');
+}
+export {};

package/dist/login.js

@@ -1,17 +1,17 @@
 import { spawn } from 'node:child_process';
 import { createHash, randomBytes } from 'node:crypto';
-import { hostname } from 'node:os';
-import { delimiter, dirname } from 'node:path';
 import { parseArgs } from 'node:util';
-import { post, retrying } from './api.js';
+import { HouseRefusal, post, retrying } from './api.js';
 import { placeAppGit } from './app-git.js';
-import { allowHouseInCodex, loginPath } from './clis.js';
-import { forgetOwnAgent, readDisconnected, readEnrolment, readOwnAgent, writeEnrolment, writeOwnAgent } from './home.js';
+import { writeCodexRule } from './clis.js';
+import { forgetDisconnected, forgetOwnAgent, readDisconnected, readEnrolment, readOwnAgent, writeEnrolment, writeOwnAgent, } from './home.js';
 import { callHouse, rpc } from './mcp.js';
+import { refusalOf } from './refusals.js';
 import { selectRelay } from './relay.js';
 import { startService } from './service.js';
 import { placeSkillSet } from './skills.js';
-const DEFAULT_HOUSE = 'https://agents.house';
+import { endUnserved } from './wire.js';
+export const DEFAULT_HOUSE = 'https://agents.house';
 const OPENER = process.platform === 'darwin' ? 'open' : 'xdg-open';
 // Polling every two seconds brings the User's confirmation to the waiting Kit moments after they give it.
 const POLL_INTERVAL_MS = 2000;
@@ -20,21 +20,33 @@ function open(link) {
         .on('error', () => undefined)
         .unref();
 }
-async function accepted(house, credential) {
+export async function accepted(house, credential) {
     const checked = await callHouse(house, credential, rpc('tools/list', {}));
     if (checked.status === 200)
         return true;
     if (checked.status === 401)
         return false;
+    endUnserved(checked.text);
     throw new Error(`House answered ${checked.status} when Kit checked this computer's own agent's connection: ${checked.text}`);
 }
-const USAGE = `usage: kit login [--house <origin>] [--environment <id>] [--rooms <ref>[,<ref>...] | --no-private] [--code <code>]
+const USAGE = `usage: kit login [--house <origin>] [--environment <id>] [--rooms <ref>[,<ref>...] | --no-private]
+       kit login [--house <origin>] --code <code>
   --house <origin>          the House to connect to, ${DEFAULT_HOUSE} unless one is stored
   --environment <id>        reconnect this Environment
   --rooms <ref>[,<ref>...]  give this Environment only these Rooms
   --no-private              give this Environment every Room but your Private Room
   --code <code>             connect this machine with a login code
 `;
+function connected(house, named, environment) {
+    if (named === undefined)
+        return `Environment ${environment} is connected to ${house}.\n`;
+    if (named === environment)
+        return `Environment ${environment} is reconnected to ${house}.\n`;
+    return `Environment ${named} stays with its account; this computer is connected to ${house} as new Environment ${environment} of the account that confirmed.\n`;
+}
+function gone(error) {
+    return error instanceof HouseRefusal && refusalOf(error.text)?.code === 'kit_environment_not_found';
+}
 function chosenRooms(rooms, noPrivate) {
     if (rooms !== undefined && noPrivate)
         throw new Error('--rooms and --no-private are two choices of Rooms; pass one');
@@ -73,57 +85,63 @@ export async function login(argv) {
     selectRelay(relay);
     const house = values.house ?? enrolled?.house ?? DEFAULT_HOUSE;
     const replaces = process.env.HOUSE_KIT_REPLACES;
-    const environment = replaces === undefined ? (values.environment ?? (enrolled?.house === house ? enrolled.environment : undefined)) : undefined;
+    const remembered = replaces === undefined && values.environment === undefined && enrolled?.house === house ? enrolled.environment : undefined;
+    const environment = replaces === undefined ? (values.environment ?? remembered) : undefined;
     const ownAgent = await readOwnAgent();
     let held = false;
+    let named = environment;
     let exchanged;
     if (values.code !== undefined) {
-        exchanged = await post(house, '/kit/token', { code: values.code, label: hostname() });
+        exchanged = await post(house, '/kit/token', { code: values.code });
     }
     else {
         held = ownAgent !== null && ownAgent.house === house && (await accepted(house, ownAgent.credential));
         const verifier = randomBytes(32).toString('base64url');
-        const started = await retrying(() => post(house, '/kit', {
-            label: hostname(),
-            ...(environment === undefined
+        const start = () => retrying(() => post(house, '/kit', {
+            ...(named === undefined
                 ? { act: 'new_environment', ...(replaces === undefined ? {} : { replaces }) }
-                : { act: 'existing_environment', environment_id: environment }),
+                : { act: 'existing_environment', environment_id: named }),
             ...rooms,
             code_challenge: createHash('sha256').update(verifier).digest('base64url'),
             ...(held ? {} : { headless: true }),
         }));
+        let started;
+        try {
+            started = await start();
+        }
+        catch (error) {
+            if (remembered === undefined || !gone(error))
+                throw error;
+            await forgetDisconnected();
+            process.stdout.write(`House no longer holds Environment ${remembered}; connecting this computer as a new one.\n`);
+            named = undefined;
+            started = await start();
+        }
         process.stdout.write(`Open this link and confirm: ${started.start_url}\n`);
         open(started.start_url);
         exchanged = await retrying(() => post(house, '/kit/token', { login: started.login, code_verifier: verifier }), undefined, () => POLL_INTERVAL_MS);
     }
-    try {
-        await placeSkillSet();
-    }
-    catch (error) {
-        process.stderr.write(`kit: the skills could not be placed: ${error.message}\n`);
-    }
-    try {
-        const shell = await loginPath().catch(() => '');
-        await allowHouseInCodex([dirname(process.execPath), process.env.PATH ?? '', shell].join(delimiter));
-    }
-    catch (error) {
-        process.stderr.write(`kit: Codex's rule for house could not be written: ${error.message}\n`);
-    }
+    await placeSkillSet(house);
+    await writeCodexRule().catch((error) => process.stderr.write(`kit: ${error.message}\n`));
+    const relayRecord = relay === undefined ? {} : { relay };
     await writeEnrolment({
         house,
-        ...(relay === undefined ? {} : { relay }),
+        ...relayRecord,
         environment: exchanged.environment,
         credential: exchanged.credential,
     });
-    process.stdout.write(`Environment ${exchanged.environment} is connected to ${house}.\n`);
+    process.stdout.write(connected(house, named, exchanged.environment));
     if (exchanged.headless_credential !== undefined) {
-        await writeOwnAgent({ house, user: exchanged.user, credential: exchanged.headless_credential });
+        await writeOwnAgent({ house, ...relayRecord, user: exchanged.user, credential: exchanged.headless_credential });
     }
     else if (held && ownAgent !== null && ownAgent.user !== exchanged.user) {
         await forgetOwnAgent();
         process.stdout.write("This computer's own agent was another User's; run kit login again to connect it to you.\n");
     }
-    await placeAppGit(ownAgent, await readOwnAgent());
+    else if (held && ownAgent !== null) {
+        await writeOwnAgent({ house, ...relayRecord, user: ownAgent.user, credential: ownAgent.credential });
+    }
+    await placeAppGit(await readOwnAgent()).catch((error) => process.stderr.write(`kit: ${error.message}\n`));
     try {
         startService();
     }

package/dist/logout.js

@@ -1,5 +1,4 @@
 import { HouseRefusal, post } from './api.js';
-import { forgetAppGit } from './app-git.js';
 import { forgetEnrolment, forgetOwnAgent, readEnrolment } from './home.js';
 export async function logout() {
     const enrolled = await readEnrolment();
@@ -13,7 +12,6 @@ export async function logout() {
         }
         await forgetEnrolment(enrolled);
     }
-    await forgetAppGit();
     await forgetOwnAgent();
     process.stdout.write(enrolled === null
         ? 'This computer is not connected to House.\n'

package/dist/mcp.js

@@ -1,8 +1,11 @@
 import { randomUUID } from 'node:crypto';
-import { KIT_VERSION } from './clis.js';
+import { KIT_RELEASE } from './clis.js';
 import { relayed } from './relay.js';
+import { KIT_WIRE, KIT_WIRE_HEADER } from './wire.js';
 const MCP_PROTOCOL_VERSION = '2026-07-28';
 export const UNREACHABLE = 'House is unreachable; call again in a minute';
+export class Unsettled extends Error {
+}
 export function rpc(method, params) {
     return { jsonrpc: '2.0', id: randomUUID(), method, params };
 }
@@ -13,7 +16,7 @@ export function mcpBody(message, operation) {
             ...message.params,
             _meta: {
                 'io.modelcontextprotocol/protocolVersion': MCP_PROTOCOL_VERSION,
-                'io.modelcontextprotocol/clientInfo': { name: '@agentshouse/kit', version: KIT_VERSION },
+                'io.modelcontextprotocol/clientInfo': { name: '@agentshouse/kit', version: KIT_RELEASE },
                 'io.modelcontextprotocol/clientCapabilities': {},
                 ...(operation === null ? {} : { 'agents.house/agent-operation': operation }),
             },
@@ -31,6 +34,7 @@ export async function callHouse(origin, credential, message, operation = null, s
             'mcp-protocol-version': MCP_PROTOCOL_VERSION,
             'mcp-method': message.method,
             ...(tool === null ? {} : { 'mcp-name': tool }),
+            [KIT_WIRE_HEADER]: String(KIT_WIRE),
         },
         body: mcpBody(message, operation),
         signal,

package/dist/placement.js

@@ -0,0 +1,31 @@
+import { readFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { kitHome } from './home.js';
+function recorded(name) {
+    try {
+        return readFileSync(join(kitHome(), name), 'utf8').trim();
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return null;
+        throw error;
+    }
+}
+export function installCommand() {
+    return recorded('install-command');
+}
+export function machine() {
+    const placed = recorded('placement');
+    if (placed === 'container' || placed === 'server' || placed === 'windows')
+        return placed;
+    return process.platform === 'darwin' ? 'macos' : 'linux';
+}
+export function placedPrefix() {
+    const prefix = process.env.HOUSE_KIT_PREFIX;
+    if (prefix === undefined || prefix === '')
+        throw new Error('this Kit process was not started by a launcher its installer placed');
+    return resolve(prefix);
+}
+export function releaseDirectory(release) {
+    return join(placedPrefix(), 'releases', release);
+}

package/dist/relay.js

@@ -1,13 +1,34 @@
+import { setGlobalProxyFromEnv } from 'node:http';
+const PROXY = /^https?_proxy$/i;
+const LOOPBACK = ['127.0.0.1', 'localhost', '::1'];
 let selected;
+let restoreProxy;
 export function selectRelay(relay) {
     selected = relay === undefined || relay === '' ? null : relay;
+    proxyUnlessRelayed();
 }
-function relayOrigin() {
+export function relayOrigin() {
     if (selected !== undefined)
         return selected ?? undefined;
     const ambient = process.env.HOUSE_KIT_RELAY;
     return ambient === undefined || ambient === '' ? undefined : ambient;
 }
+function unlessRelayed() {
+    if (relayOrigin() === undefined)
+        return { ...process.env };
+    return Object.fromEntries(Object.entries(process.env).filter(([name]) => !PROXY.test(name)));
+}
+export function proxyUnlessRelayed() {
+    restoreProxy?.();
+    restoreProxy = setGlobalProxyFromEnv(unlessRelayed());
+}
+export function childEnvironment() {
+    const environment = unlessRelayed();
+    if (!Object.keys(environment).some((name) => PROXY.test(name)))
+        return environment;
+    const bypassed = [environment.NO_PROXY ?? environment.no_proxy, ...LOOPBACK].filter((entry) => entry !== undefined && entry !== '').join(',');
+    return { ...environment, NO_PROXY: bypassed, no_proxy: bypassed };
+}
 export function relayed(target) {
     const url = new URL(target);
     const relay = relayOrigin();

package/dist/resident.js

@@ -1,22 +1,26 @@
 import { once } from 'node:events';
 import { watch } from 'node:fs';
 import { mkdir, rm, writeFile } from 'node:fs/promises';
-import { createServer } from 'node:http';
+import { createServer, get } from 'node:http';
 import { dirname, extname, join } from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
 import { fileURLToPath } from 'node:url';
 import { Agents } from './agents.js';
 import { house } from './api.js';
 import { received } from './bridge.js';
-import { Conversations } from './conversations.js';
+import { CONVERSATION_METHODS, Conversations } from './conversations.js';
 import { LocalCopies } from './copies.js';
-import { restart } from './end.js';
-import { agentBase, enrolled, forgetRestart, kitHome, restartAsked } from './home.js';
+import { restart, unknownMethod } from './end.js';
+import { agentBase, enrolled, kitHome, ownerLock, ownerSocket, readEnrolment } from './home.js';
+import { Calls } from './calls.js';
 import { killDescendants } from './scope.js';
+import { removeInputs, Scripts } from './scripts.js';
 import { quoted } from './shell.js';
 import { SignIns } from './sign-in.js';
 import { placeSkillSet } from './skills.js';
-import { holdStream } from './stream.js';
-import { Updates } from './update.js';
+import { holdConnection } from './connection.js';
+import { KitUpdate } from './update.js';
+import { takeUnservedRelease } from './wire.js';
 import { codexLauncher } from './work.js';
 function report(error) {
     process.stderr.write(`kit: ${error instanceof Error ? error.message : String(error)}\n`);
@@ -29,13 +33,32 @@ async function installShim(path, module) {
     await mkdir(dirname(path), { recursive: true });
     await writeFile(path, `#!/bin/sh\nexec ${quoted(process.execPath)} ${quoted(main)} "$@"\n`, { mode: 0o755 });
 }
+function claimed(lock) {
+    try {
+        lock.exec('BEGIN EXCLUSIVE');
+        return true;
+    }
+    catch (error) {
+        if (error.errcode === 5)
+            return false;
+        throw error;
+    }
+}
 async function serveOwner(copies) {
-    const socketPath = join(kitHome(), 'owner.sock');
-    await rm(socketPath, { force: true });
+    const lock = new DatabaseSync(ownerLock());
+    if (!claimed(lock)) {
+        lock.close();
+        const running = await runningResident();
+        throw new Error(`${running === null ? 'another Kit process' : `Kit process ${running}`} already runs this Environment from Kit home ${kitHome()}; stop it first to run another Kit process here`);
+    }
     const server = createServer(async (request, response) => {
         try {
             const text = await received(request);
             let answered;
+            if (request.url === '/resident') {
+                response.writeHead(200, { 'content-type': 'application/json' }).end(JSON.stringify({ pid: process.pid }));
+                return;
+            }
             if (request.url === '/git/fetch') {
                 answered = await copies.fetch();
             }
@@ -53,9 +76,23 @@ async function serveOwner(copies) {
             response.writeHead(502).end(error instanceof Error ? error.message : String(error));
         }
     });
-    server.listen(socketPath);
+    server.on('close', () => lock.close());
+    await rm(ownerSocket(), { force: true });
+    server.listen(ownerSocket());
     await once(server, 'listening');
 }
+function runningResident() {
+    return new Promise((resolve, reject) => {
+        get({ socketPath: ownerSocket(), path: '/resident' }, (answer) => {
+            received(answer).then((text) => resolve(JSON.parse(text).pid), reject);
+        }).on('error', (error) => {
+            if (error.code === 'ENOENT' || error.code === 'ECONNREFUSED')
+                resolve(null);
+            else
+                reject(error);
+        });
+    });
+}
 function connected() {
     return new Promise((resolve) => {
         const watcher = watch(kitHome(), () => {
@@ -72,77 +109,99 @@ function connected() {
         resolve();
     });
 }
-export async function resident() {
+async function started() {
     await connected();
-    await forgetRestart();
     watch(kitHome(), () => {
         if (enrolled())
             return;
         killDescendants();
         process.exit(1);
     });
-    await placeSkillSet();
+    await placeSkillSet((await readEnrolment()).house);
     await mkdir(agentBase(), { recursive: true });
-    process.env.HOUSE_KIT_RESIDENT = String(process.pid);
-    const agents = new Agents(house);
-    const copies = new LocalCopies(house);
-    await copies.load();
     await installShim(join(kitHome(), 'shim', 'git'), 'git-main');
     await installShim(codexLauncher(), 'codex-main');
+}
+export async function resident() {
+    await mkdir(kitHome(), { recursive: true, mode: 0o700 });
+    const copies = new LocalCopies(house);
+    await copies.load();
     await serveOwner(copies);
-    let stream = null;
+    await started().catch((error) => {
+        report(error);
+        process.exit(1);
+    });
+    process.env.HOUSE_KIT_RESIDENT = String(process.pid);
+    const agents = new Agents(house, () => changed());
+    let connection = null;
     let reported = false;
-    const idle = () => conversations.idle() && signIns.idle();
+    const idle = () => calls.idle() && conversations.idle() && agents.idle();
     const changed = () => {
         if (!idle()) {
             reported = false;
         }
-        else if (restartAsked() && conversations.quiet()) {
-            restart('restarting for an updated CLI');
+        else if (update.placedRelease() !== null && conversations.quiet()) {
+            restart(`Kit ${update.placedRelease()} is placed; its supervisor starts it`);
         }
         else if (!reported) {
             reported = true;
             logged(house.deliver('/kit/idle', {}, idle));
         }
     };
+    const calls = new Calls(house, changed);
     const conversations = new Conversations({
         house,
         agents,
         copies,
-        send: (frame) => stream?.send(frame) ?? false,
+        calls,
+        send: (notification) => connection?.send(notification) ?? false,
         changed,
     });
-    const signIns = new SignIns(house, agents, changed);
-    const updates = new Updates(house);
+    const signIns = new SignIns(house, agents, calls);
+    const update = new KitUpdate(calls);
+    if (process.env.HOUSE_KIT_SANDBOX !== '1')
+        takeUnservedRelease((release) => logged(update.takeRefused(release)));
+    removeInputs();
+    const scripts = new Scripts(calls, (notification) => connection?.send(notification) ?? false);
     for (const signal of ['SIGTERM', 'SIGINT']) {
         process.once(signal, () => {
             killDescendants();
+            removeInputs();
             process.kill(process.pid, signal);
         });
     }
     await house.deliver('/kit/restarted', {}).catch(report);
-    await updates.resumed().catch(report);
     logged(agents.refresh());
-    stream = holdStream({
+    agents.keepCurrent();
+    connection = holdConnection({
         opened: () => {
             conversations.opened();
             changed();
             logged(copies.connected());
         },
-        frame: (arrived) => {
-            if (arrived.type === 'watching')
-                conversations.watching(arrived.watching === true);
-            if (arrived.type === 'work_available' && arrived.subject === 'agents')
-                logged(agents.refresh());
-            if (arrived.type === 'input') {
-                reported = false;
-                if (arrived.kind === 'sign_in')
-                    signIns.start(arrived);
-                else if (arrived.kind === 'update')
-                    updates.start(arrived);
-                else
-                    conversations.input(arrived);
+        closed: () => scripts.disconnected(),
+        call: (call) => {
+            if (call.kind === 'sign_in')
+                signIns.start(call);
+            else if (call.kind === 'update')
+                update.take(call);
+            else if (call.kind === 'run_wizard' || call.kind === 'run_function')
+                scripts.start(call);
+            else if (CONVERSATION_METHODS.has(call.kind))
+                conversations.call(call);
+            else {
+                const refused = { refused: unknownMethod(call.kind) };
+                void calls.carry(call.input_id, async () => ({ result: refused }));
             }
         },
+        notification: (notification) => {
+            if (notification.type === 'watching')
+                conversations.watching(notification.watching === true);
+            if (notification.type === 'authority_changed')
+                logged(copies.changed(notification.rooms));
+            if (notification.type === 'work_available' && notification.subject === 'agents')
+                logged(agents.refresh());
+            scripts.notified(notification);
+        },
     });
 }