@agentshouse/kit 0.2.1-alpha.15 → 0.2.1-alpha.17

package/README.md

@@ -24,6 +24,11 @@ On your own Ubuntu 26.04 server, run the Linux command with `--linux` to
 install House Kit natively, with its workspace at `/agents/house`; `kit` and
 `house` are then on the server's `PATH`.
 
+House Kit runs the agent CLIs your login shell finds and installs a missing
+one through that CLI's own installer. Running the command again offers to
+update each CLI older than House Kit needs; add `--update-clis` to update every
+one to its latest release without asking.
+
 House Kit also gives every Agent on the Environment a set of agent skills. Add
 `--no-skills` to the command to leave them out; running it again without the
 flag brings them back.
@@ -33,7 +38,9 @@ flag brings them back.
 `kit login` opens a link you confirm in your browser and keeps the
 Environment's credential in `~/.house-kit`, or in `$HOUSE_KIT_HOME` when it is
 set. Pass `--manual` to paste the code by hand on a machine without a browser,
-and `--environment <id>` to reconnect an Environment you already have.
+and `--environment <id>` to reconnect an Environment you already have. It also
+connects your own agent: `house <tool>` run outside an Agent conversation calls
+House as you, until you revoke that connection on Connections.
 
 `kit resident` keeps the Environment connected, and keeps the Rooms you chose
 for this Environment as Git repositories under `working-copies` in the

package/dist/acp.js

@@ -2,13 +2,14 @@ import { ndJsonStream, PROTOCOL_VERSION, } from '@agentclientprotocol/sdk';
 import { execFileSync, spawn } from 'node:child_process';
 import { readdirSync, readFileSync } from 'node:fs';
 import { Readable, Writable } from 'node:stream';
-import { CLIS, KIT_VERSION, cliCommand, withoutProxy } from './clis.js';
+import { CLIS, KIT_VERSION, adapterCommand, withoutProxy } from './clis.js';
 export const TURN_STARTED = 'kit/turn_started';
 export const TURN_ENDED = 'kit/turn_ended';
