@agentshouse/kit 0.2.1-ce145e9aadbf6 → 0.2.1-ce47f621f90e1

package/dist/house-main.js

@@ -1,162 +1,10 @@
 #!/usr/bin/env node
-import { createHash } from 'node:crypto';
-import { readFile } from 'node:fs/promises';
-import { request, setGlobalProxyFromEnv } from 'node:http';
-import { basename, join } from 'node:path';
-import { kitHome, readOwnAgent } from './home.js';
-import { callHouse, rpc, UNREACHABLE } from './mcp.js';
-import { refusalOf } from './refusals.js';
-const USAGE = "usage: house <tool> ['<arguments as JSON>']";
-const PUSH_USAGE = 'usage: house push [commit] [--owner]';
-const PUSH = "push [commit]: sends the Local copy's committed changes to House";
-const ARGUMENTS = `the arguments are one JSON object in single quotes, like house search '{"query":"invoice"}'`;
-const CLOSED = "this conversation's House connection is closed; nothing to do from here";
-const REVOKED = 'this conversation no longer has House access; nothing to do from here';
-const UNCONNECTED = "this computer's own agent has no House connection; run kit login";
-const DISCONNECTED = "House no longer accepts this computer's own agent; run kit login";
-const socketPath = process.env.HOUSE_BRIDGE;
-function refused(path, status, text) {
-    const refusal = refusalOf(text);
-    if (refusal !== null)
-        return refusal.text;
-    if (status === 401)
-        return REVOKED;
-    if (URL.canParse(path))
-        return `the upload answered ${status}; upload the file again`;
-    if (status === 502 && /^[A-Za-z]/.test(text))
-        return text;
-    return `${path} answered ${status}`;
-}
-function bridged(path, body, headers = { 'content-type': 'application/json' }, to = socketPath) {
-    return new Promise((resolve, reject) => {
-        const sent = request({ socketPath: to, path, method: 'POST', headers }, (answer) => {
-            let text = '';
-            answer.setEncoding('utf8');
-            answer.on('data', (chunk) => {
-                text += chunk;
-            });
-            answer.on('end', () => {
-                if (answer.statusCode === 200)
-                    resolve(text);
-                else
-                    reject(new Error(refused(path, answer.statusCode, text)));
-            });
-        });
-        sent.on('error', () => reject(new Error(CLOSED)));
-        sent.end(body instanceof Buffer ? body : JSON.stringify(body));
-    });
-}
-async function direct(message) {
-    const ownAgent = await readOwnAgent();
-    if (ownAgent === null)
-        throw new Error(UNCONNECTED);
-    setGlobalProxyFromEnv();
-    const answer = await callHouse(ownAgent.house, ownAgent.credential, message).catch(() => {
-        throw new Error(UNREACHABLE);
-    });
-    if (answer.status === 200)
-        return answer.text;
-    throw new Error(answer.status === 401 ? DISCONNECTED : (refusalOf(answer.text)?.text ?? `House answered ${answer.status}`));
-}
-async function mcp(method, params) {
-    const message = rpc(method, params);
-    const answer = JSON.parse(socketPath === undefined ? await direct(message) : await bridged('/', message));
-    if (answer.error !== undefined)
-        throw new Error(answer.error.message);
-    return answer.result;
-}
-async function tools() {
-    return (await mcp('tools/list', {})).tools;
-}
-async function localFile(path) {
-    try {
-        return await readFile(path);
-    }
-    catch (error) {
-        throw new Error(error.code === 'EISDIR'
-            ? `${path} is a folder; upload one file at a time`
-            : `${path} is not a readable file`);
-    }
-}
-async function upload(path, roomRef, missing) {
-    if (typeof path !== 'string' || path === '')
-        throw new Error(missing);
-    const bytes = await localFile(path);
-    const declared = JSON.parse(await bridged('/kit/attachments/upload', {
-        ...(roomRef === undefined ? {} : { room_ref: roomRef }),
-        name: basename(path),
-        bytes: bytes.length,
-        sha256: createHash('sha256').update(bytes).digest('hex'),
-    }));
-    if (declared.upload === undefined)
-        return declared.attachment;
-    const saved = JSON.parse(await bridged(declared.upload.url, bytes, {
-        'content-type': 'application/octet-stream',
-        'x-house-byte-operation': declared.upload.operation,
-    }));
-    if (saved.upload_failure !== undefined)
-        throw new Error(`${path} was not saved: ${saved.upload_failure}; call again later`);
-    return saved.attachment;
-}
-async function push(args) {
-    if (args.includes('--help'))
-        return PUSH_USAGE;
-    const owner = args.includes('--owner');
-    const commit = args.find((arg) => arg !== '--owner') ?? 'HEAD';
-    if (owner && socketPath !== undefined)
-        throw new Error('--owner is not for Agent conversations; run house push without it');
-    if (!owner && socketPath === undefined)
-        throw new Error('outside an Agent conversation, house push needs --owner');
-    const pushed = JSON.parse(await bridged('/git/push', { cwd: process.cwd(), commit }, undefined, owner ? join(kitHome(), 'owner.sock') : socketPath));
-    if (pushed.refused)
-        throw new Error(pushed.text);
-    return pushed.text;
-}
-function argumentsOf(argument) {
-    if (argument === undefined)
-        return {};
-    let parsed;
-    try {
-        parsed = JSON.parse(argument);
-    }
-    catch {
-        throw new Error(ARGUMENTS);
-    }
-    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed))
-        throw new Error(ARGUMENTS);
-    return parsed;
+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(`house: the Kit needs Node 24.22.1 or newer; this is ${process.versions.node}\n`);
+    process.exitCode = 1;
 }
