@agentshouse/kit 0.2.1-ca0e1517cce79 → 0.2.1-ca1f38641026d

package/dist/conversations.js

@@ -1,9 +1,9 @@
-import { client, RequestError, } from '@agentclientprotocol/sdk';
+import { client, } from '@agentclientprotocol/sdk';
 import { createHash, randomUUID } from 'node:crypto';
 import { mkdir } from 'node:fs/promises';
 import { join } from 'node:path';
 import { unlessAborted } from './abort.js';
-import { startAdapter } from './acp.js';
+import { signedOut, startAdapter } from './acp.js';
 import { finalRefusal, HouseRefusal } from './api.js';
 import { openBridge } from './bridge.js';
 import { CLIS } from './clis.js';
@@ -18,7 +18,6 @@ import { killMarked, Scope } from './scope.js';
 import { holdSecretInput } from './secret-input.js';
 import { transcribe } from './transcription.js';
 import { workFor } from './work.js';
-const SIGNED_OUT = RequestError.authRequired().code;
 const KILLED = 'the conversation was killed';
 const INTERRUPTED = 'the conversation was interrupted';
 const REFUSED = 'the CLI refused the prompt';
@@ -34,6 +33,7 @@ const NO_SESSION = "the Agent's CLI did not open a session";
 const NO_RESUME = "the Agent's CLI could not resume this conversation";
 const NOT_SIGNED_IN = "the Agent's CLI is not signed in; sign it in on the Agent's machine";
 const NO_SETTINGS = "the Agent's CLI refused the Agent's model, mode or effort";
+const UNSTEERED = "the Agent's CLI did not take the message into its running turn";
 class NotStarted extends Error {
 }
 class ResumeRefused extends NotStarted {
@@ -46,9 +46,6 @@ async function step(reason, work) {
         throw new NotStarted(typeof reason === 'string' ? reason : reason(error), { cause: error });
     }
 }
-function signedOut(error) {
-    return typeof error === 'object' && error !== null && error.code === SIGNED_OUT;
-}
 function unopened(reason) {
     return (error) => (signedOut(error) ? NOT_SIGNED_IN : reason);
 }
@@ -65,7 +62,7 @@ const EXIT_PLAN_MODE = {
         return value;
     },
 };