-export async function startAdapter(kind, cwd, app, jobs = () => undefined, added = {}) {
-    const child = spawn(cliCommand(kind), CLIS[kind].args, {
+export async function startAdapter(kind, cli, cwd, app, jobs = () => undefined, added = {}) {
+    const adapter = CLIS[kind].adapter;
+    const child = spawn(adapter === null ? cli : adapterCommand(kind), CLIS[kind].args, {
         cwd,
-        env: { ...withoutProxy(), ...added },
+        env: { ...withoutProxy(), ...(adapter === null ? {} : { [adapter.executable]: cli }), ...added },
         stdio: ['pipe', 'pipe', 'pipe'],
         detached: true,
     });

package/dist/agents.js

@@ -1,7 +1,7 @@
 import { client } from '@agentclientprotocol/sdk';
-import { readFile } from 'node:fs/promises';
+import { readFile, realpath } from 'node:fs/promises';
 import { killTree, startAdapter } from './acp.js';
-import { CLIS, KIT_VERSION, cliCommand, install, run } from './clis.js';
+import { CLIS, KIT_VERSION, below, installAdapter, installCli, locate, run, versionOf } from './clis.js';
 import { agentBase, kitHome } from './home.js';
 const SIGNED_OUT = { signed_in: false, models: [] };
 function select(options, category) {
@@ -14,6 +14,9 @@ function values(options) {
 function causeOf(error) {
     return error instanceof Error ? error.message : String(error);
 }
+function logged(error) {
+    process.stderr.write(`kit: ${causeOf(error)}\n`);
+}
 async function models(kind, adapter, known) {
     const agent = adapter.connection.agent;
     const opened = await agent.request('session/new', { cwd: kitHome(), mcpServers: [] });
@@ -38,13 +41,13 @@ async function models(kind, adapter, known) {
     }
     return offered;
 }
-async function offer(kind, known) {
+async function offer(kind, cli, known) {
     const probe = CLIS[kind].signedIn;
-    if ('command' in probe && (await run(cliCommand(kind), probe.command, 30_000)).status !== 0)
+    if ('command' in probe && (await run(cli, probe.command, 30_000)).status !== 0)
         return SIGNED_OUT;
     let adapter;
     try {
-        adapter = await startAdapter(kind, kitHome(), client({ name: '@agentshouse/kit' }));
+        adapter = await startAdapter(kind, cli, kitHome(), client({ name: '@agentshouse/kit' }));
         if ('initializeMeta' in probe) {
             const method = adapter.initialized._meta?.[probe.initializeMeta];
             if (typeof method !== 'string' || method.length === 0)
@@ -54,13 +57,27 @@ async function offer(kind, known) {
     }
     catch (error) {
         process.stderr.write(`kit: ${kind} did not offer its models: ${causeOf(error)}\n`);
-        return adapter === undefined && 'initializeMeta' in probe ? known : { signed_in: true, models: known.models };
+        return { signed_in: adapter === undefined && 'initializeMeta' in probe ? known.signed_in : true, models: known.models };
     }
     finally {
         if (adapter !== undefined)
             killTree(adapter.child);
     }
 }
+function reported(kind, reading) {
+    return {
+        kind,
+        release: reading.release,
+        ...(reading.minimum === undefined ? {} : { minimum: reading.minimum }),
+        failure: reading.failure,
+        signed_in: reading.signed_in,
+        models: reading.models,
+    };
+}
+function tooOld(kind, release) {
+    const cli = CLIS[kind];
+    return `${cli.bin} ${release} is older than ${cli.minimum}, the oldest this Kit runs`;
+}
 async function sshHostKey() {
     const listed = await run('ssh-keygen', ['-l', '-E', 'sha256', '-f', '/etc/ssh/ssh_host_ed25519_key.pub'], 10_000);
     return listed.status === 0 ? (/^\d+ (SHA256:\S+)/.exec(listed.output)?.[1] ?? null) : null;
@@ -75,11 +92,10 @@ export class Agents {
     desired = { agents: [], routes: [] };
     house;
     reading = Promise.resolve();
+    queues = new Map();
     installing = Promise.resolve();
-    installs = new Map();
-    offers = new Map();
-    reporting = null;
-    again = false;
+    readings = new Map();
+    reads = new Map();
     sending = Promise.resolve();
     sent = null;
     constructor(house) {
@@ -88,9 +104,6 @@ export class Agents {
     read() {
         return this.reading.then(() => undefined, () => undefined);
     }
-    installed() {
-        return this.installing.catch(() => undefined);
-    }
     route(agentId) {
         return this.desired.routes.find((route) => route.agent_id === agentId);
     }
@@ -100,28 +113,118 @@ export class Agents {
             return this.desired;
         });
         this.reading = reading;
-        const installing = this.installed()
-            .then(() => reading)
-            .then(({ agents }) => this.install(agents));
-        this.installing = installing;
-        if (this.reporting === null)
-            this.reporting = this.reports();
-        else
-            this.again = true;
-        return Promise.all([installing, this.reporting]).then(() => undefined);
+        return reading.then(({ agents }) => {
+            Promise.all(agents.map((kind) => this.queue(kind, () => this.load(kind))))
+                .then(() => this.report())
+                .catch(logged);
+        });
+    }
+    cli(kind) {
+        return this.queue(kind, async () => {
+            const resolved = await this.resolve(kind);
+            if (!('cli' in resolved)) {
+                this.update(kind, resolved);
+                throw new Error(resolved.failure ?? tooOld(kind, resolved.release));
+            }
+            const { cli, release } = resolved;
+            const known = this.readings.get(kind);
+            const kept = known?.release === null || known?.minimum !== undefined ? SIGNED_OUT : (known ?? SIGNED_OUT);
+            if (known?.release !== release || known.minimum !== undefined) {
+                this.update(kind, { release, failure: null, signed_in: kept.signed_in, models: kept.models });
+            }
+            const read = this.nextRead(kind);
+            offer(kind, cli, kept)
+                .then((offered) => {
+                const current = this.readings.get(kind);
+                if (this.reads.get(kind) === read && current?.release === release)
+                    this.update(kind, { ...current, ...offered });
+            })
+                .catch(logged);
+            return cli;
+        });
+    }
+    located(kind) {
+        return this.queue(kind, () => this.ensure(kind));
+    }
+    async reread(kind) {
+        await this.queue(kind, async () => {
+            this.nextRead(kind);
+            this.readings.set(kind, await this.examine(kind, this.readings.get(kind) ?? SIGNED_OUT));
+        });
+        await this.report();
     }
     report() {
         const sending = this.sending.catch(() => undefined).then(() => this.send());
         this.sending = sending;
         return sending;
     }
-    async send() {
-        const agents = [];
-        for (const [kind, installed] of this.installs) {
-            const offered = installed.release === null ? SIGNED_OUT : await offer(kind, this.offers.get(kind) ?? SIGNED_OUT);
-            this.offers.set(kind, offered);
-            agents.push({ kind, ...installed, ...offered });
+    nextRead(kind) {
+        const read = (this.reads.get(kind) ?? 0) + 1;
+        this.reads.set(kind, read);
+        return read;
+    }
+    update(kind, reading) {
+        this.readings.set(kind, reading);
+        this.report().catch(logged);
+    }
+    queue(kind, work) {
+        const queued = (this.queues.get(kind) ?? Promise.resolve()).then(work);
+        this.queues.set(kind, queued.catch(() => undefined));
+        return queued;
+    }
+    async ensure(kind) {
+        const failed = await installAdapter(kind);
+        if (failed !== null)
+            throw new Error(failed);
+        const found = await locate(kind);
+        if (found !== null)
+            return found;
+        const installing = this.installing.catch(() => undefined).then(() => installCli(kind));
+        this.installing = installing;
+        const failure = await installing;
+        if (failure !== null)
+            throw new Error(failure);
+        const installed = await locate(kind);
+        if (installed === null)
+            throw new Error(`the login shell does not find ${CLIS[kind].bin} after its install`);
+        return installed;
+    }
+    async resolve(kind) {
+        let cli;
+        try {
+            cli = await realpath(await this.ensure(kind));
         }
+        catch (error) {
+            const failure = causeOf(error);
+            process.stderr.write(`kit: ${kind} did not install: ${failure}\n`);
+            return { release: null, failure, ...SIGNED_OUT };
+        }
+        const release = await versionOf(cli);
+        if (release === null)
+            return { release: null, failure: `${cli} --version names no version`, ...SIGNED_OUT };
+        const minimum = CLIS[kind].minimum;
+        if (below(release, minimum))
+            return { release, minimum, failure: null, ...SIGNED_OUT };
+        return { cli, release };
+    }
+    async examine(kind, known) {
+        const resolved = await this.resolve(kind);
+        if (!('cli' in resolved))
+            return resolved;
+        return { release: resolved.release, failure: null, ...(await offer(kind, resolved.cli, known)) };
+    }
+    async load(kind) {
+        const known = this.readings.get(kind);
+        if (known !== undefined && known.failure === null)
+            return;
+        this.nextRead(kind);
+        this.readings.set(kind, await this.examine(kind, SIGNED_OUT));
+    }
+    async send() {
+        const agents = this.desired.agents.flatMap((kind) => {
+            const reading = this.readings.get(kind);
+            return reading === undefined ? [] : [reported(kind, reading)];
+        });
         const hostKey = await sshHostKey();
         const body = {
             os: await operatingSystem(),
@@ -136,22 +239,4 @@ export class Agents {
         await this.house.deliver('/kit/agents/report', body);
         this.sent = state;
     }
-    async install(kinds) {
-        const installs = new Map();
-        for (const kind of kinds)
-            installs.set(kind, await install(kind));
-        this.installs = installs;
-    }
-    async reports() {
-        try {
-            do {
-                this.again = false;
-                await this.installing;
-                await this.report();
-            } while (this.again);
-        }
-        finally {
-            this.reporting = null;
-        }
-    }
 }

package/dist/bootstrap.json

@@ -1,12 +1,12 @@
 {
   "schemaVersion": 1,
-  "version": "0.2.1-alpha.15",
+  "version": "0.2.1-alpha.17",
   "hosts": {
     "linux": {
-      "command": "bash <(curl -fsSL https://github.com/agentshouse/kit/releases/download/v0.2.1-alpha.15/connect-linux.sh)",
+      "command": "bash <(curl -fsSL https://github.com/agentshouse/kit/releases/download/v0.2.1-alpha.17/connect-linux.sh)",
       "asset": {
         "name": "connect-linux.sh",
-        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-alpha.15/connect-linux.sh"
+        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-alpha.17/connect-linux.sh"
       },
       "workspace": {
         "argument": "--workspace",
@@ -17,10 +17,10 @@
       }
     },
     "windows": {
-      "command": "& ([scriptblock]::Create((irm https://github.com/agentshouse/kit/releases/download/v0.2.1-alpha.15/connect-windows.ps1)))",
+      "command": "& ([scriptblock]::Create((irm https://github.com/agentshouse/kit/releases/download/v0.2.1-alpha.17/connect-windows.ps1)))",
       "asset": {
         "name": "connect-windows.ps1",
-        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-alpha.15/connect-windows.ps1"
+        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-alpha.17/connect-windows.ps1"
       },
       "workspace": {
         "argument": "--workspace",

package/dist/bridge.js

@@ -7,12 +7,11 @@ import { request as httpsRequest } from 'node:https';
 import { delimiter, join } from 'node:path';
 import { parse } from 'yaml';
 import { HouseRefusal, retryDelay } from './api.js';
-import { KIT_VERSION } from './clis.js';
 import { changedPaths, } from './copies.js';
 import { kitHome, readEnrolment } from './home.js';
+import { callHouse, mcpBody, rpc, UNREACHABLE } from './mcp.js';
 import { operationId, uuidOf } from './operation.js';
 import { refusalOf } from './refusals.js';
-const MCP_PROTOCOL_VERSION = '2026-07-28';
 const MCP_REQUEST_BYTES = 4 * 1024 * 1024;
 const ATTACHMENTS = '/kit/attachments/upload';
 export async function received(request) {
@@ -34,7 +33,6 @@ function relay(request, response, target, authorization) {
     forwarded.on('error', () => response.destroy());
     request.pipe(forwarded);
 }
-const UNREACHABLE = 'House is unreachable; call again in a minute';
 function refusalIn(text, status) {
     return refusalOf(text) ?? { code: '', text: text === '' ? `House refused it with ${status}` : text, conflicts: [] };
 }
@@ -90,35 +88,7 @@ export async function openBridge(house, copies, conversationId, signal) {
     const origin = (await readEnrolment()).house;
     const { credential } = await house.post(`/kit/conversations/${conversationId}/credential`, {}, signal);
     const closed = new AbortController();
-    const body = (message, operation) => JSON.stringify({
-        ...message,
-        params: {
-            ...message.params,
-            _meta: {
-                'io.modelcontextprotocol/protocolVersion': MCP_PROTOCOL_VERSION,
-                'io.modelcontextprotocol/clientInfo': { name: '@agentshouse/kit', version: KIT_VERSION },
-                'io.modelcontextprotocol/clientCapabilities': {},
-                ...(operation === null ? {} : { 'agents.house/agent-operation': operation }),
-            },
-        },
-    });
-    const sent = async (message, operation) => {
-        const tool = message.method === 'tools/call' ? String(message.params?.name) : null;
-        const answer = await fetch(new URL('/', origin), {
-            method: 'POST',
-            headers: {
-                'content-type': 'application/json',
-                authorization: `Bearer ${credential}`,
-                accept: 'application/json, text/event-stream',
-                'mcp-protocol-version': MCP_PROTOCOL_VERSION,
-                'mcp-method': message.method,
-                ...(tool === null ? {} : { 'mcp-name': tool }),
-            },
-            body: body(message, operation),
-            signal: closed.signal,
-        });
-        return { status: answer.status, text: await answer.text() };
-    };
+    const sent = (message, operation) => callHouse(origin, credential, message, operation, closed.signal);
     const send = async (message, operation) => {
         if (operation === null)
             return sent(message, null);
@@ -134,7 +104,7 @@ export async function openBridge(house, copies, conversationId, signal) {
             await delay(after, undefined, { signal: closed.signal });
         }
     };
-    const call = (name, args) => ({ jsonrpc: '2.0', id: randomUUID(), method: 'tools/call', params: { name, arguments: args } });
+    const call = (name, args) => rpc('tools/call', { name, arguments: args });
     const staged = async (operation, changes) => {
         const bytes = Buffer.from(JSON.stringify({ changes }));
         const sha256 = createHash('sha256').update(bytes).digest('hex');
@@ -175,7 +145,7 @@ export async function openBridge(house, copies, conversationId, signal) {
     const forward = async (path, text) => {
         if (path === '/') {
             const message = JSON.parse(text);
-            const tool = message.method === 'tools/call' ? String(message.params?.name) : null;
+            const tool = message.method === 'tools/call' ? String(message.params.name) : null;
             return send(message, tool !== null && (await writes(tool)) ? operationId() : null);
         }
         const answer = await fetch(new URL(path, origin), {
@@ -191,7 +161,7 @@ export async function openBridge(house, copies, conversationId, signal) {
         submit: async (operation, changes, held, retain) => {
             const inline = call('edit', { changes });
             let upload = held;
-            if (upload === undefined && Buffer.byteLength(body(inline, operation)) > MCP_REQUEST_BYTES) {
+            if (upload === undefined && Buffer.byteLength(mcpBody(inline, operation)) > MCP_REQUEST_BYTES) {
                 const prepared = await staged(operation, changes);
                 if ('refused' in prepared)
                     return prepared;
@@ -257,7 +227,7 @@ export async function openBridge(house, copies, conversationId, signal) {
             GIT_CONFIG_VALUE_0: app,
         },
         tool: async (name, args) => {
-            const forwarded = await forward('/', JSON.stringify({ jsonrpc: '2.0', id: randomUUID(), method: 'tools/call', params: { name, arguments: args } }));
+            const forwarded = await forward('/', JSON.stringify(call(name, args)));
             if (forwarded.status !== 200)
                 throw new Error(`House refused ${name} with ${forwarded.status}: ${forwarded.text}`);
             const answer = JSON.parse(forwarded.text);

package/dist/clis-main.js

@@ -0,0 +1,23 @@
+import { setGlobalProxyFromEnv } from 'node:http';
+import { post } from './api.js';
+import { CLIS, below, locate, versionOf } from './clis.js';
+import { readEnrolment } from './home.js';
+setGlobalProxyFromEnv();
+try {
+    const { house, credential } = (await readEnrolment());
+    const { agents } = await post(house, '/kit/agents/desired', {}, credential);
+    for (const kind of agents) {
+        const cli = await locate(kind);
+        if (cli === null)
+            continue;
+        const release = await versionOf(cli);
+        if (release === null)
+            continue;
+        const { bin, minimum } = CLIS[kind];
+        process.stdout.write(`${[bin, cli, release, minimum, below(release, minimum) ? 'old' : 'current'].join('\t')}\n`);
+    }
+}
+catch (error) {
+    process.stderr.write(`kit: ${error.message}\n`);
+    process.exitCode = 1;
+}

package/dist/clis.js

@@ -1,6 +1,7 @@
 import { spawn } from 'node:child_process';
 import { readFileSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
+import { userInfo } from 'node:os';
 import { join } from 'node:path';
 import { kitHome } from './home.js';
 const RUNNING_JOB = new Set(['running', 'paused']);
@@ -30,11 +31,13 @@ function airPhase({ _meta }) {
 }
 export const CLIS = {
     'codex-acp': {
-        package: '@agentclientprotocol/codex-acp',
-        bin: 'codex-acp',
+        bin: 'codex',
+        minimum: '0.159.1',
+        install: 'curl -fsSL https://chatgpt.com/codex/install.sh | sh',
+        adapter: { package: '@agentclientprotocol/codex-acp', bin: 'codex-acp', executable: 'CODEX_PATH' },
         args: [],
-        signedIn: { command: ['cli', 'login', 'status'] },
-        login: { args: ['cli', 'login', '--device-auth'], code: 'show' },
+        signedIn: { command: ['login', 'status'] },
+        login: { args: ['login', '--device-auth'], code: 'show' },
         queues: false,
         turnStarted: (notice) => threadStatus(notice) === 'active',
         turnEnded: (notice) => threadStatus(notice) === 'idle',
@@ -42,11 +45,17 @@ export const CLIS = {
         phase: airPhase,
     },
     'claude-agent-acp': {
-        package: '@agentclientprotocol/claude-agent-acp',
-        bin: 'claude-agent-acp',
+        bin: 'claude',
+        minimum: '2.1.286',
+        install: 'curl -fsSL https://claude.ai/install.sh | bash',
+        adapter: {
+            package: '@agentclientprotocol/claude-agent-acp',
+            bin: 'claude-agent-acp',
+            executable: 'CLAUDE_CODE_EXECUTABLE',
+        },
         args: [],
-        signedIn: { command: ['--cli', 'auth', 'status'] },
-        login: { args: ['--cli', 'auth', 'login', '--claudeai'], code: 'collect' },
+        signedIn: { command: ['auth', 'status'] },
+        login: { args: ['auth', 'login', '--claudeai'], code: 'collect' },
         queues: false,
         turnStarted: () => false,
         turnEnded: ({ method, params }) => method === 'session/update' &&
@@ -56,8 +65,10 @@ export const CLIS = {
         phase: () => null,
     },
     'grok-build': {
-        package: '@xai-official/grok',
         bin: 'grok',
+        minimum: '1.0.46',
+        install: 'curl -fsSL https://x.ai/cli/install.sh | bash',
+        adapter: null,
         args: ['agent', '--no-leader', 'stdio'],
         signedIn: { initializeMeta: 'defaultAuthMethodId' },
         login: { args: ['login', '--device-auth'], code: 'show' },
@@ -77,18 +88,19 @@ export const CLIS = {
 const KIT_PACKAGE = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
 export const KIT_VERSION = KIT_PACKAGE.version;
 const PROXY = /^https?_proxy$/i;
-export function pinned(kind) {
-    return KIT_PACKAGE.peerDependencies[CLIS[kind].package];
-}
+const VERSION = /\d+\.\d+\.\d+(?:-[0-9A-Za-z.]+)?/;
+const INSTALL_MS = 15 * 60_000;
+const READ_MS = 30_000;
+const CAUSE_CHARACTERS = 4000;
 function prefix(kind) {
     return join(kitHome(), 'agents', kind);
 }
-export function cliCommand(kind) {
-    return join(prefix(kind), 'node_modules', '.bin', CLIS[kind].bin);
+export function adapterCommand(kind) {
+    return join(prefix(kind), 'node_modules', '.bin', CLIS[kind].adapter.bin);
 }
-export async function installedRelease(kind) {
+async function installedAdapter(kind) {
     try {
-        const manifest = join(prefix(kind), 'node_modules', CLIS[kind].package, 'package.json');
+        const manifest = join(prefix(kind), 'node_modules', CLIS[kind].adapter.package, 'package.json');
         return JSON.parse(await readFile(manifest, 'utf8')).version;
     }
     catch {
@@ -98,29 +110,64 @@ export async function installedRelease(kind) {
 export function withoutProxy() {
     return Object.fromEntries(Object.entries(process.env).filter(([name]) => !PROXY.test(name)));
 }
-export function run(command, args, timeoutMs) {
+export function run(command, args, timeoutMs, detached = false) {
     return new Promise((resolve) => {
-        const child = spawn(command, args, { stdio: ['ignore', 'pipe', 'pipe'], timeout: timeoutMs, env: withoutProxy() });
+        const child = spawn(command, args, {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            timeout: timeoutMs,
+            env: withoutProxy(),
+            detached,
+        });
+        let stdout = '';
         let output = '';
         child.stdout.on('data', (chunk) => {
+            stdout += chunk.toString('utf8');
             output += chunk.toString('utf8');
         });
         child.stderr.on('data', (chunk) => {
             output += chunk.toString('utf8');
         });
-        child.on('error', (error) => resolve({ status: null, output: error.message }));
-        child.on('close', (status) => resolve({ status, output }));
+        child.on('error', (error) => resolve({ status: null, stdout, output: error.message }));
+        child.on('close', (status) => resolve({ status, stdout, output }));
     });
 }
-export async function install(kind) {
-    const release = pinned(kind);
-    if ((await installedRelease(kind)) === release)
-        return { release, failure: null };
-    const ran = await run('npm', ['install', '--prefix', prefix(kind), '--no-save', '--no-audit', '--no-fund', `${CLIS[kind].package}@${release}`], 15 * 60_000);
-    if (ran.status !== 0) {
-        const failure = ran.output.trim() || `npm exited with ${ran.status ?? 'a signal'}`;
-        process.stderr.write(`kit: ${kind} did not install: ${failure}\n`);
-        return { release: null, failure };
+function failureOf(ran, program) {
+    return ran.output.trim().slice(-CAUSE_CHARACTERS) || `${program} exited with ${ran.status ?? 'a signal'}`;
+}
+export async function installAdapter(kind) {
+    const adapter = CLIS[kind].adapter;
+    if (adapter === null)
+        return null;
+    const release = KIT_PACKAGE.peerDependencies[adapter.package];
+    if ((await installedAdapter(kind)) === release)
+        return null;
+    const ran = await run('npm', ['install', '--prefix', prefix(kind), '--no-save', '--no-audit', '--no-fund', '--omit=optional', `${adapter.package}@${release}`], INSTALL_MS);
+    return ran.status === 0 ? null : failureOf(ran, 'npm');
+}
+export async function installCli(kind) {
+    const ran = await run('bash', ['-o', 'pipefail', '-c', CLIS[kind].install], INSTALL_MS, true);
+    return ran.status === 0 ? null : failureOf(ran, 'the install');
+}
+function loginShell() {
+    return process.env.SHELL || userInfo().shell;
+}
+const FOUND = 'house-kit-cli ';
+const LOOKUP = `found=$(command -v "$1") || exit 0; case $found in /*) ;; *) found=$(pwd -P)/$found ;; esac; printf "${FOUND}%s\\n" "$found"`;
+export async function locate(kind) {
+    const ran = await run(loginShell(), ['-l', '-i', '-c', `exec /bin/sh -c '${LOOKUP}' sh ${CLIS[kind].bin}`], READ_MS, true);
+    return ran.stdout.split('\n').findLast((line) => line.startsWith(FOUND))?.slice(FOUND.length) ?? null;
+}
+export async function versionOf(path) {
+    return VERSION.exec((await run(path, ['--version'], READ_MS)).stdout)?.[0] ?? null;
+}
+function numbers(version) {
+    return version.split(/[.-]/, 3).map(Number);
+}
+export function below(found, minimum) {
+    const [have, need] = [numbers(found), numbers(minimum)];
+    for (let index = 0; index < 3; index++) {
+        if (have[index] !== need[index])
+            return have[index] < need[index];
     }
-    return { release: await installedRelease(kind), failure: null };
+    return found.includes('-') && !minimum.includes('-');
 }

package/dist/conversations.js

@@ -253,7 +253,7 @@ export class Conversations {
             .onNotification(TURN_ENDED, (params) => params, () => this.ended(conversation))
             .onRequest('session/request_permission', ({ params, signal }) => this.ask(conversation, 'session/request_permission', params, false, signal))
             .onRequest('elicitation/create', ({ params, signal }) => this.ask(conversation, 'elicitation/create', params, asksSecret(params), signal));
-        await unlessKilled(this.kit.agents.installed(), conversation.killed.signal);
+        const cli = await unlessKilled(this.kit.agents.cli(route.kind), conversation.killed.signal);
         const bridge = await openBridge(this.kit.house, this.kit.copies, conversation.id, conversation.killed.signal);
         if (conversation.kills > 0) {
             bridge.close();
@@ -262,7 +262,7 @@ export class Conversations {
         conversation.opening = bridge;
         try {
             await unlessKilled(createHowWeWork(bridge), conversation.killed.signal);
-            const adapter = await startAdapter(route.kind, route.working_directory, app, (job) => this.job(conversation, job), bridge.env);
+            const adapter = await startAdapter(route.kind, cli, route.working_directory, app, (job) => this.job(conversation, job), bridge.env);
             void adapter.exited.then(() => bridge.close());
             const agent = adapter.connection.agent;
             const cwd = route.working_directory;

package/dist/home.js

@@ -1,8 +1,9 @@
-import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 const ENROLMENT = 'credential.json';
 const CONFIGURATION = 'kit.json';
+const OWN_AGENT = 'own-agent.json';
 export function kitHome() {
     return process.env.HOUSE_KIT_HOME ?? join(homedir(), '.house-kit');
 }
@@ -35,6 +36,15 @@ export function readEnrolment() {
 export function writeEnrolment(enrolment) {
     return writeHome(ENROLMENT, enrolment);
 }
+export function readOwnAgent() {
+    return readHome(OWN_AGENT);
+}
+export function writeOwnAgent(ownAgent) {
+    return writeHome(OWN_AGENT, ownAgent);
+}
+export function forgetOwnAgent() {
+    return rm(join(kitHome(), OWN_AGENT), { force: true });
+}
 export async function readConfiguration() {
     return { skills: (await readHome(CONFIGURATION))?.skills !== false };
 }

package/dist/house-main.js

@@ -1,15 +1,18 @@
 #!/usr/bin/env node
-import { createHash, randomUUID } from 'node:crypto';
+import { createHash } from 'node:crypto';
 import { readFile } from 'node:fs/promises';
-import { request } from 'node:http';
+import { request, setGlobalProxyFromEnv } from 'node:http';
 import { basename, join } from 'node:path';
-import { kitHome } from './home.js';
+import { kitHome, readOwnAgent } from './home.js';
+import { callHouse, rpc, UNREACHABLE } from './mcp.js';
 import { refusalOf } from './refusals.js';
 const USAGE = "usage: house <tool> ['<arguments as JSON>']";
 const GIT_USAGE = 'usage: house git push [commit] [--owner]';
 const ARGUMENTS = `the arguments are one JSON object in single quotes, like house search '{"query":"invoice"}'`;
 const CLOSED = "this conversation's House connection is closed; nothing to do from here";
 const REVOKED = 'this conversation no longer has House access; nothing to do from here';
+const UNCONNECTED = "this computer's own agent has no House connection; run kit login";
+const DISCONNECTED = "House no longer accepts this computer's own agent; run kit login";
 const socketPath = process.env.HOUSE_BRIDGE;
 function refused(path, status, text) {
     const refusal = refusalOf(text);
@@ -42,8 +45,21 @@ function bridged(path, body, headers = { 'content-type': 'application/json' }, t
         sent.end(body instanceof Buffer ? body : JSON.stringify(body));
     });
 }
+async function direct(message) {
+    const ownAgent = await readOwnAgent();
+    if (ownAgent === null)
+        throw new Error(UNCONNECTED);
+    setGlobalProxyFromEnv();
+    const answer = await callHouse(ownAgent.house, ownAgent.credential, message).catch(() => {
+        throw new Error(UNREACHABLE);
+    });
+    if (answer.status === 200)
+        return answer.text;
+    throw new Error(answer.status === 401 ? DISCONNECTED : (refusalOf(answer.text)?.text ?? `House answered ${answer.status}`));
+}
 async function mcp(method, params) {
-    const answer = JSON.parse(await bridged('/', { jsonrpc: '2.0', id: randomUUID(), 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;
@@ -122,10 +138,10 @@ async function house([verb, argument]) {
         return `${tool.description}\n${JSON.stringify(tool.inputSchema)}`;
     }
     const args = argumentsOf(argument);
-    if (verb === 'upload_attachment') {
+    if (socketPath !== undefined && verb === 'upload_attachment') {
         return JSON.stringify({ attachment: await upload(args.path, args.room_ref, 'upload_attachment needs "path", a local file') });
     }
-    if (verb === 'append_record' && Array.isArray(args.attachments)) {
+    if (socketPath !== undefined && verb === 'append_record' && Array.isArray(args.attachments)) {
         const attachments = [];
         for (const path of args.attachments) {
             attachments.push(await upload(path, args.room_ref, 'each attachments entry is the path of a local file'));
@@ -139,15 +155,9 @@ async function house([verb, argument]) {
     return text;
 }
 const argv = process.argv.slice(2);
-if (argv[0] !== 'git' && socketPath === undefined) {
-    process.stderr.write('house: house runs inside an Agent conversation\n');
+(argv[0] === 'git' ? gitPush(argv.slice(1)) : house(argv)).then((text) => {
+    process.stdout.write(`${text}\n`);
+}, (error) => {
+    process.stderr.write(`house: ${error instanceof Error ? error.message : String(error)}\n`);
     process.exitCode = 1;
-}
-else {
-    (argv[0] === 'git' ? gitPush(argv.slice(1)) : house(argv)).then((text) => {
-        process.stdout.write(`${text}\n`);
-    }, (error) => {
-        process.stderr.write(`house: ${error instanceof Error ? error.message : String(error)}\n`);
-        process.exitCode = 1;
-    });
-}
+});

package/dist/login.js

@@ -4,7 +4,8 @@ import { hostname } from 'node:os';
 import { createInterface } from 'node:readline/promises';
 import { parseArgs } from 'node:util';
 import { post } from './api.js';
-import { readEnrolment, writeEnrolment } from './home.js';
+import { forgetOwnAgent, readEnrolment, readOwnAgent, writeEnrolment, writeOwnAgent } from './home.js';
+import { callHouse, rpc } from './mcp.js';
 const DEFAULT_HOUSE = 'https://agents.house';
 function listen() {
     return new Promise((resolve, reject) => {
@@ -48,6 +49,14 @@ function listen() {
         });
     });
 }
+async function accepted(house, credential) {
+    const checked = await callHouse(house, credential, rpc('tools/list', {}));
+    if (checked.status === 200)
+        return true;
+    if (checked.status === 401)
+        return false;
+    throw new Error(`House answered ${checked.status} when Kit checked this computer's own agent's connection: ${checked.text}`);
+}
 async function typed(question) {
     const reader = createInterface({ input: process.stdin, output: process.stdout });
     const closed = new Promise((_, reject) => {
@@ -73,17 +82,27 @@ export async function login(argv) {
     const house = values.house ?? enrolled?.house ?? DEFAULT_HOUSE;
     const replaces = process.env.HOUSE_KIT_REPLACES;
     const environment = replaces === undefined ? (values.environment ?? (enrolled?.house === house ? enrolled.environment : undefined)) : undefined;
+    const ownAgent = await readOwnAgent();
+    const held = ownAgent !== null && ownAgent.house === house && (await accepted(house, ownAgent.credential));
     const verifier = randomBytes(32).toString('base64url');
     const started = {
         ...(environment === undefined
             ? { act: 'new_environment', label: hostname(), ...(replaces === undefined ? {} : { replaces }) }
             : { act: 'existing_environment', environment_id: environment }),
         code_challenge: createHash('sha256').update(verifier).digest('base64url'),
+        ...(held ? {} : { headless: true }),
     };
     const exchange = async (code) => {
         const exchanged = await post(house, '/kit/token', { code, code_verifier: verifier });
         await writeEnrolment({ house, environment: exchanged.environment, credential: exchanged.credential });
         process.stdout.write(`Environment ${exchanged.environment} is connected to ${house}.\n`);
+        if (exchanged.headless_credential !== undefined) {
+            await writeOwnAgent({ house, user: exchanged.user, credential: exchanged.headless_credential });
+        }
+        else if (held && ownAgent.user !== exchanged.user) {
+            await forgetOwnAgent();
+            process.stdout.write("This computer's own agent was another User's; run kit login again to connect it to you.\n");
+        }
     };
     if (values.manual) {
         const { start_url } = await post(house, '/kit', {

package/dist/mcp.js

@@ -0,0 +1,38 @@
+import { randomUUID } from 'node:crypto';
+import { KIT_VERSION } from './clis.js';
+const MCP_PROTOCOL_VERSION = '2026-07-28';
+export const UNREACHABLE = 'House is unreachable; call again in a minute';
+export function rpc(method, params) {
+    return { jsonrpc: '2.0', id: randomUUID(), method, params };
+}
+export function mcpBody(message, operation) {
+    return JSON.stringify({
+        ...message,
+        params: {
+            ...message.params,
+            _meta: {
+                'io.modelcontextprotocol/protocolVersion': MCP_PROTOCOL_VERSION,
+                'io.modelcontextprotocol/clientInfo': { name: '@agentshouse/kit', version: KIT_VERSION },
+                'io.modelcontextprotocol/clientCapabilities': {},
+                ...(operation === null ? {} : { 'agents.house/agent-operation': operation }),
+            },
+        },
+    });
+}
+export async function callHouse(origin, credential, message, operation = null, signal) {
+    const tool = message.method === 'tools/call' ? String(message.params.name) : null;
+    const answer = await fetch(new URL('/', origin), {
+        method: 'POST',
+        headers: {
+            'content-type': 'application/json',
+            authorization: `Bearer ${credential}`,
+            accept: 'application/json, text/event-stream',
+            'mcp-protocol-version': MCP_PROTOCOL_VERSION,
+            'mcp-method': message.method,
+            ...(tool === null ? {} : { 'mcp-name': tool }),
+        },
+        body: mcpBody(message, operation),
+        signal,
+    });
+    return { status: answer.status, text: await answer.text() };
+}

package/dist/resident.js

@@ -14,7 +14,6 @@ import { SignIns } from './sign-in.js';
 import { placeSkillSet } from './skills.js';
 import { holdStream } from './stream.js';
 import { Updates } from './update.js';
-const AGENTS_REREAD_MS = 60 * 60_000;
 function report(error) {
     process.stderr.write(`kit: ${error instanceof Error ? error.message : String(error)}\n`);
 }
@@ -95,7 +94,6 @@ export async function resident() {
     await house.deliver('/kit/restarted', {}).catch(report);
     await updates.resumed().catch(report);
     logged(agents.refresh());
-    setInterval(() => logged(agents.refresh()), AGENTS_REREAD_MS);
     stream = holdStream({
         opened: () => {
             conversations.opened();

package/dist/sign-in.js

@@ -1,13 +1,16 @@
 import { spawn } from 'node:child_process';
 import { createInterface } from 'node:readline';
 import { killTree } from './acp.js';
-import { CLIS, cliCommand, withoutProxy } from './clis.js';
+import { CLIS, withoutProxy } from './clis.js';
 import { holdSecretInput } from './secret-input.js';
 const ESCAPE = /\u001b\[[\d;]*m/g;
 const LINK = /https:\/\/\S+/;
 const CODE = /^[A-Z0-9]+-[A-Z0-9]+$/;
+function causeOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}
 function logged(error) {
-    process.stderr.write(`kit: ${error instanceof Error ? error.message : String(error)}\n`);
+    process.stderr.write(`kit: ${causeOf(error)}\n`);
 }
 export class SignIns {
     house;
@@ -28,7 +31,7 @@ export class SignIns {
         this.running.add(input.input_id);
         this.changed();
         this.login(input)
-            .then(() => this.agents.report())
+            .then(() => this.agents.reread(input.cli))
             .then(() => this.house.deliver(`/kit/inputs/${input.input_id}/ack`, {}))
             .catch(logged)
             .finally(() => {
@@ -37,9 +40,16 @@ export class SignIns {
         });
     }
     async login(input) {
-        await this.agents.installed();
+        let cli;
+        try {
+            cli = await this.agents.located(input.cli);
+        }
+        catch (error) {
+            process.stderr.write(`kit: the ${input.cli} sign-in failed: ${causeOf(error)}\n`);
+            return;
+        }
         const login = CLIS[input.cli].login;
-        const child = spawn(cliCommand(input.cli), login.args, {
+        const child = spawn(cli, login.args, {
             stdio: ['pipe', 'pipe', 'pipe'],
             detached: true,
             env: withoutProxy(),

package/dist/update.js

@@ -5,7 +5,7 @@ import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { run } from './clis.js';
 import { kitHome } from './home.js';
-const RECORD = 'bash "$0" --linux; printf %s "$?" > "$1"; systemctl start house-kit.service';
+const RECORD = 'outcome=$1; shift; bash "$0" --linux "$@"; printf %s "$?" > "$outcome"; systemctl start house-kit.service';
 function logged(error) {
     process.stderr.write(`kit: ${error instanceof Error ? error.message : String(error)}\n`);
 }
@@ -46,7 +46,7 @@ async function finished(inputId) {
         await new Promise((resolve) => setTimeout(resolve, 1000));
     }
 }
-function rerun(script, inputId) {
+function rerun(script, inputId, flags) {
     return new Promise((resolve) => {
         const child = spawn('systemd-run', [
             '--wait',
@@ -59,6 +59,7 @@ function rerun(script, inputId) {
             RECORD,
             script,
             outcome(),
+            ...flags,
         ], { stdio: ['ignore', 'ignore', 'inherit'] });
         child.on('error', () => resolve({ refused: 'no service manager runs this Kit' }));
         child.on('close', () => resolve(null));
@@ -102,7 +103,7 @@ export class Updates {
         await writeFile(path, script, { mode: 0o700 });
         await rm(outcome(), { force: true });
         await writeFile(pending(), `${JSON.stringify({ input_id: input.input_id })}\n`, { mode: 0o600 });
-        return (await rerun(path, input.input_id)) ?? (await recorded()) ?? {
+        return (await rerun(path, input.input_id, input.update_clis ? ['--update-clis'] : [])) ?? (await recorded()) ?? {
             refused: 'the Kit bootstrap did not finish',
         };
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentshouse/kit",
-  "version": "0.2.1-alpha.15",
+  "version": "0.2.1-alpha.17",
   "description": "House Kit connects an Environment to agents.house.",
   "license": "MIT",
   "repository": {
@@ -31,8 +31,7 @@
   },
   "peerDependencies": {
     "@agentclientprotocol/claude-agent-acp": "0.85.1",
-    "@agentclientprotocol/codex-acp": "2.1.1",
-    "@xai-official/grok": "1.0.46"
+    "@agentclientprotocol/codex-acp": "2.1.1"
   },
   "peerDependenciesMeta": {
     "@agentclientprotocol/claude-agent-acp": {
@@ -40,9 +39,6 @@
     },
     "@agentclientprotocol/codex-acp": {
       "optional": true
-    },
-    "@xai-official/grok": {
-      "optional": true
     }
   },
   "devDependencies": {