@agentshouse/kit 0.2.1-ca18b01951c3b → 0.2.1-cab5821cf0a77

package/dist/house-main.js

@@ -1,292 +1,10 @@
 #!/usr/bin/env node
-import { createHash } from 'node:crypto';
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
-import { request, setGlobalProxyFromEnv } from 'node:http';
-import { basename, dirname, extname, join, resolve } from 'node:path';
-import { verified } from './files.js';
-import { HOUSE_REF } from './git.js';
-import { kitHome, readOwnAgent } from './home.js';
-import { callHouse, rpc, UNREACHABLE } from './mcp.js';
-import { refusalOf } from './refusals.js';
-import { relayed, selectRelay } from './relay.js';
-import { parse, stringify } from 'yaml';
-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 FETCH_USAGE = 'usage: house fetch';
-const FETCH = `fetch: records House's changes on each Local copy's ${HOUSE_REF}`;
-const DOWNLOAD_USAGE = `usage: house download '{"path":"/rooms/<handle>/<path>","file":"<local file>"}', adding "ref" for a revision`;
-const DOWNLOAD = 'download: writes a binary file of a Room to the local file named by file';
-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 SANDBOXED = "your CLI's sandbox kept house from House; run house directly, not through another program";
-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, or kit chatgpt --key <key> with a script key";
-const DISCONNECTED = "House no longer accepts this computer's own agent; run kit login, or kit chatgpt --key <key> with a script key";
-const UNCONFIRMED = 'with no result; a write may or may not have taken effect, so read before you repeat it';
-const socketPath = process.env.HOUSE_BRIDGE;
-const MEDIA_TYPES = new Map([
-    ['avif', 'image/avif'],
-    ['csv', 'text/csv'],
-    ['docx', 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'],
-    ['gif', 'image/gif'],
-    ['heic', 'image/heic'],
-    ['html', 'text/html'],
-    ['jpeg', 'image/jpeg'],
-    ['jpg', 'image/jpeg'],
-    ['json', 'application/json'],
-    ['m4a', 'audio/mp4'],
-    ['md', 'text/markdown'],
-    ['mov', 'video/quicktime'],
-    ['mp3', 'audio/mpeg'],
-    ['mp4', 'video/mp4'],
-    ['ogg', 'audio/ogg'],
-    ['pdf', 'application/pdf'],
-    ['png', 'image/png'],
-    ['pptx', 'application/vnd.openxmlformats-officedocument.presentationml.presentation'],
-    ['svg', 'image/svg+xml'],
-    ['txt', 'text/plain'],
-    ['wav', 'audio/wav'],
-    ['webm', 'video/webm'],
-    ['webp', 'image/webp'],
-    ['xlsx', 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'],
-    ['zip', 'application/zip'],
-]);
-function refused(path, method, status, text, local) {
-    const refusal = refusalOf(text);
-    if (refusal !== null)
-        return refusal.text;
-    if (status === 401)
-        return REVOKED;
-    const act = method === 'GET' ? 'download' : 'upload';
-    if (URL.canParse(path))
-        return `the ${act} answered ${status}; ${act} the file again`;
-    if (status === 502 && local)
-        return text;
-    return path === '/' ? unconfirmed(status) : `${path} answered ${status}`;
-}
-function unconfirmed(status) {
-    return `House answered ${status} ${UNCONFIRMED}`;
-}
-function exchanged(path, method, body, headers = { 'content-type': 'application/json' }, to = socketPath) {
-    return new Promise((resolve, reject) => {
-        const sent = request({ socketPath: to, path, method, headers }, (answer) => {
-            const chunks = [];
-            answer.on('data', (chunk) => chunks.push(chunk));
-            answer.on('end', () => {
-                const bytes = Buffer.concat(chunks);
-                if (answer.statusCode === 200)
-                    resolve(bytes);
-                else
-                    reject(new Error(refused(path, method, answer.statusCode, bytes.toString('utf8'), answer.headers['content-type'] === undefined)));
-            });
-        });
-        sent.on('error', (error) => reject(new Error(error.code === 'EPERM' || error.code === 'EACCES' ? SANDBOXED : CLOSED)));
-        sent.end(body === undefined ? undefined : body instanceof Buffer ? body : JSON.stringify(body));
-    });
-}
-async function bridged(path, body, headers, to = socketPath) {
-    return (await exchanged(path, 'POST', body, headers, to)).toString('utf8');
-}
-async function direct(message) {
-    const ownAgent = await readOwnAgent();
-    if (ownAgent === null)
-        throw new Error(UNCONNECTED);
-    selectRelay(process.env.HOUSE_KIT_RELAY || ownAgent.relay);
-    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 ?? unconfirmed(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 transferred(url, method, bytes, headers) {
-    if (socketPath !== undefined)
-        return exchanged(url, method, bytes, headers);
-    setGlobalProxyFromEnv();
-    const answer = await fetch(relayed(url), { method, ...(headers === undefined ? {} : { headers }), ...(bytes === undefined ? {} : { body: bytes }) }).catch(() => {
-        throw new Error(UNREACHABLE);
-    });
-    const received = Buffer.from(await answer.arrayBuffer());
-    if (answer.status === 200)
-        return received;
-    throw new Error(refused(url, method, answer.status, received.toString('utf8'), false));
-}
-async function sent(url, bytes, operation) {
-    const headers = { 'content-type': 'application/octet-stream', 'x-house-byte-operation': operation };
-    return (await transferred(url, 'POST', bytes, headers)).toString('utf8');
-}
-async function download(args) {
-    const { flags, positionals: [argument] } = accepted(args, ['--help'], 1, DOWNLOAD_USAGE);
-    if (flags.has('--help'))
-        return DOWNLOAD_USAGE;
-    const { file, ...selected } = argumentsOf(argument);
-    if (typeof file !== 'string' || file === '')
-        throw new Error('download needs "file", the local file to write');
-    const inspected = parse(await called('inspect', selected));
-    if (typeof inspected?.download !== 'string')
-        throw new Error(`${String(selected.path)} holds no binary file; shell reads its text`);
-    const bytes = verified(await transferred(inspected.download, 'GET'), String(inspected.sha256), String(selected.path));
-    const written = resolve(file);
-    await mkdir(dirname(written), { recursive: true });
-    await writeFile(written, bytes);
-    return written;
-}
-async function described(file) {
-    const bytes = await localFile(file);
-    const mediaType = MEDIA_TYPES.get(extname(file).slice(1).toLowerCase());
-    return {
-        bytes,
-        description: {
-            bytes: bytes.length,
-            sha256: createHash('sha256').update(bytes).digest('hex'),
-            ...(mediaType === undefined ? {} : { media_type: mediaType }),
-        },
-    };
-}
-async function upload({ file, ...destination }) {
-    if (typeof file !== 'string' || file === '')
-        throw new Error('upload needs "file", a local file');
-    const { bytes, description } = await described(file);
-    const answer = await called('upload', { ...destination, ...description });
-    const declared = parse(answer);
-    if (declared.upload === undefined)
-        return answer;
-    const written = JSON.parse(await sent(declared.upload.url, bytes, declared.upload.operation));
-    return stringify(written, { lineWidth: 0 }).trimEnd();
-}
-async function appendRecord(args) {
-    const held = new Map();
-    const attachments = Array.isArray(args.attachments)
-        ? await Promise.all(args.attachments.map(async (attachment) => {
-            if (typeof attachment !== 'string')
-                return attachment;
-            const { bytes, description } = await described(attachment);
-            held.set(description.sha256, bytes);
-            return { name: basename(attachment), ...description };
-        }))
-        : args.attachments;
-    const record = { ...args, attachments };
-    for (;;) {
-        const answer = await called('append_record', record);
-        const { upload } = parse(answer);
-        if (upload === undefined)
-            return answer;
-        for (const grant of upload)
-            await sent(grant.url, held.get(grant.sha256), grant.operation);
-    }
-}
-function unexpected(argument, usage) {
-    return new Error(`unexpected argument ${argument}; ${usage}`);
-}
-function accepted(args, flags, positionals, usage) {
-    const given = { flags: new Set(), positionals: [] };
-    for (const arg of args) {
-        if (flags.includes(arg))
-            given.flags.add(arg);
-        else if (!arg.startsWith('-') && given.positionals.length < positionals)
-            given.positionals.push(arg);
-        else
-            throw unexpected(arg, usage);
-    }
-    return given;
-}
-async function push(args) {
-    const { flags, positionals: [commit = 'HEAD'] } = accepted(args, ['--help', '--owner'], 1, PUSH_USAGE);
-    if (flags.has('--help'))
-        return PUSH_USAGE;
-    const owner = flags.has('--owner');
-    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;
-}
-async function fetched(args) {
-    if (accepted(args, ['--help'], 0, FETCH_USAGE).flags.has('--help'))
-        return FETCH_USAGE;
-    const answer = JSON.parse(await bridged('/git/fetch', {}, undefined, socketPath ?? join(kitHome(), 'owner.sock')));
-    if (answer.refused)
-        throw new Error(answer.text);
-    return answer.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;
-}
-async function house(args) {
-    const { flags, positionals: [verb, argument] } = accepted(args, ['--help'], 2, USAGE);
-    if (verb === 'help' && argument !== undefined)
-        throw unexpected(argument, USAGE);
-    if (flags.has('--help') && argument !== undefined)
-        throw unexpected('--help', USAGE);
-    if (verb === undefined || verb === 'help') {
-        return [USAGE, 'help', PUSH, FETCH, DOWNLOAD, ...(await tools()).map((tool) => (tool.description === undefined ? tool.name : `${tool.name}: ${tool.description}`))].join('\n');
-    }
-    if (flags.has('--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 parsed = argumentsOf(argument);
-    return verb === 'upload' ? upload(parsed) : verb === 'append_record' ? appendRecord(parsed) : called(verb, 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 called(name, args) {
-    const result = await mcp('tools/call', { name, 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);
-const named = argv.findIndex((arg) => !arg.startsWith('-'));
-const rest = argv.filter((_arg, index) => index !== named);
-(argv[named] === 'push'
-    ? push(rest)
-    : argv[named] === 'fetch'
-        ? fetched(rest)
-        : argv[named] === 'download'
-            ? download(rest)
-            : house(argv)).then((text) => {
-    process.stdout.write(`${text}\n`);
-    if (argv[0] === 'shell')
-        process.exitCode = Number(/^exit: (\d+)(?:\n|$)/.exec(text)?.[1] ?? 0);
-}, (error) => {
-    process.stderr.write(`house: ${error instanceof Error ? error.message : String(error)}\n`);
-    process.exitCode = 1;
-});
+export {};

package/dist/instructions.js

@@ -1,11 +1,32 @@
+import { agentInstructions } from '@agentshouse/skills';
 import { HOUSE_REF } from './git.js';
-import { readHowWeWork } 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: (.+)$/;
+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 readOwnerRules(bridge) {
+    let document = '';
+    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');
+        if (read.isError === true || (FAILED.test(lines[0] ?? '') && lines[1]?.startsWith('stderr: '))) {
+            const refusal = read.isError === true ? text : lines.slice(1).join('\n').replace(/^stderr: /gm, '');
+            if (UNREADABLE.test(refusal))
+                return '';
+            throw new Error(refusal);
+        }
+        const cut = cutOf(lines);
+        document += lines.slice(cut === null ? 0 : 1).join('\n');
+        command = cut?.[2];
+    }
+    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 readHowWeWork(bridge)).replace(/\n$/, '')].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,69 +1,10 @@
 #!/usr/bin/env node
-import { setGlobalProxyFromEnv } from 'node:http';
-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 { 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 House Kit and ends your own agent's connection",
-            operands: 0,
-            run: logout,
-        },
-    ],
-    [
-        'resident',
-        {
-            usage: 'usage: kit resident',
-            about: "keeps this Environment connected; House 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);
-setGlobalProxyFromEnv();
-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`);
+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,6 +1,5 @@
 import { spawn } from 'node:child_process';
 import { createHash, randomBytes } from 'node:crypto';
-import { hostname } from 'node:os';
 import { parseArgs } from 'node:util';
 import { HouseRefusal, post, retrying } from './api.js';
 import { placeAppGit } from './app-git.js';
@@ -11,6 +10,7 @@ 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.
@@ -26,6 +26,7 @@ export async function accepted(house, credential) {
         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]
@@ -36,6 +37,13 @@ const USAGE = `usage: kit login [--house <origin>] [--environment <id>] [--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';
 }
@@ -81,15 +89,15 @@ export async function login(argv) {
     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 start = (named) => retrying(() => post(house, '/kit', {
-            label: hostname(),
+        const start = () => retrying(() => post(house, '/kit', {
             ...(named === undefined
                 ? { act: 'new_environment', ...(replaces === undefined ? {} : { replaces }) }
                 : { act: 'existing_environment', environment_id: named }),
@@ -99,20 +107,21 @@ export async function login(argv) {
         }));
         let started;
         try {
-            started = await start(environment);
+            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`);
-            started = await start(undefined);
+            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);
     }
-    await placeSkillSet();
+    await placeSkillSet(house);
     await writeCodexRule().catch((error) => process.stderr.write(`kit: ${error.message}\n`));
     const relayRecord = relay === undefined ? {} : { relay };
     await writeEnrolment({
@@ -121,7 +130,7 @@ export async function login(argv) {
         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, ...relayRecord, user: exchanged.user, credential: exchanged.headless_credential });
     }
@@ -132,7 +141,7 @@ export async function login(argv) {
     else if (held && ownAgent !== null) {
         await writeOwnAgent({ house, ...relayRecord, user: ownAgent.user, credential: ownAgent.credential });
     }
-    await placeAppGit(ownAgent, await readOwnAgent()).catch((error) => process.stderr.write(`kit: ${error.message}\n`));
+    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,