-export const CONVERSATION_METHODS = new Set(['open', 'message', 'interrupt', 'kill', 'option', 'answer']);
+export const CONVERSATION_METHODS = new Set(['open', 'message', 'interrupt', 'kill', 'done', 'option', 'answer']);
 function causeOf(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -73,7 +70,9 @@ function answeredWith(error) {
     return { failure: signedOut(error) ? 'signed_out' : 'error', cause: causeOf(error) };
 }
 function exitedWith(running, cause) {
-    return running.killed ? { failure: 'killed', cause: KILLED } : { failure: 'exited', cause };
+    if (running.killed)
+        return { failure: 'killed', cause: KILLED };
+    return { failure: running.adapter.silent() ? 'silent' : 'exited', cause };
 }
 function answerMessage(request, response) {
     return `The User answered a question you asked earlier.\nQuestion: ${JSON.stringify(request)}\nAnswer: ${JSON.stringify(response)}`;
@@ -103,12 +102,16 @@ function audioOf(result) {
 function marker(bridge) {
     return `HOUSE_BRIDGE=${bridge.env.HOUSE_BRIDGE}`;
 }
+function steers(adapter) {
+    return adapter.initialized._meta?.steering?.supported === true;
+}
 class Turn {
     id = randomUUID();
     parts;
     questions = 0;
     secrets = 0;
     prompted = false;
+    steered = false;
     taken = null;
     ended = false;
     images = 0;
@@ -128,6 +131,7 @@ class Conversation {
     context = null;
     leftovers = new Set();
     waiting = [];
+    done = false;
     sending = null;
     subagents = new Map();
     held = [];
@@ -139,7 +143,7 @@ class Conversation {
     killed = new AbortController();
     interrupts = 0;
     interrupted = new AbortController();
-    open = 0;
+    turns = new Set();
     queue = Promise.resolve();
     reports = Promise.resolve();
     starting = null;
@@ -195,7 +199,7 @@ export class Conversations {
         for (const conversation of this.conversations.values()) {
             const turn = conversation.turn;
             const asking = turn !== null && turn.questions > 0 && turn.secrets === 0;
-            if (conversation.open > (asking ? 1 : 0))
+            if (conversation.turns.size > (asking ? 1 : 0))
                 return false;
         }
         const conversations = [...this.conversations.values()];
@@ -204,7 +208,7 @@ export class Conversations {
         return !conversations.some((conversation) => conversation.running?.scope.working() || [...conversation.leftovers].some((scope) => scope.working()));
     }
     quiet() {
-        return this.idle() && [...this.conversations.values()].every((conversation) => conversation.open === 0);
+        return this.idle() && [...this.conversations.values()].every((conversation) => conversation.turns.size === 0);
     }
     look() {
         for (const conversation of this.conversations.values()) {
@@ -220,8 +224,10 @@ export class Conversations {
     opened() {
         this.watched = false;
         for (const conversation of this.conversations.values()) {
-            if (conversation.running !== null)
+            if (conversation.running !== null) {
                 this.facts(conversation);
+                this.subagentsChanged(conversation);
+            }
             else if (conversation.exitUntold)
                 this.process(conversation, false);
             if (conversation.untold || conversation.told !== null)
@@ -248,9 +254,14 @@ export class Conversations {
     }
     async carry(conversation, call) {
         if (call.kind === 'open')
-            return { result: this.open(conversation, call) };
+            return this.open(conversation, call);
         if (call.kind === 'message')
             return this.message(conversation, call);
+        if (call.kind === 'done') {
+            conversation.done = true;
+            this.next(conversation);
+            return { result: Promise.resolve({}) };
+        }
         await this.launched(conversation);
         if (call.kind === 'interrupt') {
             if (--conversation.interrupts === 0)
@@ -275,11 +286,17 @@ export class Conversations {
         }
         return { result: Promise.resolve({}) };
     }
-    open(conversation, call) {
-        if (conversation.running !== null)
-            return Promise.resolve({});
+    async open(conversation, call) {
+        await this.stop(conversation);
         const launch = conversation.launch ?? this.launch(conversation, this.route(conversation, call.agent_id), null, true);
-        return launch.session.then((session) => ({ provider_session_id: session }), (error) => ({ refused: refusal(conversation, error) }));
+        return {
+            result: launch.session.then((session) => ({ provider_session_id: session }), (error) => ({ refused: refusal(conversation, error) })),
+        };
+    }
+    async stop(conversation) {
+        const running = conversation.running;
+        running?.scope.kill();
+        await running?.adapter.exited;
     }
     launch(conversation, route, sessionId, empty) {
         let opened;
@@ -318,7 +335,10 @@ export class Conversations {
         return read;
     }
     async message(conversation, call) {
-        const content = [{ type: 'text', text: String(call.text) }];
+        const content = [
+            ...(typeof call.recent === 'string' ? [{ type: 'text', text: call.recent }] : []),
+            { type: 'text', text: String(call.text) },
+        ];
         let route;
         let instructing = null;
         try {
@@ -336,21 +356,71 @@ export class Conversations {
             return { result: Promise.resolve({ refused: refusal(conversation, error) }) };
         }
         conversation.preparing = null;
-        return {
-            result: new Promise((settle) => {
-                conversation.waiting.push({ call, route, content, instructing, settle });
-                this.next(conversation);
-            }),
-        };
+        const { promise, resolve: settle } = Promise.withResolvers();
+        const waiting = { call, route, content, instructing, settle };
+        if (call.at_once === true && conversation.turns.size > 0)
+            await this.atOnce(conversation, waiting);
+        else
+            conversation.waiting.push(waiting);
+        this.next(conversation);
+        return { result: promise };
+    }
+    async atOnce(conversation, waiting) {
+        while (conversation.sending !== null)
+            await conversation.sending;
+        const running = conversation.running;
+        if (running !== null && conversation.turns.size > 0 && steers(running.adapter)) {
+            conversation.sending = this.steer(conversation, running, waiting);
+            await conversation.sending;
+            conversation.sending = null;
+            return;
+        }
+        this.ahead(conversation, waiting);
+        if (conversation.turns.size > 0)
+            await this.cancel(conversation);
+    }
+    ahead(conversation, waiting) {
+        const behind = conversation.waiting.findIndex((held) => held.call.at_once !== true);
+        conversation.waiting.splice(behind === -1 ? conversation.waiting.length : behind, 0, waiting);
+    }
+    async steer(conversation, running, waiting) {
+        let outcome;
+        try {
+            ({ outcome } = await running.adapter.connection.agent.request('_session/steering', {
+                sessionId: running.sessionId,
+                prompt: waiting.content,
+                _meta: { steering: { idleBehavior: 'promptRequired' } },
+            }));
+        }
+        catch (error) {
+            outcome = error;
+        }
+        if (outcome === 'promptRequired') {
+            this.ahead(conversation, waiting);
+        }
+        else if (outcome === 'injected' || outcome === 'startedNewTurn') {
+            if (outcome === 'injected') {
+                for (const turn of conversation.turns)
+                    turn.steered ||= turn.prompted;
+            }
+            this.kit.calls.keepResult(String(waiting.call.input_id), {});
+            waiting.settle({});
+        }
+        else {
+            const cause = outcome instanceof Error ? outcome : new Error(`the CLI answered ${JSON.stringify(outcome)}`);
+            waiting.settle({ refused: refusal(conversation, new NotStarted(UNSTEERED, { cause })) });
+        }
     }
     next(conversation) {
-        if (conversation.sending !== null || conversation.open > 0)
+        if (conversation.sending !== null || conversation.turns.size > 0)
             return;
         const waiting = conversation.waiting.shift();
         if (waiting === undefined) {
             const step = conversation.preparing ?? (conversation.launch === null ? null : 'session');
             if (conversation.starting !== step)
                 this.starts(conversation, step);
+            if (conversation.done && conversation.launch === null)
+                void this.stop(conversation).catch(logged);
             return;
         }
         conversation.sending = this.send(conversation, waiting).finally(() => {
@@ -491,7 +561,11 @@ export class Conversations {
         void bridging.then((bridge) => bridge.close(), () => undefined);
     }
     async interrupt(conversation, turnId) {
-        if (conversation.running === null || conversation.turn?.id !== turnId)
+        if ([...conversation.turns].some((turn) => turn.id === turnId))
+            await this.cancel(conversation);
+    }
+    async cancel(conversation) {
+        if (conversation.running === null)
             return;
         await conversation.running.adapter.connection.agent.notify('session/cancel', {
             sessionId: conversation.running.sessionId,
@@ -585,6 +659,7 @@ export class Conversations {
             const options = await step(NO_SETTINGS, this.launchSettings(running, route, opened.configOptions ?? []));
             void work.settled().then(() => scope.record());
             conversation.running = running;
+            adapter.turn(conversation.turns.size > 0);
             conversation.session = running.sessionId;
             conversation.options = options;
             this.facts(conversation);
@@ -651,6 +726,10 @@ export class Conversations {
         conversation.running = null;
         conversation.commands = null;
         conversation.options = null;
+        if (conversation.subagents.size > 0) {
+            conversation.subagents.clear();
+            this.subagentsChanged(conversation);
+        }
         for (const [id, question] of this.questions) {
             if (question.conversation === conversation)
                 this.questions.delete(id);
@@ -667,6 +746,10 @@ export class Conversations {
         if (conversation.options !== null)
             this.options(conversation, conversation.options);
     }
+    subagentsChanged(conversation) {
+        const subagents = [...conversation.subagents.values()].map(({ description, activity }) => ({ description, activity }));
+        this.kit.send({ type: 'subagents', conversation_id: conversation.id, subagents });
+    }
     commands(conversation, commands) {
         conversation.commands = commands;
         if (conversation.running === null)
@@ -701,7 +784,8 @@ export class Conversations {
     }
     begin(conversation) {
         const turn = new Turn((operation) => this.write(conversation, turn, operation));
-        conversation.open++;
+        conversation.turns.add(turn);
+        conversation.running?.adapter.turn(true);
         void this.deliver(conversation, turn, 'started', {}).catch(logged);
         conversation.turn = turn;
         if (conversation.context !== null)
@@ -723,7 +807,8 @@ export class Conversations {
         if (notice !== null)
             turn.parts.start({ type: 'marker', marker: 'retry', text: notice });
         turn.ended = true;
-        conversation.open--;
+        conversation.turns.delete(turn);
+        conversation.running?.adapter.turn(conversation.turns.size > 0);
         if (conversation.turn === turn)
             conversation.turn = null;
         const body = Promise.allSettled(turn.uploads).then(() => ({
@@ -756,7 +841,7 @@ export class Conversations {
             }
             else {
                 this.took(turn);
-                if (conversation.open === 1 && conversation.running === running) {
+                if (conversation.turns.size === 1 && conversation.turns.has(turn) && conversation.running === running) {
                     running.adapter.retire();
                     this.detach(conversation, running);
                 }
@@ -769,19 +854,22 @@ export class Conversations {
         this.took(turn);
         return turn;
     }
-    ended(conversation) {
+    ended(conversation, stop) {
         const turn = conversation.turn;
         if (turn === null)
             return;
-        if (!turn.prompted) {
-            this.end(conversation, turn, null);
-        }
-        else {
-            for (const event of conversation.running?.reader.closeTurn() ?? [])
-                this.apply(conversation, turn, event);
-            conversation.turn = null;
-            this.kit.changed();
+        const held = stop !== null && !turn.steered && [...conversation.subagents.values()].some((subagent) => subagent.turn === turn);
+        if (!turn.prompted || held) {
+            this.took(turn);
+            this.end(conversation, turn, stop === 'refusal' ? { failure: 'refused', cause: REFUSED } : null);
+            return;
         }
+        if (stop !== null)
+            return;
+        for (const event of conversation.running?.reader.closeTurn() ?? [])
+            this.apply(conversation, turn, event);
+        conversation.turn = null;
+        this.kit.changed();
     }
     async ask(conversation, method, params, secret, signal) {
         const turn = this.started(conversation);
@@ -837,7 +925,7 @@ export class Conversations {
                 this.started(conversation);
                 return;
             case 'ended':
-                this.ended(conversation);
+                this.ended(conversation, event.stop);
                 return;
             case 'commands':
                 this.commands(conversation, event.commands);
@@ -852,6 +940,9 @@ export class Conversations {
             case 'subagent-done':
                 this.subagentDone(conversation, event.id, event.result);
                 return;
+            case 'subagent-activity':
+                this.subagentActivity(conversation, event.id, event.activity);
+                return;
             case 'marker':
             case 'image':
                 if (conversation.turn !== null)
@@ -878,7 +969,8 @@ export class Conversations {
                 return;
             case 'subagent': {
                 const index = turn.parts.start({ type: 'subagent', description: event.description, status: 'running', result: null });
-                conversation.subagents.set(event.id, { description: event.description, turn, index });
+                conversation.subagents.set(event.id, { description: event.description, turn, index, activity: null });
+                this.subagentsChanged(conversation);
                 return;
             }
             case 'message':
@@ -901,6 +993,7 @@ export class Conversations {
         if (subagent === undefined)
             return;
         conversation.subagents.delete(id);
+        this.subagentsChanged(conversation);
         if (subagent.turn === conversation.turn) {
             subagent.turn.parts.done(subagent.index, result);
             return;
@@ -911,6 +1004,13 @@ export class Conversations {
         else
             conversation.turn.parts.start(part);
     }
+    subagentActivity(conversation, id, activity) {
+        const subagent = conversation.subagents.get(id);
+        if (subagent === undefined || subagent.activity === activity)
+            return;
+        subagent.activity = activity;
+        this.subagentsChanged(conversation);
+    }
     async image(conversation, turn, reserved, data, mediaType) {
         const bytes = Buffer.from(data, 'base64');
         const name = `image-${++turn.images}.${mediaType.split('/')[1]}`;

package/dist/end.js

@@ -14,9 +14,15 @@ export function end(reason) {
 export function restart(reason) {
     exit(reason, 1);
 }
-export function updateRequired() {
+function updateLine(lead) {
     const command = installCommand();
-    end(command === null ? 'This Kit is too old for House; install it again.' : `This Kit is too old for House. Update it: ${command}`);
+    return command === null ? `${lead}; install it again.` : `${lead}. Update it: ${command}`;
+}
+export function updateRequired() {
+    end(updateLine('This Kit is too old for House'));
+}
+export function unknownMethod(kind) {
+    return updateLine(`This Kit does not know ${kind}`);
 }
 export function newerThanHouse(release, command) {
     end(`Kit ${KIT_RELEASE} is newer than this Building supports (Kit ${release}). Install Kit ${release}: ${command}`);

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/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,6 +1,6 @@
 import { createHash } from 'node:crypto';
 import { createReadStream } from 'node:fs';
-import { request, setGlobalProxyFromEnv } from 'node:http';
+import { request } from 'node:http';
 import { request as httpsRequest } from 'node:https';
 import { extname, join, resolve } from 'node:path';
 import { Readable } from 'node:stream';
@@ -10,7 +10,7 @@ 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]';
@@ -89,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);
     });
@@ -120,7 +119,7 @@ function opened(url, method, headers, body) {
         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);

package/dist/instructions.js

@@ -1,6 +1,6 @@
 import { agentInstructions } from '@agentshouse/skills';
 import { HOUSE_REF } from './git.js';
-const HOW_WE_WORK = '/rooms/private/how-we-work.md';
+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: (.+)$/;
@@ -8,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 readHowWeWork(bridge) {
+async function readOwnerRules(bridge) {
     let document = '';
-    for (let command = `cat ${HOW_WE_WORK}`; command !== undefined;) {
+    for (let command = `cat ${OWNER_RULES}`; command !== undefined;) {
         const read = await bridge.tool('shell', { command });
         const text = read.content.map((content) => content.text).join('\n');
         const lines = text.split('\n');
@@ -28,5 +28,5 @@ async function readHowWeWork(bridge) {
 }
 export async function instructions(bridge, base, copies) {
     const lines = agentInstructions(HOUSE_REF, copies);
-    return [lines.join('\n'), base, (await readHowWeWork(bridge)).replace(/\n$/, '')].filter((part) => part !== '').join('\n\n');
+    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/login.js

@@ -10,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.
@@ -25,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]
@@ -119,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,