@agentshouse/kit 0.2.1-cb6679d048e60 → 0.2.1-ce145e9aadbf6

package/dist/agents.js

@@ -3,13 +3,16 @@ import { readFile, realpath } from 'node:fs/promises';
 import { killTree, startAdapter } from './acp.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: [] };
+const SIGNED_OUT = { signed_in: false, models: [], modes: [] };
 function select(options, category) {
     const option = options.find((candidate) => candidate.category === category);
     return option?.type === 'select' ? option : undefined;
 }
+function choices(options) {
+    return options.flatMap((entry) => ('group' in entry ? entry.options : [entry]));
+}
 function values(options) {
-    return options.flatMap((entry) => ('group' in entry ? entry.options : [entry])).map((entry) => entry.value);
+    return choices(options).map((entry) => entry.value);
 }
 function causeOf(error) {
     return error instanceof Error ? error.message : String(error);
@@ -21,9 +24,11 @@ async function models(kind, adapter, known) {
     const agent = adapter.connection.agent;
     const opened = await agent.request('session/new', { cwd: kitHome(), mcpServers: [] });
     let options = opened.configOptions ?? [];
+    const mode = select(options, 'mode');
+    const modes = mode === undefined ? [] : choices(mode.options).map(({ value, name }) => ({ mode: value, name }));
     const model = select(options, 'model');
     if (model === undefined)
-        return [];
+        return { models: [], modes };
     const offered = [];
     for (const value of values(model.options)) {
         if (select(options, 'model')?.currentValue !== value) {
@@ -39,7 +44,13 @@ async function models(kind, adapter, known) {
         const effort = select(options, 'thought_level');
         offered.push({ model: value, efforts: effort === undefined ? [] : values(effort.options) });
     }
-    return offered;
+    return { models: offered, modes };
+}
+async function signedIn(kind, cli, known) {
+    const probe = CLIS[kind].signedIn;
+    if ('command' in probe)
+        return (await run(cli, probe.command, 30_000)).status === 0;
+    return (await offer(kind, cli, known)).signed_in;
 }
 async function offer(kind, cli, known) {
     const probe = CLIS[kind].signedIn;
@@ -53,11 +64,15 @@ async function offer(kind, cli, known) {
             if (typeof method !== 'string' || method.length === 0)
                 return SIGNED_OUT;
         }
-        return { signed_in: true, models: await models(kind, adapter, known.models) };
+        return { signed_in: true, ...(await models(kind, adapter, known.models)) };
     }
     catch (error) {
         process.stderr.write(`kit: ${kind} did not offer its models: ${causeOf(error)}\n`);
-        return { signed_in: 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,
+            modes: known.modes,
+        };
     }
     finally {
         if (adapter !== undefined)
@@ -72,6 +87,8 @@ function reported(kind, reading) {
         failure: reading.failure,
         signed_in: reading.signed_in,
         models: reading.models,
+        modes: reading.modes,
+        full_access: CLIS[kind].fullAccess,
     };
 }
 function tooOld(kind, release) {
@@ -114,7 +131,7 @@ export class Agents {
         });
         this.reading = reading;
         return reading.then(({ agents }) => {
-            Promise.all(agents.map((kind) => this.queue(kind, () => this.load(kind))))
+            Promise.all(agents.map((kind) => this.load(kind)))
                 .then(() => this.report())
                 .catch(logged);
         });
@@ -130,7 +147,7 @@ export class Agents {
             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 });
+                this.update(kind, { release, failure: null, signed_in: kept.signed_in, models: kept.models, modes: kept.modes });
             }
             const read = this.nextRead(kind);
             offer(kind, cli, kept)
@@ -147,10 +164,12 @@ export class Agents {
         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.examine(kind, this.readings.get(kind) ?? SIGNED_OUT, offer);
+        await this.report();
+    }
+    async recheck(kind) {
+        const known = this.readings.get(kind) ?? SIGNED_OUT;
+        await this.examine(kind, known, async (kind, cli) => (await signedIn(kind, cli, known)) ? { ...known, signed_in: true } : SIGNED_OUT);
         await this.report();
     }
     report() {
@@ -207,18 +226,18 @@ export class Agents {
             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 examine(kind, known, read) {
+        const current = this.nextRead(kind);
+        const resolved = await this.queue(kind, () => this.resolve(kind));
+        const reading = 'cli' in resolved ? { release: resolved.release, failure: null, ...(await read(kind, resolved.cli, known)) } : resolved;
+        if (this.reads.get(kind) === current)
+            this.readings.set(kind, reading);
     }
     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));
+        await this.examine(kind, SIGNED_OUT, offer);
     }
     async send() {
         const agents = this.desired.agents.flatMap((kind) => {

package/dist/api.js

@@ -1,4 +1,5 @@
 import { readEnrolment } from './home.js';
+import { relayed } from './relay.js';
 export class HouseRefusal extends Error {
     status;
     text;
@@ -12,7 +13,7 @@ export function retryDelay(attempt) {
     return Math.random() * Math.min(30_000, 1000 * 2 ** attempt);
 }
 export async function post(house, path, body, credential, signal) {
-    const answer = await fetch(new URL(path, house), {
+    const answer = await fetch(relayed(new URL(path, house)), {
         method: 'POST',
         headers: {
             'content-type': 'application/json',

package/dist/bootstrap.json

@@ -1,23 +1,23 @@
 {
   "schemaVersion": 2,
-  "version": "0.2.1-cb6679d048e60",
+  "version": "0.2.1-ce145e9aadbf6",
   "hosts": {
     "macos": {
       "asset": {
         "name": "connect-linux.sh",
-        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-cb6679d048e60/connect-linux.sh"
+        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-ce145e9aadbf6/connect-linux.sh"
       }
     },
     "linux": {
       "asset": {
         "name": "connect-linux.sh",
-        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-cb6679d048e60/connect-linux.sh"
+        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-ce145e9aadbf6/connect-linux.sh"
       }
     },
     "windows": {
       "asset": {
         "name": "connect-windows.ps1",
-        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-cb6679d048e60/connect-windows.ps1"
+        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-ce145e9aadbf6/connect-windows.ps1"
       }
     }
   }

package/dist/bridge.js

@@ -13,6 +13,7 @@ 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';
+import { relayed } from './relay.js';
 const MCP_REQUEST_BYTES = 4 * 1024 * 1024;
 const ATTACHMENTS = '/kit/attachments/upload';
 export async function received(request) {
@@ -22,7 +23,8 @@ export async function received(request) {
         text += chunk;
     return text;
 }
-function relay(request, response, target, authorization) {
+function relay(request, response, house, authorization) {
+    const target = relayed(house);
     const send = target.protocol === 'https:' ? httpsRequest : httpRequest;
     const forwarded = send(target, {
         method: request.method,
@@ -117,7 +119,7 @@ export async function openBridge(house, copies, conversationId, signal) {
         if ('refused' in prepared)
             return prepared;
         const { transfer } = parse(prepared.text);
-        const posted = await fetch(transfer.url, {
+        const posted = await fetch(relayed(transfer.url), {
             method: 'POST',
             headers: { 'content-type': 'text/plain; charset=utf-8' },
             body: Buffer.concat([Buffer.from(`${transfer.operation}\n`), bytes]),
@@ -150,7 +152,7 @@ export async function openBridge(house, copies, conversationId, signal) {
             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), {
+        const answer = await fetch(relayed(new URL(path, origin)), {
             method: 'POST',
             headers: { 'content-type': 'application/json', authorization: `Bearer ${credential}` },
             body: versioned(conversationId, text),

package/dist/clis.js

@@ -1,10 +1,16 @@
 import { spawn } from 'node:child_process';
 import { readFileSync } from 'node:fs';
-import { readFile } from 'node:fs/promises';
-import { userInfo } from 'node:os';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { homedir, userInfo } from 'node:os';
 import { join } from 'node:path';
 import { kitHome } from './home.js';
 const RUNNING_JOB = new Set(['running', 'paused']);
+async function allowHouseInCodex() {
+    const rules = join(process.env.CODEX_HOME || join(homedir(), '.codex'), 'rules');
+    await mkdir(rules, { recursive: true });
+    await writeFile(join(rules, 'house.rules'), 'prefix_rule(pattern = ["house"], decision = "allow")\n');
+}
+async function nothing() { }
 function threadStatus({ method, params }) {
     if (method !== 'session/update' || params?.update?.sessionUpdate !== 'session_info_update')
         return undefined;
@@ -36,6 +42,9 @@ export const CLIS = {
         install: 'curl -fsSL https://chatgpt.com/codex/install.sh | sh',
         adapter: { package: '@agentclientprotocol/codex-acp', bin: 'codex-acp', executable: 'CODEX_PATH', env: {} },
         args: [],
+        fullAccess: 'agent-full-access',
+        sessionMeta: {},
+        allowHouse: allowHouseInCodex,
         signedIn: { command: ['login', 'status'] },
         login: { args: ['login', '--device-auth'], code: 'show' },
         queues: false,
@@ -52,9 +61,12 @@ export const CLIS = {
             package: '@agentclientprotocol/claude-agent-acp',
             bin: 'claude-agent-acp',
             executable: 'CLAUDE_CODE_EXECUTABLE',
-            env: { CLAUDE_CODE_ENTRYPOINT: 'claude-agent-acp' },
+            env: { CLAUDE_CODE_ENTRYPOINT: 'claude-agent-acp', IS_SANDBOX: '1' },
         },
         args: [],
+        fullAccess: 'bypassPermissions',
+        sessionMeta: { claudeCode: { options: { allowedTools: ['Bash(house:*)'] } } },
+        allowHouse: nothing,
         signedIn: { command: ['auth', 'status'] },
         login: { args: ['auth', 'login', '--claudeai'], code: 'collect', rejected: 'Invalid code' },
         queues: false,
@@ -70,7 +82,10 @@ export const CLIS = {
         minimum: '1.0.46',
         install: 'curl -fsSL https://x.ai/cli/install.sh | bash',
         adapter: null,
-        args: ['agent', '--no-leader', 'stdio'],
+        args: ['agent', '--always-approve', '--no-leader', 'stdio'],
+        fullAccess: null,
+        sessionMeta: {},
+        allowHouse: nothing,
         signedIn: { initializeMeta: 'defaultAuthMethodId' },
         login: { args: ['login', '--device-auth'], code: 'show' },
         queues: true,

package/dist/conversations.js

@@ -285,13 +285,15 @@ export class Conversations {
         conversation.opening = bridge;
         try {
             await unlessAborted(createHowWeWork(bridge), conversation.killed.signal);
+            await CLIS[route.kind].allowHouse();
             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;
+            const _meta = CLIS[route.kind].sessionMeta;
             const opened = sessionId === null
-                ? await agent.request('session/new', { cwd, mcpServers: [] })
-                : { ...(await agent.request('session/resume', { sessionId, cwd, mcpServers: [] })), sessionId };
+                ? await agent.request('session/new', { cwd, mcpServers: [], _meta })
+                : { ...(await agent.request('session/resume', { sessionId, cwd, mcpServers: [], _meta })), sessionId };
             const running = {
                 adapter,
                 bridge,
@@ -321,6 +323,7 @@ export class Conversations {
     async launchSettings(running, route, offered) {
         let options = offered;
         const settings = [
+            ['mode', route.mode ?? CLIS[route.kind].fullAccess],
             ['model', route.model],
             ['thought_level', route.effort],
         ];

package/dist/copies.js

@@ -8,6 +8,7 @@ import { kitHome } from './home.js';
 import { operationId } from './operation.js';
 import { refusalOf } from './refusals.js';
 import { changed } from './translate.js';
+import { relayed } from './relay.js';
 const BRANCH = 'main';
 const PROVENANCE = '_provenance';
 const REPLICA_RETRY_MS = 30_000;
@@ -40,11 +41,11 @@ function sidecar(path) {
     segments.splice(-1, 0, PROVENANCE);
     return segments.join('/');
 }
-function rootOf(copy) {
-    return copy.private ? '/private' : `/rooms/${copy.room_handle}`;
+function rootOf(handle) {
+    return `/rooms/${handle}`;
 }
 function relative(path) {
-    return path.replace(/^\/private\//, '').replace(/^\/rooms\/[^/]+\//, '');
+    return path.replace(/^\/rooms\/[^/]+\//, '');
 }
 function declaredWritable(path, copy) {
     const deepest = (scopes) => Math.max(-1, ...scopes.filter((scope) => covers(path, scope)).map((scope) => scope.length));
@@ -176,7 +177,7 @@ export class LocalCopies {
     async load() {
         const home = join(kitHome(), 'local-copies');
         const names = (await readdir(join(home, 'rooms')).catch(() => [])).filter((name) => name.endsWith('.json'));
-        for (const path of [...names.map((name) => join(home, 'rooms', name)), join(home, 'private.json')]) {
+        for (const path of names.map((name) => join(home, 'rooms', name))) {
             const text = await readFile(path, 'utf8').catch(() => null);
             if (text === null)
                 continue;
@@ -188,7 +189,7 @@ export class LocalCopies {
         await this.selecting;
         return [...this.copies.values()]
             .filter((copy) => copy.active)
-            .map((copy) => `${rootOf(copy)}: ${copy.repository}`)
+            .map((copy) => `${rootOf(copy.room_handle)}: ${copy.repository}`)
             .sort();
     }
     select() {
@@ -198,12 +199,7 @@ export class LocalCopies {
     }
     async reselect() {
         const { local_copy: chosen } = await this.house.post('/kit/local-copy/selection', {});
-        const selected = [
-            ...(chosen?.rooms ?? [])
-                .filter((room) => room.room_handle !== null)
-                .map((room) => ({ key: `rooms/${room.room_ref}`, private: false, handle: room.room_handle })),
-            ...(chosen?.private === true ? [{ key: 'private', private: true, handle: null }] : []),
-        ];
+        const selected = (chosen?.rooms ?? []).flatMap((room) => room.room_handle === null ? [] : [{ key: `rooms/${room.room_ref}`, handle: room.room_handle }]);
         const keys = new Set(selected.map((scope) => scope.key));
         const work = [];
         for (const key of this.copies.keys()) {
@@ -287,7 +283,7 @@ export class LocalCopies {
         }).catch(logged);
     }
     async save(copy) {
-        const path = join(kitHome(), 'local-copies', copy.private ? 'private.json' : `${copy.key}.json`);
+        const path = join(kitHome(), 'local-copies', `${copy.key}.json`);
         await mkdir(dirname(path), { recursive: true, mode: 0o700 });
         const temporary = `${path}.${process.pid}`;
         await writeFile(temporary, JSON.stringify(copy), { mode: 0o600 });
@@ -295,12 +291,12 @@ export class LocalCopies {
         this.copies.set(copy.key, copy);
         return copy;
     }
-    async read(selected) {
-        const prefixes = [rootOf(selected)];
+    async read(handle) {
+        const prefixes = [rootOf(handle)];
         const discovery = await this.house.post('/kit/door/discover', { prefixes });
         let bundle = await this.house.post('/kit/door/bootstrap', { prefixes });
         if ('transfer' in bundle)
-            bundle = (await (await fetch(bundle.transfer.url)).json());
+            bundle = (await (await fetch(relayed(bundle.transfer.url))).json());
         const [view] = bundle.scopes;
         if (view === undefined)
             return null;
@@ -343,13 +339,13 @@ export class LocalCopies {
             return;
         }
         const discovery = await this.house.post('/kit/door/discover', {
-            prefixes: [rootOf(copy)],
+            prefixes: [rootOf(copy.room_handle)],
         });
         const authority = discovery.authorities.find((entry) => entry.room_ref === copy.room_ref);
         if (authority === undefined)
             return;
         if (authority.managed_replication !== 'admitted') {
-            logged(`operation_denied: ${rootOf(copy)} is not synchronized to this Environment`);
+            logged(`operation_denied: ${rootOf(copy.room_handle)} is not synchronized to this Environment`);
             return;
         }
         if (JSON.stringify([authority.operations.write, authority.protected_paths]) !==
@@ -360,12 +356,12 @@ export class LocalCopies {
         await this.save(await this.caughtUp(copy));
     }
     async materialize(scope) {
-        const read = await this.read({ private: scope.private, room_handle: scope.handle });
+        const read = await this.read(scope.handle);
         if (read === null) {
-            logged(`House serves nothing of ${rootOf({ private: scope.private, room_handle: scope.handle })} to copy`);
+            logged(`House serves nothing of ${rootOf(scope.handle)} to copy`);
             return;
         }
-        const repository = scope.private ? join(localCopies(), 'private') : join(localCopies(), 'rooms', read.anchor);
+        const repository = join(localCopies(), 'rooms', read.anchor);
         if (await exists(repository)) {
             logged(`${repository} already exists and House Kit leaves it as it is`);
             return;
@@ -377,7 +373,7 @@ export class LocalCopies {
         try {
             await git(staging, ['init', '-q', '-b', BRANCH]);
             house = await importCommits(staging, [
-                { message: `House ${rootOf({ private: scope.private, room_handle: scope.handle })}`, from: null, files: read.writable },
+                { message: `House ${rootOf(scope.handle)}`, from: null, files: read.writable },
             ]);
             await git(staging, ['update-ref', `refs/heads/${BRANCH}`, house]);
             await git(staging, ['reset', '-q', '--hard']);
@@ -391,7 +387,6 @@ export class LocalCopies {
         }
         await this.save({
             key: scope.key,
-            private: scope.private,
             room_ref: read.anchor,
             room_handle: scope.handle,
             repository,
@@ -407,11 +402,11 @@ export class LocalCopies {
         });
     }
     async received(copy) {
-        const read = await this.read(copy);
+        const read = await this.read(copy.room_handle);
         if (read === null)
             return copy;
         const house = await importCommits(copy.repository, [
-            { message: `House ${rootOf(copy)} at position ${read.position}`, from: copy.house, replaces: true, files: read.writable },
+            { message: `House ${rootOf(copy.room_handle)} at position ${read.position}`, from: copy.house, replaces: true, files: read.writable },
         ]);
         const removed = copy.read_only.filter((path) => !read.readOnly.has(path));
         const readOnly = await readOnlyPlaced(copy.repository, copy.read_only, read.readOnly, removed);
@@ -434,7 +429,7 @@ export class LocalCopies {
             let answer;
             try {
                 answer = await this.house.post('/kit/door/enumerate', {
-                    prefixes: [rootOf(copy)],
+                    prefixes: [rootOf(copy.room_handle)],
                     positions: [{ authority: copy.room_ref, position: copy.position, log_epoch: copy.log_epoch }],
                 });
             }
@@ -484,7 +479,7 @@ export class LocalCopies {
         let { house, manifests } = copy;
         if (files.size > 0) {
             house = await importCommits(copy.repository, [
-                { message: `House ${rootOf(copy)} at position ${position}`, from: copy.house, files },
+                { message: `House ${rootOf(copy.room_handle)} at position ${position}`, from: copy.house, files },
             ]);
             manifests = { ...manifests, [house]: { parent: copy.house, files: revisions } };
         }
@@ -515,7 +510,7 @@ export class LocalCopies {
             copy = await this.save(without(copy));
         }
         if (!copy.active) {
-            return { refused: true, text: `${rootOf(copy)} is no longer synced to this Environment, so House takes no push from it` };
+            return { refused: true, text: `${rootOf(copy.room_handle)} is no longer synced to this Environment, so House takes no push from it` };
         }
         const listed = (await git(copy.repository, ['rev-list', '--topo-order', commit])).split('\n');
         const base = listed.find((ancestor) => ancestor in copy.manifests);
@@ -549,7 +544,7 @@ export class LocalCopies {
         return this.settle(submitted, caller);
     }
     async derived(copy, base, commit) {
-        const root = rootOf(copy);
+        const root = rootOf(copy.room_handle);
         const before = await tree(copy.repository, base);
         const after = await tree(copy.repository, commit);
         const moved = movedPaths(copy.moves, before, after);
@@ -631,7 +626,7 @@ export class LocalCopies {
         const push = copy.push;
         const current = await this.save(await this.caughtUp(copy));
         const house = await tree(copy.repository, current.house);
-        const root = rootOf(current);
+        const root = rootOf(current.room_handle);
         if (!(await this.landed(copy.repository, push.changes, house, await tree(copy.repository, push.commit)))) {
             await this.save(without(current));
             return {
@@ -687,7 +682,7 @@ export class LocalCopies {
                 written = [
                     ...written,
                     {
-                        path: `${rootOf(copy)}/${path}`,
+                        path: `${rootOf(copy.room_handle)}/${path}`,
                         revision: entry === undefined ? null : (revisionAt(copy, copy.house, path) ?? null),
                         content: entry === undefined ? null : await blobText(copy.repository, entry, path),
                     },
@@ -707,7 +702,7 @@ export class LocalCopies {
         }
         const edits = new Map([...files].filter(([path, content]) => (content === null ? selected.has(path) : selected.get(path) !== blobId(content))));
         const received = [...files.keys()].filter((path) => revisionAt(copy, copy.house, path) === revisionAt(copy, push.house, path));
-        const accepted = `House ${rootOf(copy)} with ${push.commit} accepted`;
+        const accepted = `House ${rootOf(copy.room_handle)} with ${push.commit} accepted`;
         const house = await importCommits(copy.repository, [
             ...(edits.size === 0 ? [] : [{ message: accepted, from: push.commit, files: edits }]),
             {

package/dist/files.js

@@ -1,10 +1,11 @@
 import { mkdir, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
+import { relayed } from './relay.js';
 export async function placeFiles(house, directory, files, signal) {
     const paths = [];
     for (const file of files) {
         const original = await house.post('/kit/conversation/originals/get', { version: file.version, download: true }, signal);
-        const answer = await fetch(original.download.url, { signal });
+        const answer = await fetch(relayed(original.download.url), { signal });
         if (!answer.ok)
             throw new Error(`${file.name} did not download: ${answer.status}`);
         const folder = join(directory, '.house', 'files', original.message, file.version);

package/dist/instructions.js

@@ -1,7 +1,7 @@
 import { HOW_WE_WORK } from './skills.js';
 const HOUSE_LINE = 'Work with House through the `house` CLI: run `house --help`.';
 const FILE_LINE = 'To give the User a file or a page, upload it with `house upload_attachment` and link it; never start a server.';
-const READ_LINE = 'Before working in a Room, read `/private/rooms/<handle>/AGENTS.md`.';
+const READ_LINE = 'Before working in a Room, read `/rooms/private/rooms/<handle>/AGENTS.md`.';
 const COPIES_LINE = 'House Local copies; commit, then `house push`:';
 const UNREADABLE = /^(?:\S+: )?(?:path_not_found|room_not_found|operation_denied)\b/;
 const FAILED = /^exit: [1-9]\d*$/;

package/dist/mcp.js

@@ -1,5 +1,6 @@
 import { randomUUID } from 'node:crypto';
 import { KIT_VERSION } from './clis.js';
+import { relayed } from './relay.js';
 const MCP_PROTOCOL_VERSION = '2026-07-28';
 export const UNREACHABLE = 'House is unreachable; call again in a minute';
 export function rpc(method, params) {
@@ -21,7 +22,7 @@ export function mcpBody(message, 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), {
+    const answer = await fetch(relayed(new URL('/', origin)), {
         method: 'POST',
         headers: {
             'content-type': 'application/json',

package/dist/relay.js

@@ -0,0 +1,10 @@
+export function relayed(target) {
+    const url = new URL(target);
+    const relay = process.env.HOUSE_KIT_RELAY;
+    if (relay === undefined || relay === '')
+        return url;
+    const through = new URL(`${url.host}${url.pathname}${url.search}`, `${relay}/`);
+    if (url.protocol === 'wss:' || url.protocol === 'ws:')
+        through.protocol = 'wss:';
+    return through;
+}

package/dist/secret-input.js

@@ -1,4 +1,4 @@
-import { retryDelay } from './api.js';
+import { HouseRefusal, retryDelay } from './api.js';
 export async function holdSecretInput(house, subject, steps, waiting) {
     for (let failures = 0; waiting();) {
         try {
@@ -10,6 +10,8 @@ export async function holdSecretInput(house, subject, steps, waiting) {
             failures = 0;
         }
         catch (error) {
+            if (error instanceof HouseRefusal && error.status < 500)
+                return null;
             process.stderr.write(`kit: ${error instanceof Error ? error.message : String(error)}\n`);
             await new Promise((resolve) => setTimeout(resolve, retryDelay(failures++)));
         }

package/dist/sign-in.js

@@ -31,8 +31,9 @@ export class SignIns {
         this.running.add(input.input_id);
         this.changed();
         this.login(input)
-            .then(() => this.agents.reread(input.cli))
+            .then(() => this.agents.recheck(input.cli))
             .then(() => this.house.deliver(`/kit/inputs/${input.input_id}/ack`, {}))
+            .then(() => this.agents.reread(input.cli))
             .catch(logged)
             .finally(() => {
             this.running.delete(input.input_id);

package/dist/skills.js

@@ -6,7 +6,7 @@ import { fileURLToPath } from 'node:url';
 import { KIT_VERSION } from './clis.js';
 import { kitHome, readConfiguration, readHome, writeHome } from './home.js';
 import { refusalOf } from './refusals.js';
-export const HOW_WE_WORK = '/private/how-we-work.md';
+export const HOW_WE_WORK = '/rooms/private/how-we-work.md';
 const SKILL_SET = fileURLToPath(new URL('../skills/', import.meta.url));
 const HOW_WE_WORK_TEXT = readFileSync(new URL('../how-we-work.md', import.meta.url), 'utf8');
 const RECORD = 'skill-set.json';

package/dist/stream.js

@@ -1,5 +1,6 @@
 import { retryDelay } from './api.js';
 import { readEnrolment } from './home.js';
+import { relayed } from './relay.js';
 const SUBPROTOCOL = 'house.kit.stream.1';
 function streamUrl(house) {
     const url = new URL('/kit/stream', house);
@@ -11,7 +12,7 @@ export function holdStream(handlers) {
     let failures = 0;
     const connect = async () => {
         const { house, credential } = (await readEnrolment());
-        const opening = new WebSocket(streamUrl(house), {
+        const opening = new WebSocket(relayed(streamUrl(house)), {
             protocols: [SUBPROTOCOL],
             headers: { authorization: `Bearer ${credential}` },
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentshouse/kit",
-  "version": "0.2.1-cb6679d048e60",
+  "version": "0.2.1-ce145e9aadbf6",
   "description": "House Kit connects an Environment to agents.house.",
   "license": "MIT",
   "repository": {