@agentshouse/kit 0.2.1-c845e172df1af → 0.2.1-c849d8d4ab62f

package/dist/events.js

@@ -1,8 +1,13 @@
+const AUTONOMOUS_ORIGINS = new Set(['task-notification', 'peer', 'coordinator', 'observer', 'observer-activity']);
 const COMMAND = { shown: 'command' };
 const HIDDEN = { shown: 'hidden' };
 const FINISHED = new Set(['completed', 'failed']);
 export const RUNNING_JOB = new Set(['running', 'paused']);
-const MESSAGE_TARGETS = { send_routine_request: 'access', cancel_routine_request: 'request', send_mail: 'request' };
+const MESSAGE_TARGETS = new Map([
+    ['send_routine_request', ['routine', 'agent']],
+    ['cancel_routine_request', ['request']],
+    ['send_mail', ['conversation', 'request']],
+]);
 function words(line) {
     const found = [];
     let word = null;
@@ -48,11 +53,13 @@ export function houseMessage(line) {
     catch {
         return null;
     }
-    const argument = MESSAGE_TARGETS[call.command];
-    if (argument === undefined)
+    if (call === null)
         return null;
-    const target = call.arguments?.[argument];
-    return { shown: 'message', command: call.command, target: typeof target === 'string' ? target : null };
+    const targets = MESSAGE_TARGETS.get(call.command);
+    if (targets === undefined)
+        return null;
+    const target = targets.map((argument) => call.arguments?.[argument]).find((value) => typeof value === 'string');
+    return { shown: 'message', command: call.command, target: target ?? null };
 }
 function decidedByLine(command, final) {
     const line = typeof command === 'string' ? command : Array.isArray(command) ? command.at(-1) : undefined;
@@ -269,6 +276,7 @@ class Reader {
 class ClaudeReader extends Reader {
     watchedOptions = { model: 'model' };
     tasks = new Map();
+    stop = null;
     own(message) {
         if (message.params?.update?._meta?.claudeCode?.parentToolUseId !== undefined)
             return [];
@@ -276,7 +284,9 @@ class ClaudeReader extends Reader {
     }
     update(update) {
         if (update.sessionUpdate === 'usage_update' && update._meta?.['_claude/origin'] !== undefined) {
-            return [...super.update(update), { kind: 'ended' }];
+            const stop = this.stop;
+            this.stop = null;
+            return [...super.update(update), { kind: 'ended', stop }];
         }
         if (update.sessionUpdate === 'session_info_update' && update._meta?.jetbrains?.air?.sessionFailure !== undefined) {
             return [{ kind: 'marker', marker: 'retry', text: update._meta.jetbrains.air.sessionFailure.title }];
@@ -287,6 +297,13 @@ class ClaudeReader extends Reader {
         if (message.method !== '_claude/sdkMessage')
             return [];
         const sdk = message.params.message;
+        if (sdk.type === 'result') {
+            if (AUTONOMOUS_ORIGINS.has(sdk.origin?.kind))
+                this.stop = null;
+            else
+                this.stop = sdk.stop_reason === 'refusal' ? 'refusal' : sdk.is_error === true ? null : 'end_turn';
+            return [];
+        }
         switch (sdk.subtype) {
             case 'task_started':
                 if (sdk.tool_use_id !== undefined)
@@ -294,6 +311,10 @@ class ClaudeReader extends Reader {
                 return [];
             case 'task_notification':
                 return sdk.tool_use_id === undefined ? [] : this.finish(sdk.tool_use_id, sdk.summary ?? null);
+            case 'task_progress':
+                if (!this.subagents.has(sdk.tool_use_id) || this.done.has(sdk.tool_use_id) || typeof sdk.description !== 'string')
+                    return [];
+                return [{ kind: 'subagent-activity', id: sdk.tool_use_id, activity: sdk.description }];
             default:
                 return [];
         }
@@ -356,7 +377,7 @@ class CodexReader extends Reader {
                 if (codex?.threadStatus?.type === 'active')
                     return [{ kind: 'started' }];
                 if (codex?.threadStatus?.type === 'idle')
-                    return [{ kind: 'ended' }];
+                    return [{ kind: 'ended', stop: null }];
                 if (codex?.error !== undefined)
                     return [{ kind: 'marker', marker: 'retry', text: codex.error.message ?? '' }];
                 return [];
@@ -429,7 +450,7 @@ class GrokReader extends Reader {
             return (message.params.runningPromptId ?? null) !== null && session === this.session ? [{ kind: 'started' }] : [];
         }
         if (message.params?.update?.sessionUpdate === 'turn_completed') {
-            return session === this.session ? [{ kind: 'ended' }] : [];
+            return session === this.session ? [{ kind: 'ended', stop: null }] : [];
         }
         if (message.method === '_x.ai/models/update') {
             this.offered(message.params);

package/dist/files.js

@@ -4,27 +4,68 @@ 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 { retrying, retryDelay } from './api.js';
+import { parseDocument } from 'yaml';
+import { retryDelay } from './api.js';
 import { Unsettled } from './mcp.js';
 import { relayed } from './relay.js';
 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) {
-    let upload = declared;
+    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;
-    for (;;) {
+    while ('upload' in answer) {
+        const { id, parts } = answer.upload;
         let sent = 0;
         let failure = null;
-        for (const { part, url } of upload.parts) {
-            const start = (part - 1) * upload.part_bytes;
+        for (const { part, url } of parts ?? []) {
+            const start = (part - 1) * partBytes;
             try {
-                await uploading.send(url, start, Math.min(start + upload.part_bytes, uploading.bytes));
+                await uploading.send(url, start, Math.min(start + partBytes, uploading.bytes), {
+                    [PART_CHECKSUM]: digests[part - 1].toString('base64'),
+                });
                 sent++;
             }
             catch (error) {
@@ -39,24 +80,17 @@ export async function uploaded(declared, uploading) {
         else {
             if (failure !== null && ++stalled >= STALLED_ROUNDS)
                 throw failure;
-            // A round that sent no part, its store unreachable or not yet started, is followed by the next finishing call on the jittered curve.
+            // A round that sent no part, its store unreachable, is followed by the next finishing call on the jittered curve.
             await paused(retryDelay(idle++));
         }
-        let answer = await finishing(uploading, upload.id);
-        while ('checking' in answer) {
-            // A finishing call that finds House still checking the stored bytes is sent again after five seconds, the cadence at which House takes up a check it handed over.
-            await paused(5_000);
-            answer = await finishing(uploading, upload.id);
-        }
-        if (!('upload' in answer))
-            return answer;
-        upload = answer.upload;
+        answer = await finishing(uploading, id, partSha256);
     }
+    return answer;
 }
-async function finishing(uploading, upload) {
+async function finishing(uploading, upload, partSha256) {
     for (let unsettled = 1;; unsettled++) {
         try {
-            return await uploading.finish(upload);
+            return await uploading.finish(upload, partSha256);
         }
         catch (error) {
             if (!(error instanceof Unsettled) || unsettled === STALLED_ROUNDS)
@@ -104,28 +138,7 @@ export async function downloaded(address, fetching, destination, name) {
         return;
     }
 }
-async function fetched(url, signal) {
+export async function fetched(url, signal) {
     const answer = await fetch(relayed(url), { signal });
     return { status: answer.status, body: answer.body ?? Readable.from([]) };
 }
-export async function placeFiles(house, directory, files, signal) {
-    const paths = [];
-    for (const file of files) {
-        const original = () => retrying(() => house.post('/kit/conversation/originals/get', { version: file.version, download: true }, signal), signal);
-        let first = await original();
-        const folder = join(directory, '.house', 'files', first.message, file.version);
-        await mkdir(join(directory, '.house')).catch((error) => {
-            if (error.code !== 'EEXIST')
-                throw error;
-        });
-        await mkdir(folder, { recursive: true });
-        const path = join(folder, file.name);
-        await downloaded(async () => {
-            const answered = first ?? (await original());
-            first = null;
-            return { download: answered.download.url, sha256: file.sha256 };
-        }, (url) => fetched(url, signal), path, file.name);
-        paths.push(path);
-    }
-    return paths;
-}

package/dist/git.js

@@ -2,8 +2,8 @@ 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');
 }
@@ -11,7 +11,7 @@ export const HOUSE_REF = 'refs/house/received';
 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,17 +1,16 @@
 import { createHash } from 'node:crypto';
 import { createReadStream } from 'node:fs';
-import { readFile } from 'node:fs/promises';
-import { request, setGlobalProxyFromEnv } from 'node:http';
+import { request } from 'node:http';
 import { request as httpsRequest } from 'node:https';
-import { basename, extname, join, resolve } from 'node:path';
+import { extname, join, resolve } from 'node:path';
 import { Readable } from 'node:stream';
 import { pipeline } from 'node:stream/promises';
-import { downloaded, storeRefusal, uploaded } from './files.js';
+import { downloaded, inspectedFile, storeRefusal, uploaded } from './files.js';
 import { HOUSE_REF } from './git.js';
 import { ownerSocket, readOwnAgent } from './home.js';
 import { callHouse, rpc, UNREACHABLE, Unsettled } from './mcp.js';
 import { refusalOf, retryable } from './refusals.js';
-import { relayed, selectRelay } from './relay.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]';
@@ -90,7 +89,6 @@ async function direct(message) {
     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 Unsettled(UNREACHABLE);
     });
@@ -116,43 +114,35 @@ function unreadable(path, error) {
         ? `${path} is a folder; upload one file at a time`
         : `${path} is not a readable file`);
 }
-async function localFile(path) {
-    try {
-        return await readFile(path);
-    }
-    catch (error) {
-        throw unreadable(path, error);
-    }
-}
 function opened(url, method, headers, body) {
     return new Promise((answered, failed) => {
         const local = socketPath !== undefined;
         const target = local ? null : relayed(url);
         if (!local)
-            setGlobalProxyFromEnv();
+            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 instanceof Readable)
-            pipeline(body, sent).catch(() => undefined);
+        if (body === undefined)
+            sent.end();
         else
-            sent.end(body);
+            pipeline(body, sent).catch(() => undefined);
     });
 }
-async function textOf(answer) {
-    return Buffer.concat(await answer.toArray()).toString('utf8');
+function ranged(file, start, end) {
+    return end === start ? undefined : createReadStream(file, { start, end: end - 1 });
 }
-async function sent(url, bytes, operation) {
-    const headers = { 'content-type': 'application/octet-stream', 'x-house-byte-operation': operation };
-    const answer = await opened(url, 'POST', headers, bytes);
-    const text = await textOf(answer);
-    if (answer.statusCode === 200)
-        return text;
-    throw new Error(refusalOf(text)?.text ?? storeRefusal('upload', answer.statusCode).message);
+async function* read(file, start, end) {
+    try {
+        yield* ranged(file, start, end) ?? [];
+    }
+    catch (error) {
+        throw unreadable(file, error);
+    }
 }
-async function sentPart(url, file, start, end) {
-    const answer = await opened(url, 'PUT', { 'content-length': String(end - start) }, end === start ? undefined : createReadStream(file, { start, end: end - 1 }));
+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);
@@ -166,10 +156,10 @@ async function download(args) {
         throw new Error('download needs "file", the local file to write');
     const written = resolve(file);
     await downloaded(async () => {
-        const inspected = parse(await called('inspect', selected));
-        if (typeof inspected?.download !== 'string')
+        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 { download: inspected.download, sha256: String(inspected.sha256) };
+        return file;
     }, async (url) => {
         const answer = await opened(url, 'GET', {});
         return { status: answer.statusCode, body: answer };
@@ -191,10 +181,10 @@ async function described(file) {
     const mediaType = MEDIA_TYPES.get(extname(file).slice(1).toLowerCase());
     return { bytes, sha256: digest.digest('hex'), ...(mediaType === undefined ? {} : { media_type: mediaType }) };
 }
-async function finished(upload, room) {
-    const text = await called('upload', { upload, room_ref: room });
+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 || 'checking' in answer) ? answer : { text };
+    return answer !== null && 'upload' in answer ? answer : { text };
 }
 async function upload({ file, ...destination }) {
     if (typeof file !== 'string' || file === '')
@@ -205,33 +195,15 @@ async function upload({ file, ...destination }) {
     if (declared?.upload === undefined)
         return answer;
     const accepted = await uploaded(declared.upload, {
+        name: file,
         bytes: description.bytes,
-        send: (url, start, end) => sentPart(url, file, start, end),
-        finish: (id) => finished(id, destination.room_ref),
+        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;
 }
-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 description = await described(attachment);
-            held.set(description.sha256, attachment);
-            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, await localFile(held.get(grant.sha256)), grant.operation);
-    }
-}
 function unexpected(argument, usage) {
     return new Error(`unexpected argument ${argument}; ${usage}`);
 }
@@ -299,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([
@@ -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';
@@ -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]
@@ -91,13 +92,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 +121,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,6 +1,7 @@
 import { randomUUID } from 'node:crypto';
 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 {
@@ -33,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/relay.js

@@ -1,6 +1,11 @@
+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();
 }
 export function relayOrigin() {
     if (selected !== undefined)
@@ -8,6 +13,22 @@ export function relayOrigin() {
     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();