@agentshouse/kit 0.2.1-cb8dc89b78e07 → 0.2.1-cb997daca91ed

package/dist/files.js

@@ -1,42 +1,144 @@
-import { createHash } from 'node:crypto';
-import { mkdir, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { HouseRefusal, retrying } from './api.js';
+import { createHash, randomUUID } from 'node:crypto';
+import { createWriteStream } from 'node:fs';
+import { mkdir, rename, rm } from 'node:fs/promises';
+import { basename, dirname, join } from 'node:path';
+import { Readable, Transform } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { parseDocument } from 'yaml';
+import { retryDelay } from './api.js';
+import { Unsettled } from './mcp.js';
 import { relayed } from './relay.js';
-export function verified(bytes, sha256, name) {
-    if (createHash('sha256').update(bytes).digest('hex') !== sha256)
-        throw new Error(`${name} did not arrive whole; download it again`);
-    return bytes;
-}
-export async function placeFiles(house, directory, files, signal) {
-    const paths = [];
-    for (const file of files) {
-        const original = await retrying(() => house.post('/kit/conversation/originals/get', { version: file.version, download: true }, signal), signal);
-        const answer = await fetch(relayed(original.download.url), { signal });
-        if (!answer.ok)
-            throw new Error(`${file.name} did not download: ${answer.status}`);
-        const folder = join(directory, '.house', 'files', original.message, file.version);
-        await mkdir(join(directory, '.house')).catch((error) => {
-            if (error.code !== 'EEXIST')
+const STALLED_ROUNDS = 8;
+const PART_CHECKSUM = 'x-amz-checksum-sha256';
+const LINK = /\]\((\/rooms\/[^/)\s]+\/[^)\s]+)\)/gu;
+export function linkedPaths(text) {
+    return [...new Set(Array.from(text.matchAll(LINK), (link) => link[1]))];
+}
+export function inspectedFile(answer) {
+    const document = parseDocument(answer);
+    if (document.errors.length > 0)
+        return null;
+    const inspected = document.toJS();
+    if (typeof inspected?.download !== 'string')
+        return null;
+    return {
+        download: inspected.download,
+        sha256: String(inspected.sha256),
+        media_type: typeof inspected.media_type === 'string' ? inspected.media_type : null,
+    };
+}
+function paused(milliseconds) {
+    return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+export function storeRefusal(act, status) {
+    return new Error(`the ${act} answered ${status}; ${act} the file again`);
+}
+async function partDigests(uploading, partBytes) {
+    const whole = createHash('sha256');
+    const digests = [];
+    for (let start = 0; digests.length === 0 || start < uploading.bytes; start += partBytes) {
+        const end = Math.min(start + partBytes, uploading.bytes);
+        const digest = createHash('sha256');
+        for await (const chunk of uploading.read(start, end)) {
+            digest.update(chunk);
+            whole.update(chunk);
+        }
+        digests.push(digest.digest());
+    }
+    if (whole.digest('hex') !== uploading.sha256)
+        throw new Error(`${uploading.name} changed while it was uploaded; upload it again`);
+    return digests;
+}
+export async function uploaded(declared, uploading) {
+    const partBytes = declared.part_bytes;
+    const digests = await partDigests(uploading, partBytes);
+    const partSha256 = digests.map((digest) => digest.toString('hex'));
+    let answer = await finishing(uploading, declared.id, partSha256);
+    let idle = 0;
+    let stalled = 0;
+    while ('upload' in answer) {
+        const { id, parts } = answer.upload;
+        let sent = 0;
+        let failure = null;
+        for (const { part, url } of parts ?? []) {
+            const start = (part - 1) * partBytes;
+            try {
+                await uploading.send(url, start, Math.min(start + partBytes, uploading.bytes), {
+                    [PART_CHECKSUM]: digests[part - 1].toString('base64'),
+                });
+                sent++;
+            }
+            catch (error) {
+                failure = error;
+                break;
+            }
+        }
+        if (sent > 0) {
+            idle = 0;
+            stalled = 0;
+        }
+        else {
+            if (failure !== null && ++stalled >= STALLED_ROUNDS)
+                throw failure;
+            // A round that sent no part, its store unreachable, is followed by the next finishing call on the jittered curve.
+            await paused(retryDelay(idle++));
+        }
+        answer = await finishing(uploading, id, partSha256);
+    }
+    return answer;
+}
+async function finishing(uploading, upload, partSha256) {
+    for (let unsettled = 1;; unsettled++) {
+        try {
+            return await uploading.finish(upload, partSha256);
+        }
+        catch (error) {
+            if (!(error instanceof Unsettled) || unsettled === STALLED_ROUNDS)
                 throw error;
-        });
-        await mkdir(folder, { recursive: true });
-        const path = join(folder, file.name);
-        await writeFile(path, verified(Buffer.from(await answer.arrayBuffer()), file.sha256, file.name));
-        paths.push(path);
+        }
+        // A finishing call House did not settle, unreached or refused short of final, is sent again on the jittered curve as a conversation resends it, so a dropped connection or a House restart resumes the upload instead of ending it.
+        await paused(retryDelay(unsettled - 1));
     }
-    return paths;
-}
-export function uploadBytes(upload, bytes) {
-    return retrying(async () => {
-        const answer = await fetch(relayed(upload.url), {
-            method: 'POST',
-            headers: { 'content-type': 'application/octet-stream', 'x-house-byte-operation': upload.operation },
-            body: bytes,
+}
+async function drained(body) {
+    for await (const _chunk of body)
+        ;
+}
+export async function downloaded(address, fetching, destination, name) {
+    for (let asked = 1;; asked++) {
+        const { download, sha256 } = await address();
+        const answer = await fetching(download);
+        if (answer.status === 403 && asked === 1) {
+            await drained(answer.body);
+            continue;
+        }
+        if (answer.status !== 200) {
+            await drained(answer.body);
+            throw storeRefusal('download', answer.status);
+        }
+        await mkdir(dirname(destination), { recursive: true });
+        const partial = join(dirname(destination), `.${basename(destination)}.${randomUUID()}`);
+        const digest = createHash('sha256');
+        const hashed = new Transform({
+            transform(chunk, _encoding, done) {
+                digest.update(chunk);
+                done(null, chunk);
+            },
         });
-        const text = await answer.text();
-        if (!answer.ok)
-            throw new HouseRefusal(upload.url, answer.status, text);
-        return JSON.parse(text);
-    });
+        try {
+            await pipeline(answer.body, hashed, createWriteStream(partial, { flags: 'wx' }));
+            if (digest.digest('hex') !== sha256)
+                throw new Error(`${name} did not arrive whole; download it again`);
+            await rename(partial, destination);
+        }
+        catch (error) {
+            await rm(partial, { force: true });
+            throw error;
+        }
+        return;
+    }
+}
+export async function fetched(url, signal) {
+    const answer = await fetch(relayed(url), { signal });
+    return { status: answer.status, body: answer.body ?? Readable.from([]) };
 }

package/dist/git.js

@@ -2,16 +2,16 @@ import { spawn } from 'node:child_process';
 import { isUtf8 } from 'node:buffer';
 import { createHash } from 'node:crypto';
 import { join } from 'node:path';
-import { withoutProxy } from './clis.js';
 import { workspaceRoot } from './home.js';
+import { childEnvironment } from './relay.js';
 export function localCopies() {
     return join(workspaceRoot(), 'local-copies');
 }
 export const HOUSE_REF = 'refs/house/received';
-const COMMITTER = 'House Kit <house-kit@localhost>';
+const COMMITTER = 'Kit <house-kit@localhost>';
 export function run(cwd, args, input, env = {}) {
     return new Promise((resolve, reject) => {
-        const child = spawn('git', args, { cwd, env: { ...withoutProxy(), ...env } });
+        const child = spawn('git', args, { cwd, env: { ...childEnvironment(), ...env } });
         const stdout = [];
         let stderr = '';
         child.stdout.on('data', (chunk) => stdout.push(chunk));

package/dist/house-cli.js

@@ -1,14 +1,17 @@
 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 { createReadStream } from 'node:fs';
+import { request } from 'node:http';
+import { request as httpsRequest } from 'node:https';
+import { extname, join, resolve } from 'node:path';
+import { Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { downloaded, inspectedFile, storeRefusal, uploaded } from './files.js';
 import { HOUSE_REF } from './git.js';
 import { ownerSocket, 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';
+import { callHouse, rpc, UNREACHABLE, Unsettled } from './mcp.js';
+import { refusalOf, retryable } from './refusals.js';
+import { proxyUnlessRelayed, relayed, selectRelay } from './relay.js';
+import { parse } 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";
@@ -51,15 +54,12 @@ const MEDIA_TYPES = new Map([
     ['xlsx', 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'],
     ['zip', 'application/zip'],
 ]);
-function refused(path, method, status, text, local) {
+function refused(path, 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}`;
@@ -67,38 +67,37 @@ function refused(path, method, status, text, local) {
 function unconfirmed(status) {
     return `House answered ${status} ${UNCONFIRMED}`;
 }
-function exchanged(path, method, body, headers = { 'content-type': 'application/json' }, to = socketPath) {
+function bridged(path, body, to = socketPath) {
     return new Promise((resolve, reject) => {
-        const sent = request({ socketPath: to, path, method, headers }, (answer) => {
+        const sent = request({ socketPath: to, path, method: 'POST', headers: { 'content-type': 'application/json' } }, (answer) => {
             const chunks = [];
             answer.on('data', (chunk) => chunks.push(chunk));
             answer.on('end', () => {
-                const bytes = Buffer.concat(chunks);
+                const text = Buffer.concat(chunks).toString('utf8');
                 if (answer.statusCode === 200)
-                    resolve(bytes);
+                    resolve(text);
                 else
-                    reject(new Error(refused(path, method, answer.statusCode, bytes.toString('utf8'), answer.headers['content-type'] === undefined)));
+                    reject(new Error(refused(path, answer.statusCode, text, 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));
+        sent.end(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);
+        throw new Unsettled(UNREACHABLE);
     });
     if (answer.status === 200)
         return answer.text;
-    throw new Error(answer.status === 401 ? DISCONNECTED : (refusalOf(answer.text)?.text ?? unconfirmed(answer.status)));
+    if (answer.status === 401)
+        throw new Error(DISCONNECTED);
+    const refusal = refusalOf(answer.text)?.text ?? unconfirmed(answer.status);
+    throw retryable(answer.text) === false ? new Error(refusal) : new Unsettled(refusal);
 }
 async function mcp(method, params) {
     const message = rpc(method, params);
@@ -110,31 +109,43 @@ async function mcp(method, params) {
 async function tools() {
     return (await mcp('tools/list', {})).tools;
 }
-async function localFile(path) {
+function unreadable(path, error) {
+    return new Error(error.code === 'EISDIR'
+        ? `${path} is a folder; upload one file at a time`
+        : `${path} is not a readable file`);
+}
+function opened(url, method, headers, body) {
+    return new Promise((answered, failed) => {
+        const local = socketPath !== undefined;
+        const target = local ? null : relayed(url);
+        if (!local)
+            proxyUnlessRelayed();
+        const sent = target === null
+            ? request({ socketPath, path: url, method, headers }, answered)
+            : (target.protocol === 'https:' ? httpsRequest : request)(target, { method, headers }, answered);
+        sent.on('error', (error) => failed(new Error(!local ? UNREACHABLE : error.code === 'EPERM' || error.code === 'EACCES' ? SANDBOXED : CLOSED)));
+        if (body === undefined)
+            sent.end();
+        else
+            pipeline(body, sent).catch(() => undefined);
+    });
+}
+function ranged(file, start, end) {
+    return end === start ? undefined : createReadStream(file, { start, end: end - 1 });
+}
+async function* read(file, start, end) {
     try {
-        return await readFile(path);
+        yield* ranged(file, start, end) ?? [];
     }
     catch (error) {
-        throw new Error(error.code === 'EISDIR'
-            ? `${path} is a folder; upload one file at a time`
-            : `${path} is not a readable file`);
+        throw unreadable(file, error);
     }
 }
-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 sentPart(url, file, start, end, headers) {
+    const answer = await opened(url, 'PUT', { ...headers, 'content-length': String(end - start) }, ranged(file, start, end));
+    await answer.toArray();
+    if (answer.statusCode !== 200)
+        throw storeRefusal('upload', answer.statusCode);
 }
 async function download(args) {
     const { flags, positionals: [argument] } = accepted(args, ['--help'], 1, DOWNLOAD_USAGE);
@@ -143,58 +154,55 @@ async function download(args) {
     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);
+    await downloaded(async () => {
+        const file = inspectedFile(await called('inspect', selected));
+        if (file === null)
+            throw new Error(`${String(selected.path)} holds no binary file; shell reads its text`);
+        return file;
+    }, async (url) => {
+        const answer = await opened(url, 'GET', {});
+        return { status: answer.statusCode, body: answer };
+    }, written, String(selected.path));
     return written;
 }
 async function described(file) {
-    const bytes = await localFile(file);
+    const digest = createHash('sha256');
+    let bytes = 0;
+    try {
+        for await (const chunk of createReadStream(file)) {
+            digest.update(chunk);
+            bytes += chunk.length;
+        }
+    }
+    catch (error) {
+        throw unreadable(file, error);
+    }
     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 }),
-        },
-    };
+    return { bytes, sha256: digest.digest('hex'), ...(mediaType === undefined ? {} : { media_type: mediaType }) };
+}
+async function finished(upload, room, partSha256) {
+    const text = await called('upload', { upload, room_ref: room, part_sha256: partSha256 });
+    const answer = parse(text);
+    return answer !== null && 'upload' in answer ? answer : { text };
 }
 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 description = await described(file);
     const answer = await called('upload', { ...destination, ...description });
     const declared = parse(answer);
-    if (declared.upload === undefined)
+    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);
-    }
+    const accepted = await uploaded(declared.upload, {
+        name: file,
+        bytes: description.bytes,
+        sha256: description.sha256,
+        read: (start, end) => read(file, start, end),
+        send: (url, start, end, headers) => sentPart(url, file, start, end, headers),
+        finish: (id, partSha256) => finished(id, destination.room_ref, partSha256),
+    });
+    return accepted.text;
 }
 function unexpected(argument, usage) {
     return new Error(`unexpected argument ${argument}; ${usage}`);
@@ -220,7 +228,7 @@ async function push(args) {
         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 ? ownerSocket() : socketPath));
+    const pushed = JSON.parse(await bridged('/git/push', { cwd: process.cwd(), commit }, owner ? ownerSocket() : socketPath));
     if (pushed.refused)
         throw new Error(pushed.text);
     return pushed.text;
@@ -228,7 +236,7 @@ async function push(args) {
 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 ?? ownerSocket()));
+    const answer = JSON.parse(await bridged('/git/fetch', {}, socketPath ?? ownerSocket()));
     if (answer.refused)
         throw new Error(answer.text);
     return answer.text;
@@ -263,7 +271,7 @@ async function house(args) {
         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);
+    return verb === 'upload' ? upload(parsed) : called(verb, parsed);
 }
 async function called(name, args) {
     const result = await mcp('tools/call', { name, arguments: args });

package/dist/house-main.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
-const [major = 0, minor = 0] = process.versions.node.split('.').map(Number);
-if (major < 24 || (major === 24 && minor < 14)) {
-    process.stderr.write(`house: the Kit needs Node 24.14.0 or newer; this is ${process.versions.node}\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(`house: the Kit needs Node 24.22.1 or newer; this is ${process.versions.node}\n`);
     process.exitCode = 1;
 }
 else {

package/dist/instructions.js

@@ -1,12 +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 REQUEST_LINE = "For another Agent's help, `send_routine_request`; its mail comes back into this conversation. If an Agent of your User has no Routine to call, write one in the Private Room and `create_routine_access` with your User as its only caller.";
-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, REQUEST_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

@@ -1,9 +1,9 @@
-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 { proxyUnlessRelayed } from './relay.js';
 import { resident } from './resident.js';
 const USAGE = 'usage: kit <login|logout|resident|chatgpt>\n';
 const COMMANDS = new Map([
@@ -11,7 +11,7 @@ const COMMANDS = new Map([
         'logout',
         {
             usage: 'usage: kit logout',
-            about: "disconnects this computer, stops House Kit and ends your own agent's connection",
+            about: "disconnects this computer, stops the Kit process and ends your own agent's connection",
             operands: 0,
             run: logout,
         },
@@ -20,7 +20,7 @@ const COMMANDS = new Map([
         'resident',
         {
             usage: 'usage: kit resident',
-            about: "keeps this Environment connected; House Kit's service runs it",
+            about: "keeps this Environment connected; Kit's service runs it",
             operands: 0,
             run: resident,
         },
@@ -36,7 +36,7 @@ const COMMANDS = new Map([
     ],
 ]);
 const [command, ...argv] = process.argv.slice(2);
-setGlobalProxyFromEnv();
+proxyUnlessRelayed();
 async function run() {
     if (command === 'login')
         return login(argv);

package/dist/kit-main.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
-const [major = 0, minor = 0] = process.versions.node.split('.').map(Number);
-if (major < 24 || (major === 24 && minor < 14)) {
-    process.stderr.write(`kit: the Kit needs Node 24.14.0 or newer; this is ${process.versions.node}\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 {

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';
@@ -91,13 +90,12 @@ export async function login(argv) {
     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 = () => retrying(() => post(house, '/kit', {
-            label: hostname(),
             ...(named === undefined
                 ? { act: 'new_environment', ...(replaces === undefined ? {} : { replaces }) }
                 : { act: 'existing_environment', environment_id: named }),
@@ -121,7 +119,7 @@ export async function login(argv) {
         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({

package/dist/mcp.js

@@ -1,8 +1,10 @@
 import { randomUUID } from 'node:crypto';
-import { KIT_VERSION } from './clis.js';
+import { KIT_RELEASE } from './clis.js';
 import { relayed } from './relay.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 +15,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 }),
             },