-async function house([verb, argument]) {
-    if (verb === undefined || verb === '--help' || verb === 'help') {
-        return [USAGE, 'help', PUSH, ...(await tools()).map((tool) => (tool.description === undefined ? tool.name : `${tool.name}: ${tool.description}`))].join('\n');
-    }
-    if (argument === '--help') {
-        const tool = (await tools()).find((listed) => listed.name === verb);
-        if (tool === undefined)
-            throw new Error(`${verb} is no Tool; house find_command '{"query":"${verb}"}' finds Commands`);
-        return [...(tool.description === undefined ? [] : [tool.description]), JSON.stringify(tool.inputSchema)].join('\n');
-    }
-    const args = argumentsOf(argument);
-    if (socketPath !== undefined && verb === 'upload_attachment') {
-        return JSON.stringify({ attachment: await upload(args.path, args.room_ref, 'upload_attachment needs "path", a local file') });
-    }
-    if (socketPath !== undefined && verb === 'append_record' && Array.isArray(args.attachments)) {
-        const attachments = [];
-        for (const path of args.attachments) {
-            attachments.push(await upload(path, args.room_ref, 'each attachments entry is the path of a local file'));
-        }
-        args.attachments = attachments;
-    }
-    const result = await mcp('tools/call', { name: verb, arguments: args });
-    const text = result.content.map((content) => content.text).join('\n');
-    if (result.isError === true)
-        throw new Error(text.replace(/\n+$/, ''));
-    return text;
+else {
+    await import('./house-cli.js');
 }
-const argv = process.argv.slice(2);
-(argv[0] === 'push' ? push(argv.slice(1)) : house(argv)).then((text) => {
-    process.stdout.write(`${text}\n`);
-}, (error) => {
-    process.stderr.write(`house: ${error instanceof Error ? error.message : String(error)}\n`);
-    process.exitCode = 1;
-});
+export {};

package/dist/instructions.js

@@ -1,8 +1,6 @@
-import { HOW_WE_WORK } from './skills.js';
-const HOUSE_LINE = 'Work with House through the `house` CLI: run `house --help`.';
-const FILE_LINE = 'To give the User a file or a page, upload it with `house upload_attachment` and link it; never start a server.';
-const READ_LINE = 'Before working in a Room, read `/rooms/private/rooms/<handle>/AGENTS.md`.';
-const COPIES_LINE = 'House Local copies; commit, then `house push`:';
+import { agentInstructions } from '@agentshouse/skills';
+import { HOUSE_REF } from './git.js';
+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: (.+)$/;
@@ -10,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');
@@ -26,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 = [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,21 +1,10 @@
 #!/usr/bin/env node
-import { setGlobalProxyFromEnv } from 'node:http';
-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();
-    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,73 +1,58 @@
+import { spawn } from 'node:child_process';
 import { createHash, randomBytes } from 'node:crypto';
-import { createServer } from 'node:http';
-import { hostname } from 'node:os';
-import { createInterface } from 'node:readline/promises';
 import { parseArgs } from 'node:util';
-import { post } from './api.js';
-import { forgetOwnAgent, readDisconnected, readEnrolment, readOwnAgent, writeEnrolment, writeOwnAgent } from './home.js';
+import { HouseRefusal, post, retrying } from './api.js';
+import { placeAppGit } from './app-git.js';
+import { writeCodexRule } from './clis.js';
+import { forgetDisconnected, forgetOwnAgent, readDisconnected, readEnrolment, readOwnAgent, writeEnrolment, writeOwnAgent, } from './home.js';
 import { callHouse, rpc } from './mcp.js';
-const DEFAULT_HOUSE = 'https://agents.house';
-function listen() {
-    return new Promise((resolve, reject) => {
-        let deliver = () => undefined;
-        let held = null;
-        const code = new Promise((settle) => {
-            deliver = settle;
-        });
-        const server = createServer((request, response) => {
-            const received = new URL(request.url ?? '/', 'http://127.0.0.1').searchParams.get('code');
-            if (received === null || held !== null) {
-                response.writeHead(404).end();
-                return;
-            }
-            held = response;
-            deliver(received);
-        });
-        const close = () => {
-            server.close();
-            server.closeAllConnections();
-        };
-        const port = Number(process.env.HOUSE_KIT_LOGIN_PORT ?? 0);
-        server.once('error', reject);
-        server.listen(port, port === 0 ? '127.0.0.1' : '0.0.0.0', () => {
-            const address = server.address();
-            if (address === null || typeof address === 'string') {
-                reject(new Error('the login callback has no port'));
-                return;
-            }
-            resolve({
-                uri: `http://127.0.0.1:${address.port}/callback`,
-                code,
-                answer: (text) => new Promise((written) => {
-                    if (held === null || held.destroyed || !held.socket || held.socket.destroyed)
-                        return written();
-                    held.once('close', () => written());
-                    held.writeHead(200, { 'content-type': 'text/plain; charset=utf-8', connection: 'close' }).end(`${text}\n`);
-                }),
-                close,
-            });
-        });
-    });
+import { refusalOf } from './refusals.js';
+import { selectRelay } from './relay.js';
+import { startService } from './service.js';
+import { placeSkillSet } from './skills.js';
+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;
+function open(link) {
+    spawn(OPENER, [link], { detached: true, stdio: 'ignore' })
+        .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}`);
 }
-async function typed(question) {
-    const reader = createInterface({ input: process.stdin, output: process.stdout });
-    const closed = new Promise((_, reject) => {
-        reader.once('close', () => reject(new Error('no code was typed')));
-    });
-    try {
-        return (await Promise.race([reader.question(question), closed])).trim();
-    }
-    finally {
-        reader.close();
-    }
+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');
+    if (rooms !== undefined)
+        return { rooms: { reach: 'selected', refs: rooms.split(',') } };
+    return noPrivate ? { rooms: { reach: 'all_but_private' } } : {};
 }
 export async function login(argv) {
     const { values } = parseArgs({
@@ -75,62 +60,92 @@ export async function login(argv) {
         options: {
             house: { type: 'string' },
             environment: { type: 'string' },
-            manual: { type: 'boolean', default: false },
+            rooms: { type: 'string' },
+            'no-private': { type: 'boolean', default: false },
+            code: { type: 'string' },
+            help: { type: 'boolean', default: false },
         },
     });
+    if (values.help) {
+        process.stdout.write(USAGE);
+        return;
+    }
+    if (values.code !== undefined && values.rooms !== undefined)
+        throw new Error('--code cannot be used with --rooms');
+    if (values.code !== undefined && values['no-private'])
+        throw new Error('--code cannot be used with --no-private');
+    if (values.code !== undefined && values.environment !== undefined)
+        throw new Error('--code cannot be used with --environment');
+    const rooms = chosenRooms(values.rooms, values['no-private']);
     const enrolled = (await readEnrolment()) ?? (await readDisconnected());
+    if (values.code !== undefined && enrolled !== null) {
+        throw new Error(`--code connects a new machine; this Kit home records Environment ${enrolled.environment}, so run kit login to reconnect it`);
+    }
+    const relay = process.env.HOUSE_KIT_RELAY || undefined;
+    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();
-    const held = ownAgent !== null && ownAgent.house === house && (await accepted(house, ownAgent.credential));
-    const verifier = randomBytes(32).toString('base64url');
-    const started = {
-        ...(environment === undefined
-            ? { act: 'new_environment', label: hostname(), ...(replaces === undefined ? {} : { replaces }) }
-            : { act: 'existing_environment', environment_id: environment }),
-        code_challenge: createHash('sha256').update(verifier).digest('base64url'),
-        ...(held ? {} : { headless: true }),
-    };
-    const exchange = async (code) => {
-        const exchanged = await post(house, '/kit/token', { code, code_verifier: verifier });
-        await writeEnrolment({ house, environment: exchanged.environment, credential: exchanged.credential });
-        process.stdout.write(`Environment ${exchanged.environment} is connected to ${house}.\n`);
-        if (exchanged.headless_credential !== undefined) {
-            await writeOwnAgent({ house, user: exchanged.user, credential: exchanged.headless_credential });
-        }
-        else if (held && 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");
-        }
-    };
-    if (values.manual) {
-        const { start_url } = await post(house, '/kit', {
-            ...started,
-            presentation: 'manual',
-        });
-        process.stdout.write(`Open this link and confirm: ${start_url}\n`);
-        await exchange(await typed('Code: '));
-        return;
+    let held = false;
+    let named = environment;
+    let exchanged;
+    if (values.code !== undefined) {
+        exchanged = await post(house, '/kit/token', { code: values.code });
     }
-    const callback = await listen();
-    try {
-        const { start_url } = await post(house, '/kit', {
-            ...started,
-            presentation: 'loopback',
-            loopback_uri: callback.uri,
-        });
-        process.stdout.write(`Open this link and confirm: ${start_url}\n`);
+    else {
+        held = ownAgent !== null && ownAgent.house === house && (await accepted(house, ownAgent.credential));
+        const verifier = randomBytes(32).toString('base64url');
+        const start = () => retrying(() => post(house, '/kit', {
+            ...(named === undefined
+                ? { act: 'new_environment', ...(replaces === undefined ? {} : { replaces }) }
+                : { act: 'existing_environment', environment_id: named }),
+            ...rooms,
+            code_challenge: createHash('sha256').update(verifier).digest('base64url'),
+            ...(held ? {} : { headless: true }),
+        }));
+        let started;
         try {
-            await exchange(await callback.code);
+            started = await start();
         }
         catch (error) {
-            await callback.answer(`This Environment was not connected: ${error.message}`);
-            throw 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();
         }
-        await callback.answer('This Environment is connected. You can close this tab.');
+        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);
+    }
+    await placeSkillSet(house);
+    await writeCodexRule().catch((error) => process.stderr.write(`kit: ${error.message}\n`));
+    const relayRecord = relay === undefined ? {} : { relay };
+    await writeEnrolment({
+        house,
+        ...relayRecord,
+        environment: exchanged.environment,
+        credential: exchanged.credential,
+    });
+    process.stdout.write(connected(house, named, exchanged.environment));
+    if (exchanged.headless_credential !== undefined) {
+        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");
+    }
+    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();
     }
-    finally {
-        callback.close();
+    catch (error) {
+        process.stderr.write(`kit: ${error.message}\n`);
     }
 }

package/dist/logout.js

@@ -1,18 +1,19 @@
 import { HouseRefusal, post } from './api.js';
-import { forgetEnrolment, readEnrolment } from './home.js';
+import { forgetEnrolment, forgetOwnAgent, readEnrolment } from './home.js';
 export async function logout() {
     const enrolled = await readEnrolment();
-    if (enrolled === null) {
-        process.stdout.write('This computer is not connected to House.\n');
-        return;
+    if (enrolled !== null) {
+        try {
+            await post(enrolled.house, '/kit/logout', {}, enrolled.credential);
+        }
+        catch (error) {
+            if (!(error instanceof HouseRefusal && error.status === 401))
+                throw error;
+        }
+        await forgetEnrolment(enrolled);
     }
-    try {
-        await post(enrolled.house, '/kit/logout', {}, enrolled.credential);
-    }
-    catch (error) {
-        if (!(error instanceof HouseRefusal && error.status === 401))
-            throw error;
-    }
-    await forgetEnrolment(enrolled);
-    process.stdout.write(`Environment ${enrolled.environment} is disconnected; kit login reconnects it.\n`);
+    await forgetOwnAgent();
+    process.stdout.write(enrolled === null
+        ? 'This computer is not connected to House.\n'
+        : `Environment ${enrolled.environment} is disconnected; kit login reconnects it.\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,