@agentshouse/kit 0.2.1-c03721a31074a → 0.2.1-c0535b8294007

package/dist/acp.js

@@ -1,31 +1,70 @@
 import { ndJsonStream, PROTOCOL_VERSION, } from '@agentclientprotocol/sdk';
 import { spawn } from 'node:child_process';
 import { Readable, Writable } from 'node:stream';
-import { CLIS, KIT_RELEASE, adapterCommand, withoutProxy } from './clis.js';
+import { CLIS, KIT_RELEASE, adapterCommand } from './clis.js';
+import { childEnvironment } from './relay.js';
 import { killTree } from './scope.js';
+import { Silence } from './silence.js';
 const RETIRED = 'the CLI was retired';
+// Claude Code ends a shell command or a model request after ten minutes, so a CLI that owes the Kit an answer and sends nothing for half an hour has hung.
+export const CLI_SILENCE_MS = 30 * 60_000;
+const SILENT = `the CLI sent nothing for ${CLI_SILENCE_MS / 60_000} minutes`;
 export async function startAdapter(kind, cli, cwd, app, events = () => undefined, added = {}, signal, scope = null) {
     const adapter = CLIS[kind].adapter;
     const started = [adapter === null ? cli : adapterCommand(kind), CLIS[kind].args];
     const [command, args] = scope?.command(...started) ?? started;
     const child = spawn(command, args, {
         cwd,
-        env: { ...withoutProxy(), ...(adapter === null ? {} : { ...adapter.env, [adapter.executable]: cli }), ...added },
+        env: { ...childEnvironment(), ...(adapter === null ? {} : { ...adapter.env, [adapter.executable]: cli }), ...added },
         stdio: ['pipe', 'pipe', 'pipe'],
         detached: true,
     });
     let owned = true;
     let retired = false;
+    let silent = false;
+    let over = false;
+    let open = false;
     let stderr = '';
+    const owed = new Set();
+    const asked = new Set();
+    const silence = new Silence(CLI_SILENCE_MS, () => {
+        silent = true;
+        connection.close(new Error(SILENT));
+        if (child.pid !== undefined)
+            killTree(child);
+    });
+    const watch = () => (!over && (owed.size > 0 || open) && asked.size === 0 ? silence.heard() : silence.stop());
     child.stderr.on('data', (chunk) => {
         stderr = (stderr + chunk.toString('utf8')).slice(-4000);
     });
     const stream = ndJsonStream(Writable.toWeb(child.stdin), Readable.toWeb(child.stdout));
+    const output = stream.writable.getWriter();
     const connection = app.connect({
-        writable: stream.writable,
+        writable: new WritableStream({
+            write(message) {
+                const sent = message;
+                if (sent.id !== undefined) {
+                    if (sent.method === undefined)
+                        asked.delete(sent.id);
+                    else
+                        owed.add(sent.id);
+                    watch();
+                }
+                return output.write(message);
+            },
+            close: () => output.close(),
+            abort: (reason) => output.abort(reason),
+        }),
         readable: stream.readable.pipeThrough(new TransformStream({
             transform(message, controller) {
                 const read = message;
+                if (read.id !== undefined) {
+                    if (read.method === undefined)
+                        owed.delete(read.id);
+                    else
+                        asked.add(read.id);
+                }
+                watch();
                 if (owned)
                     events(read);
                 if (read.id !== undefined || (read.method !== 'session/update' && !read.method.startsWith('_'))) {
@@ -37,6 +76,8 @@ export async function startAdapter(kind, cli, cwd, app, events = () => undefined
     const { promise: lost, resolve: lose } = Promise.withResolvers();
     const exited = new Promise((resolve) => {
         const end = (cause) => {
+            over = true;
+            silence.stop();
             if (owned)
                 lose(cause);
             owned = false;
@@ -46,11 +87,13 @@ export async function startAdapter(kind, cli, cwd, app, events = () => undefined
         child.on('error', (error) => end(`the CLI did not start: ${error.message}`));
         child.on('exit', (code, signal) => {
             const last = stderr.trim().split('\n').at(-1);
-            end(`the CLI exited with ${code ?? signal}${last ? `: ${last}` : ''}`);
+            end(silent ? SILENT : `the CLI exited with ${code ?? signal}${last ? `: ${last}` : ''}`);
         });
     });
     const retire = () => {
         owned = false;
+        over = true;
+        silence.stop();
         if (retired)
             return;
         retired = true;
@@ -74,7 +117,11 @@ export async function startAdapter(kind, cli, cwd, app, events = () => undefined
             clientInfo: { name: '@agentshouse/kit', version: KIT_RELEASE },
         });
         scope?.entered(child.pid);
-        return { connection, initialized, exited, lost, retire };
+        const turn = (opened) => {
+            open = opened;
+            watch();
+        };
+        return { connection, initialized, exited, lost, silent: () => silent, turn, retire };
     }
     catch (error) {
         retire();

package/dist/authority-main.js

@@ -1,10 +1,10 @@
-import { setGlobalProxyFromEnv } from 'node:http';
 import { HouseRefusal, post } from './api.js';
 import { readEnrolment } from './home.js';
+import { proxyUnlessRelayed } from './relay.js';
 function unanswered(error) {
     return error instanceof HouseRefusal ? error.status >= 500 : error instanceof TypeError && error.message === 'fetch failed';
 }
-setGlobalProxyFromEnv();
+proxyUnlessRelayed();
 try {
     const { house, credential } = (await readEnrolment());
     try {

package/dist/building.js

@@ -0,0 +1,46 @@
+import { createHash } from 'node:crypto';
+import { createWriteStream } from 'node:fs';
+import { rm } from 'node:fs/promises';
+import { Transform } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { readEnrolment } from './home.js';
+import { relayed } from './relay.js';
+const MANIFEST = 'bootstrap.json';
+async function served(name, signal) {
+    const enrolment = await readEnrolment();
+    if (enrolment === null)
+        throw new Error('this Kit is connected to no House');
+    const answer = await fetch(relayed(new URL(`/kit-installer/${encodeURIComponent(name)}`, enrolment.house)), { signal });
+    if (answer.status === 200 && answer.body !== null)
+        return answer;
+    await answer.body?.cancel();
+    throw new Error(`House answered ${answer.status} for ${name}`);
+}
+export async function servedDigest(name, signal) {
+    const manifest = (await (await served(MANIFEST, signal)).json());
+    const sha256 = manifest.files?.[name]?.sha256;
+    return typeof sha256 === 'string' ? sha256 : null;
+}
+export async function downloadServed(name, sha256, destination, signal, most = Infinity) {
+    const answer = await served(name, signal);
+    const digest = createHash('sha256');
+    let bytes = 0;
+    const hashed = new Transform({
+        transform(chunk, _encoding, done) {
+            bytes += chunk.length;
+            if (bytes > most)
+                return done(new Error(`${name} is larger than its pinned ${most} bytes`));
+            digest.update(chunk);
+            done(null, chunk);
+        },
+    });
+    try {
+        await pipeline(answer.body, hashed, createWriteStream(destination), { signal });
+        if (digest.digest('hex') !== sha256)
+            throw new Error(`${name} does not match its sha256`);
+    }
+    catch (error) {
+        await rm(destination, { force: true });
+        throw error;
+    }
+}

package/dist/clis-main.js

@@ -1,8 +1,8 @@
-import { setGlobalProxyFromEnv } from 'node:http';
 import { post } from './api.js';
 import { CLIS, below, locate, versionOf } from './clis.js';
 import { readEnrolment } from './home.js';
-setGlobalProxyFromEnv();
+import { proxyUnlessRelayed } from './relay.js';
+proxyUnlessRelayed();
 try {
     const { house, credential } = (await readEnrolment());
     const { agents } = await post(house, '/kit/agents/desired', {}, credential);

package/dist/clis.js

@@ -1,10 +1,12 @@
 import { spawn } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
 import { constants, readFileSync } from 'node:fs';
-import { access, mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { access, mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
 import { homedir, userInfo } from 'node:os';
 import { delimiter, dirname, isAbsolute, join } from 'node:path';
+import { downloadServed, servedDigest } from './building.js';
 import { kitHome } from './home.js';
+import { childEnvironment } from './relay.js';
 const HOUSE_EXECUTABLES = /^host_executable\(name = "house", paths = (\[.*\])\)$/m;
 function houseRule(houses) {
     return `prefix_rule(pattern = ["house"], decision = "allow")\nhost_executable(name = "house", paths = ${JSON.stringify(houses)})\n`;
@@ -69,7 +71,7 @@ function bridgeInClaudeSandbox(bridge) {
 export const CLIS = {
     'codex-acp': {
         bin: 'codex',
-        minimum: '0.159.1',
+        minimum: '0.160.1',
         install: 'curl -fsSL https://chatgpt.com/codex/install.sh | sh',
         adapter: {
             package: '@agentclientprotocol/codex-acp',
@@ -92,7 +94,7 @@ export const CLIS = {
     },
     'claude-agent-acp': {
         bin: 'claude',
-        minimum: '2.1.286',
+        minimum: '2.1.303',
         install: 'curl -fsSL https://claude.ai/install.sh | bash',
         adapter: {
             package: '@agentclientprotocol/claude-agent-acp',
@@ -138,7 +140,6 @@ export const CLIS = {
 };
 const KIT_PACKAGE = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
 export const KIT_RELEASE = KIT_PACKAGE.version;
-const PROXY = /^https?_proxy$/i;
 const VERSION = /\d+\.\d+\.\d+(?:-[0-9A-Za-z.]+)?/;
 // An install still running after fifteen minutes is ended and reported as failed, so a hung download cannot hold its CLI's report.
 const INSTALL_MS = 15 * 60_000;
@@ -160,15 +161,12 @@ async function installedAdapter(kind) {
         return null;
     }
 }
-export function withoutProxy() {
-    return Object.fromEntries(Object.entries(process.env).filter(([name]) => !PROXY.test(name)));
-}
 export function run(command, args, timeoutMs, detached = false, signal) {
     return new Promise((resolve) => {
         const child = spawn(command, args, {
             stdio: ['ignore', 'pipe', 'pipe'],
             timeout: timeoutMs,
-            env: withoutProxy(),
+            env: childEnvironment(),
             detached,
             signal: detached ? undefined : signal,
         });
@@ -202,15 +200,37 @@ export function run(command, args, timeoutMs, detached = false, signal) {
 export function failureOf(ran, program) {
     return ran.output.trim().slice(-CAUSE_CHARACTERS) || `${program} exited with ${ran.status ?? 'a signal'}`;
 }
+export function adapterArchive(kind) {
+    return `${kind}-${KIT_PACKAGE.peerDependencies[CLIS[kind].adapter.package]}.tar.gz`;
+}
 export async function installAdapter(kind, signal) {
     const adapter = CLIS[kind].adapter;
     if (adapter === null)
         return null;
-    const release = KIT_PACKAGE.peerDependencies[adapter.package];
-    if ((await installedAdapter(kind)) === release)
+    if ((await installedAdapter(kind)) === KIT_PACKAGE.peerDependencies[adapter.package])
         return null;
-    const ran = await run('npm', ['install', '--prefix', prefix(kind), '--cache', join(kitHome(), 'npm-cache'), '--no-save', '--no-audit', '--no-fund', '--omit=optional', `${adapter.package}@${release}`], INSTALL_MS, true, signal);
-    return ran.status === 0 ? null : failureOf(ran, 'npm');
+    const name = adapterArchive(kind);
+    const archive = `${prefix(kind)}.tar.gz`;
+    const deadline = AbortSignal.timeout(INSTALL_MS);
+    const bounded = signal === undefined ? deadline : AbortSignal.any([signal, deadline]);
+    try {
+        const sha256 = await servedDigest(name, bounded);
+        if (sha256 === null)
+            return `House serves no ${name}`;
+        await rm(prefix(kind), { recursive: true, force: true });
+        await mkdir(prefix(kind), { recursive: true });
+        await downloadServed(name, sha256, archive, bounded);
+        const ran = await run('tar', ['-xzf', archive, '-C', prefix(kind)], INSTALL_MS, true, signal);
+        return ran.status === 0 ? null : failureOf(ran, 'tar');
+    }
+    catch (error) {
+        if (deadline.aborted && signal?.aborted !== true)
+            return `${name} did not arrive within ${INSTALL_MS / 1000} seconds`;
+        return error instanceof Error ? error.message : String(error);
+    }
+    finally {
+        await rm(archive, { force: true });
+    }
 }
 export async function installCli(kind, signal) {
     const ran = await run('bash', ['-o', 'pipefail', '-c', CLIS[kind].install], INSTALL_MS, true, signal);

package/dist/connection.js

@@ -3,40 +3,13 @@ import { HouseRefusal, retryDelay } from './api.js';
 import { end, REPLACED, signInAgain } from './end.js';
 import { readEnrolment } from './home.js';
 import { relayed } from './relay.js';
+import { Silence } from './silence.js';
 import { endUnserved, KIT_WIRE } from './wire.js';
 const PATH = '/kit/stream';
 const SUBPROTOCOL = `house.kit.stream.${KIT_WIRE}`;
 const REFUSAL_HEADER = 'x-house-refusal';
 // House beats each Kit connection every thirty seconds, so two silent beats mean this Kit process cannot hear House.
 export const CONNECTION_SILENCE_MS = 60_000;
-const SYSTEM_CONNECTION_CLOCK = {
-    later: (delay, callback) => setTimeout(callback, delay),
-    clear: (timer) => clearTimeout(timer),
-};
-export class ConnectionSilence {
-    timer = null;
-    silent;
-    clock;
-    interval;
-    constructor(silent, clock = SYSTEM_CONNECTION_CLOCK, interval = CONNECTION_SILENCE_MS) {
-        this.silent = silent;
-        this.clock = clock;
-        this.interval = interval;
-    }
-    heard() {
-        this.stop();
-        this.timer = this.clock.later(this.interval, () => {
-            this.timer = null;
-            this.silent();
-        });
-    }
-    stop() {
-        if (this.timer === null)
-            return;
-        this.clock.clear(this.timer);
-        this.timer = null;
-    }
-}
 function connectionUrl(house) {
     const url = new URL(PATH, house);
     url.protocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
@@ -58,19 +31,26 @@ subscribe('undici:request:headers', (message) => {
 });
 export function holdConnection(handlers) {
     let connection = null;
+    let socket = null;
+    let paused = false;
     let failures = 0;
     const connect = async () => {
         const { house, credential } = (await readEnrolment());
+        if (paused || socket !== null)
+            return;
         refused = null;
         const opening = new WebSocket(relayed(connectionUrl(house)), {
             protocols: [SUBPROTOCOL],
             headers: { authorization: `Bearer ${credential}` },
         });
+        socket = opening;
         let opened = false;
         let silence = null;
         const closed = (event) => {
             silence?.stop();
             silence = null;
+            if (socket === opening)
+                socket = null;
             if (connection === opening)
                 connection = null;
             handlers.closed();
@@ -85,6 +65,8 @@ export function holdConnection(handlers) {
                 endUnserved(refused.text);
             if (!opened && refused !== null)
                 process.stderr.write(`kit: ${refused.message}\n`);
+            if (paused)
+                return;
             // A closed connection reopens in one to three seconds, spread so Kit processes one restart closed return apart; an opening House refused or left unanswered backs off on the jittered curve, retryable or not, since a resident outlives a House deploy.
             setTimeout(() => void connect(), opened ? 1000 + Math.random() * 2000 : retryDelay(failures++));
         };
@@ -92,7 +74,7 @@ export function holdConnection(handlers) {
             opened = true;
             failures = 0;
             connection = opening;
-            silence = new ConnectionSilence(() => {
+            silence = new Silence(CONNECTION_SILENCE_MS, () => {
                 if (connection !== opening)
                     return;
                 connection = null;
@@ -122,5 +104,13 @@ export function holdConnection(handlers) {
             connection.send(JSON.stringify(notification));
             return true;
         },
+        pause() {
+            paused = true;
+            socket?.close();
+            return () => {
+                paused = false;
+                void connect();
+            };
+        },
     };
 }

package/dist/conversations.js

@@ -73,7 +73,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)}`;
@@ -585,6 +587,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.open > 0);
             conversation.session = running.sessionId;
             conversation.options = options;
             this.facts(conversation);
@@ -702,6 +705,7 @@ export class Conversations {
     begin(conversation) {
         const turn = new Turn((operation) => this.write(conversation, turn, operation));
         conversation.open++;
+        conversation.running?.adapter.turn(true);
         void this.deliver(conversation, turn, 'started', {}).catch(logged);
         conversation.turn = turn;
         if (conversation.context !== null)
@@ -724,6 +728,7 @@ export class Conversations {
             turn.parts.start({ type: 'marker', marker: 'retry', text: notice });
         turn.ended = true;
         conversation.open--;
+        conversation.running?.adapter.turn(conversation.open > 0);
         if (conversation.turn === turn)
             conversation.turn = null;
         const body = Promise.allSettled(turn.uploads).then(() => ({

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

@@ -119,7 +119,7 @@ export async function login(argv) {
         open(started.start_url);
         exchanged = await retrying(() => post(house, '/kit/token', { login: started.login, code_verifier: verifier }), undefined, () => POLL_INTERVAL_MS);
     }
-    await placeSkillSet();
+    await placeSkillSet(house);
     await writeCodexRule().catch((error) => process.stderr.write(`kit: ${error.message}\n`));
     const relayRecord = relay === undefined ? {} : { relay };
     await writeEnrolment({

package/dist/relay.js

@@ -1,6 +1,11 @@
+import { setGlobalProxyFromEnv } from 'node:http';
+const PROXY = /^https?_proxy$/i;
+const LOOPBACK = ['127.0.0.1', 'localhost', '::1'];
 let selected;
+let restoreProxy;
 export function selectRelay(relay) {
     selected = relay === undefined || relay === '' ? null : relay;
+    proxyUnlessRelayed();
 }
 export function relayOrigin() {
     if (selected !== undefined)
@@ -8,6 +13,22 @@ export function relayOrigin() {
     const ambient = process.env.HOUSE_KIT_RELAY;
     return ambient === undefined || ambient === '' ? undefined : ambient;
 }
+function unlessRelayed() {
+    if (relayOrigin() === undefined)
+        return { ...process.env };
+    return Object.fromEntries(Object.entries(process.env).filter(([name]) => !PROXY.test(name)));
+}
+export function proxyUnlessRelayed() {
+    restoreProxy?.();
+    restoreProxy = setGlobalProxyFromEnv(unlessRelayed());
+}
+export function childEnvironment() {
+    const environment = unlessRelayed();
+    if (!Object.keys(environment).some((name) => PROXY.test(name)))
+        return environment;
+    const bypassed = [environment.NO_PROXY ?? environment.no_proxy, ...LOOPBACK].filter((entry) => entry !== undefined && entry !== '').join(',');
+    return { ...environment, NO_PROXY: bypassed, no_proxy: bypassed };
+}
 export function relayed(target) {
     const url = new URL(target);
     const relay = relayOrigin();

package/dist/resident.js

@@ -11,7 +11,7 @@ import { received } from './bridge.js';
 import { CONVERSATION_METHODS, Conversations } from './conversations.js';
 import { LocalCopies } from './copies.js';
 import { restart } from './end.js';
-import { agentBase, enrolled, forgetRestart, kitHome, ownerLock, ownerSocket, restartAsked } from './home.js';
+import { agentBase, enrolled, forgetRestart, kitHome, ownerLock, ownerSocket, readEnrolment, restartAsked } from './home.js';
 import { Calls } from './calls.js';
 import { killDescendants } from './scope.js';
 import { quoted } from './shell.js';
@@ -117,7 +117,7 @@ async function started() {
         killDescendants();
         process.exit(1);
     });
-    await placeSkillSet();
+    await placeSkillSet((await readEnrolment()).house);
     await mkdir(agentBase(), { recursive: true });
     await installShim(join(kitHome(), 'shim', 'git'), 'git-main');
     await installShim(codexLauncher(), 'codex-main');
@@ -143,6 +143,9 @@ export async function resident() {
         else if (restartAsked() && conversations.quiet()) {
             restart('restarting for an updated CLI');
         }
+        else if (update.held() && conversations.quiet()) {
+            update.apply(connection.pause());
+        }
         else if (!reported) {
             reported = true;
             logged(house.deliver('/kit/idle', {}, idle));
@@ -158,7 +161,7 @@ export async function resident() {
         changed,
     });
     const signIns = new SignIns(house, agents, calls);
-    const update = new KitUpdate(calls);
+    const update = new KitUpdate(calls, changed);
     const wizards = new WebWizards(calls, (notification) => connection?.send(notification) ?? false);
     for (const signal of ['SIGTERM', 'SIGINT']) {
         process.once(signal, () => {
@@ -180,7 +183,7 @@ export async function resident() {
             if (call.kind === 'sign_in')
                 signIns.start(call);
             else if (call.kind === 'update')
-                update.start(call);
+                update.hold(call);
             else if (call.kind === 'run_wizard')
                 wizards.start(call);
             else if (CONVERSATION_METHODS.has(call.kind))

package/dist/sign-in.js

@@ -1,6 +1,7 @@
 import { spawn } from 'node:child_process';
 import { createInterface } from 'node:readline';
-import { CLIS, withoutProxy } from './clis.js';
+import { CLIS } from './clis.js';
+import { childEnvironment } from './relay.js';
 import { killTree } from './scope.js';
 import { holdSecretInput } from './secret-input.js';
 const ESCAPE = /\u001b\[[\d;]*m/g;
@@ -56,7 +57,7 @@ export class SignIns {
         const child = spawn(cli, login.args, {
             stdio: ['pipe', 'pipe', 'pipe'],
             detached: true,
-            env: withoutProxy(),
+            env: childEnvironment(),
         });
         const running = () => child.exitCode === null && child.signalCode === null;
         const stop = () => killTree(child);

package/dist/silence.js

@@ -0,0 +1,28 @@
+const SYSTEM_CLOCK = {
+    later: (delay, callback) => setTimeout(callback, delay),
+    clear: (timer) => clearTimeout(timer),
+};
+export class Silence {
+    timer = null;
+    interval;
+    silent;
+    clock;
+    constructor(interval, silent, clock = SYSTEM_CLOCK) {
+        this.interval = interval;
+        this.silent = silent;
+        this.clock = clock;
+    }
+    heard() {
+        this.stop();
+        this.timer = this.clock.later(this.interval, () => {
+            this.timer = null;
+            this.silent();
+        });
+    }
+    stop() {
+        if (this.timer === null)
+            return;
+        this.clock.clear(this.timer);
+        this.timer = null;
+    }
+}

package/dist/skills.js

@@ -1,10 +1,14 @@
-import { cp, lstat, mkdir, realpath, rm, symlink } from 'node:fs/promises';
+import { cp, lstat, mkdir, realpath, rm, symlink, writeFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join, relative } from 'node:path';
-import { listSkills } from '@agentshouse/skills';
+import { GUIDE, listSkills } from '@agentshouse/skills';
+import { parse } from 'yaml';
 import { KIT_RELEASE } from './clis.js';
 import { kitHome, readConfiguration, readHome, writeHome } from './home.js';
 const RECORD = 'skill-set.json';
+const ENTRY = 'SKILL.md';
+const FRONTMATTER = /^---\n([\s\S]*?)\n---\n/u;
+const ORIGIN = '<origin>';
 function skillsDirectory() {
     return join(homedir(), '.agents', 'skills');
 }
@@ -22,9 +26,31 @@ async function present(path) {
         throw error;
     }
 }
-async function install() {
+function skillName(text) {
+    const front = FRONTMATTER.exec(text);
+    const fields = (front === null ? null : parse(front[1]));
+    return typeof fields?.name === 'string' && typeof fields.description === 'string' ? fields.name : undefined;
+}
+function skillSet(origin) {
+    const upstream = listSkills().map(({ name, directory }) => ({
+        name,
+        place: (destination) => cp(directory, destination, { recursive: true }),
+    }));
+    const pages = GUIDE.flatMap(({ text }) => {
+        const name = skillName(text);
+        if (name === undefined)
+            return [];
+        const place = async (destination) => {
+            await mkdir(destination);
+            await writeFile(join(destination, ENTRY), text.replaceAll(ORIGIN, origin));
+        };
+        return [{ name, place }];
+    });
+    return [...upstream, ...pages].sort((left, right) => (left.name < right.name ? -1 : 1));
+}
+async function install(origin) {
     const placed = [];
-    for (const skill of listSkills()) {
+    for (const skill of skillSet(origin)) {
         if (!(await present(join(skillsDirectory(), skill.name))) && !(await present(join(claudeDirectory(), skill.name)))) {
             placed.push(skill);
         }
@@ -35,32 +61,32 @@ async function install() {
     await mkdir(claudeDirectory(), { recursive: true });
     const skills = await realpath(skillsDirectory());
     const claude = await realpath(claudeDirectory());
-    for (const { name, directory } of placed) {
-        await cp(directory, join(skillsDirectory(), name), { recursive: true });
+    for (const { name, place } of placed) {
+        await place(join(skillsDirectory(), name));
         if (claude !== skills)
             await symlink(relative(claude, join(skills, name)), join(claudeDirectory(), name));
     }
-    await writeHome(RECORD, { version: KIT_RELEASE, names });
+    await writeHome(RECORD, { version: KIT_RELEASE, origin, names });
 }
-export async function placeSkillSet() {
+export async function placeSkillSet(origin) {
     try {
-        await replaceSkillSet();
+        await replaceSkillSet(origin);
     }
     catch (error) {
         process.stderr.write(`kit: the skills could not be placed: ${error.message}\n`);
     }
 }
-async function replaceSkillSet() {
+async function replaceSkillSet(origin) {
     const accepted = (await readConfiguration()).skills;
     const installed = await readHome(RECORD);
-    if (accepted && installed?.version === KIT_RELEASE)
+    if (accepted && installed?.version === KIT_RELEASE && installed.origin === origin)
         return;
     for (const name of installed?.names ?? []) {
         await rm(join(claudeDirectory(), name), { recursive: true, force: true });
         await rm(join(skillsDirectory(), name), { recursive: true, force: true });
     }
     if (accepted)
-        await install();
+        await install(origin);
     else
         await rm(join(kitHome(), RECORD), { force: true });
 }

package/dist/transcription.js

@@ -1,32 +1,31 @@
-import { createHash } from 'node:crypto';
-import { createReadStream } from 'node:fs';
 import { chmod, mkdir, mkdtemp, readdir, readFile, rename, rm, stat } from 'node:fs/promises';
 import { availableParallelism, tmpdir } from 'node:os';
 import { basename, join } from 'node:path';
-import { pipeline } from 'node:stream/promises';
 import { unlessAborted } from './abort.js';
+import { downloadServed } from './building.js';
 import { failureOf, run } from './clis.js';
 import { downloaded, fetched } from './files.js';
 import { kitHome } from './home.js';
 const RELEASE = 'https://github.com/agentshouse/kit/releases/download/engine-2';
 export const MODEL = {
-    url: 'https://huggingface.co/ggml-org/parakeet-GGUF/resolve/35156454d1a39de06863303dd209fd2bed6ee079/ggml-parakeet-tdt-0.6b-v3-q4_k.bin',
+    name: 'ggml-parakeet-tdt-0.6b-v3-q4_k.bin',
+    from: 'https://huggingface.co/ggml-org/parakeet-GGUF/resolve/35156454d1a39de06863303dd209fd2bed6ee079/ggml-parakeet-tdt-0.6b-v3-q4_k.bin',
     sha256: '8b205b8b39c6535e153de6fb11c51db46125d45c4f16ba496fe41a0fe71b885e',
     bytes: 415_611_879,
     executable: false,
 };
 export const ENGINES = {
     'linux-x64': {
-        decoder: { url: `${RELEASE}/ffmpeg-linux-x86_64`, sha256: '1f8235d206428305afb89c6e8ab99d100425a0ba61e22bb4c7aff017db8c8de5', bytes: 5_175_832, executable: true },
-        engine: { url: `${RELEASE}/parakeet-cli-linux-x86_64`, sha256: 'bb2585695992fe1927a33960002cdf51b8a90a96ad65593c3d0a9f1fbc0865c2', bytes: 3_801_616, executable: true },
+        decoder: { name: 'ffmpeg-linux-x86_64', from: `${RELEASE}/ffmpeg-linux-x86_64`, sha256: '1f8235d206428305afb89c6e8ab99d100425a0ba61e22bb4c7aff017db8c8de5', bytes: 5_175_832, executable: true },
+        engine: { name: 'parakeet-cli-linux-x86_64', from: `${RELEASE}/parakeet-cli-linux-x86_64`, sha256: 'bb2585695992fe1927a33960002cdf51b8a90a96ad65593c3d0a9f1fbc0865c2', bytes: 3_801_616, executable: true },
     },
     'linux-arm64': {
-        decoder: { url: `${RELEASE}/ffmpeg-linux-aarch64`, sha256: 'a7e08a0fae0179d1078312f6bb13d2a9aa4d4c71a1d82a022953f25dee452f5e', bytes: 4_590_208, executable: true },
-        engine: { url: `${RELEASE}/parakeet-cli-linux-aarch64`, sha256: 'cbc0bedc8daae97f1ef9dcee4200c06226218e300e0fd62ead1306d22742b7ed', bytes: 3_477_624, executable: true },
+        decoder: { name: 'ffmpeg-linux-aarch64', from: `${RELEASE}/ffmpeg-linux-aarch64`, sha256: 'a7e08a0fae0179d1078312f6bb13d2a9aa4d4c71a1d82a022953f25dee452f5e', bytes: 4_590_208, executable: true },
+        engine: { name: 'parakeet-cli-linux-aarch64', from: `${RELEASE}/parakeet-cli-linux-aarch64`, sha256: 'cbc0bedc8daae97f1ef9dcee4200c06226218e300e0fd62ead1306d22742b7ed', bytes: 3_477_624, executable: true },
     },
     'darwin-arm64': {
-        decoder: { url: `${RELEASE}/ffmpeg-darwin-arm64`, sha256: '7abe154aaed3d6b49f5167ca7221bb66bed51388925d99a7e4261a41fe52fba6', bytes: 3_696_768, executable: true },
-        engine: { url: `${RELEASE}/parakeet-cli-darwin-arm64`, sha256: '9a2aafc0922ad7c0b6db6eff1641e96572ba32ac40bf995a1df242ed2febf297', bytes: 1_939_728, executable: true },
+        decoder: { name: 'ffmpeg-darwin-arm64', from: `${RELEASE}/ffmpeg-darwin-arm64`, sha256: '7abe154aaed3d6b49f5167ca7221bb66bed51388925d99a7e4261a41fe52fba6', bytes: 3_696_768, executable: true },
+        engine: { name: 'parakeet-cli-darwin-arm64', from: `${RELEASE}/parakeet-cli-darwin-arm64`, sha256: '9a2aafc0922ad7c0b6db6eff1641e96572ba32ac40bf995a1df242ed2febf297', bytes: 1_939_728, executable: true },
     },
 };
 const CHUNK_SECONDS = 20;
@@ -47,7 +46,7 @@ function installed(artifact) {
     return join(directory(), artifact.sha256);
 }
 async function executed(command, args, signal) {
-    // A download or a transcription runs as long as its size needs; a download's deadline, the setting turning off or the turn's interrupt or end aborts it instead.
+    // A decode or a transcription runs as long as its audio needs; the setting turning off or the turn's interrupt or end aborts it instead.
     const ran = await run(command, args, 0, false, signal);
     if (ran.status !== 0)
         throw new Error(failureOf(ran, basename(command)));
@@ -61,11 +60,6 @@ async function threads() {
     const allowed = quota === 'max' ? Infinity : Math.ceil(Number(quota) / Number(period));
     return Math.max(1, Math.floor(Math.min(availableParallelism(), allowed) / 2));
 }
-async function sha256(path) {
-    const hash = createHash('sha256');
-    await pipeline(createReadStream(path), hash);
-    return hash.digest('hex');
-}
 function causeOf(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -86,6 +80,25 @@ function ready() {
 function pinnedHere() {
     return ENGINES[`${process.platform}-${process.arch}`];
 }
+const DOWNLOADS = 3;
+async function downloadedAgain(artifact, signal) {
+    // An artifact arrives at a hundred kilobytes a second or its download ends, so a stalled Building cannot hold the install open.
+    const deadlineMs = Math.ceil(artifact.bytes / 100);
+    const deadline = AbortSignal.timeout(deadlineMs);
+    for (let attempt = 1;; attempt++) {
+        try {
+            return await downloadServed(artifact.name, artifact.sha256, `${installed(artifact)}.part`, AbortSignal.any([signal, deadline]), artifact.bytes);
+        }
+        catch (error) {
+            if (signal.aborted)
+                throw error;
+            if (deadline.aborted)
+                throw new Error(`${artifact.name} did not arrive within ${Math.ceil(deadlineMs / 1000)} seconds`);
+            if (attempt === DOWNLOADS)
+                throw error;
+        }
+    }
+}
 async function install(artifacts, signal) {
     await mkdir(directory(), { recursive: true });
     const pinned = new Set(artifacts.map((artifact) => artifact.sha256));
@@ -98,25 +111,8 @@ async function install(artifacts, signal) {
         if (!(await present(installed(artifact))))
             missing.push(artifact);
     try {
-        for (const artifact of missing) {
-            const part = `${installed(artifact)}.part`;
-            // An artifact arrives at a hundred kilobytes a second or its download ends, so a stalled host cannot hold the install open.
-            const deadlineMs = Math.ceil(artifact.bytes / 100);
-            const deadline = AbortSignal.timeout(deadlineMs);
-            // Three retries carry a large download past a dropped connection before the download fails.
-            try {
-                await executed('bash', ['-c', 'trap "" XFSZ && ulimit -f "$1" && exec curl -fsSL --retry 3 -o "$2" "$3"', 'bash', String(Math.ceil(artifact.bytes / 1024)), part, artifact.url], AbortSignal.any([signal, deadline]));
-            }
-            catch (error) {
-                if (((await stat(part).catch(() => null))?.size ?? 0) >= artifact.bytes)
-                    throw new Error(`${artifact.url} is larger than its pinned ${artifact.bytes} bytes`);
-                if (deadline.aborted && !signal.aborted)
-                    throw new Error(`${artifact.url} did not arrive within ${Math.ceil(deadlineMs / 1000)} seconds`);
-                throw error;
-            }
-            if ((await sha256(part)) !== artifact.sha256)
-                throw new Error(`${artifact.url} does not match its sha256`);
-        }
+        for (const artifact of missing)
+            await downloadedAgain(artifact, signal);
         for (const artifact of missing) {
             if (artifact.executable)
                 await chmod(`${installed(artifact)}.part`, 0o755);

package/dist/update.js

@@ -6,9 +6,13 @@ import { join } from 'node:path';
 import { run } from './clis.js';
 import { kitHome, workspaceRoot } from './home.js';
 import { service, throughSudo } from './placement.js';
+import { relayed } from './relay.js';
 const BOOTSTRAP_BYTES = 1_000_000;
 // A bootstrap is at most a million bytes, so two minutes carry it over ten kilobytes a second and no stalled host holds the update queue.
 const BOOTSTRAP_MS = 120_000;
+// A bootstrap's downloads and CLI updates take minutes, so one still running after an hour has hung and is ended before it keeps the Kit offline.
+const RERUN_MS = 60 * 60_000;
+const TIMED_OUT = '124';
 function directory() {
     return join(kitHome(), 'update');
 }
@@ -34,7 +38,7 @@ function placement() {
     return service() === 'user' ? ['--workspace', workspaceRoot()] : ['--linux'];
 }
 function record() {
-    return `outcome=$1; shift; bash "$0" "$@"; printf %s "$?" > "$outcome"; ${[...elevated(), 'systemctl', ...manager(), 'start', 'house-kit.service'].join(' ')}`;
+    return `outcome=$1; shift; timeout ${RERUN_MS / 1000} bash "$0" "$@"; printf %s "$?" > "$outcome"; ${[...elevated(), 'systemctl', ...manager(), 'start', 'house-kit.service'].join(' ')}`;
 }
 async function pendingCall() {
     try {
@@ -48,6 +52,8 @@ async function recorded() {
     const status = await readFile(outcome(), 'utf8').catch(() => null);
     if (status === null)
         return null;
+    if (status.trim() === TIMED_OUT)
+        return { refused: `the Kit bootstrap did not finish within ${RERUN_MS / 1000} seconds` };
     return status.trim() === '0' ? {} : { refused: `the Kit bootstrap exited with ${status.trim()}` };
 }
 async function forget(callId) {
@@ -108,9 +114,12 @@ function rerun(script, callId, flags) {
 }
 export class KitUpdate {
     calls;
+    changed;
+    waiting = new Map();
     queue = Promise.resolve();
-    constructor(calls) {
+    constructor(calls, changed) {
         this.calls = calls;
+        this.changed = changed;
     }
     async resumed() {
         const callId = await pendingCall();
@@ -118,8 +127,17 @@ export class KitUpdate {
             return;
         await this.enqueue(callId, () => finished(callId));
     }
-    start(call) {
-        void this.enqueue(call.input_id, () => this.carry(call));
+    hold(call) {
+        this.waiting.set(call.input_id, call);
+        this.changed();
+    }
+    held() {
+        return this.waiting.size > 0;
+    }
+    apply(resume) {
+        const held = [...this.waiting.values()];
+        this.waiting.clear();
+        void Promise.all(held.map((call) => this.enqueue(call.input_id, () => this.carry(call)))).then(resume);
     }
     enqueue(callId, work) {
         const before = this.queue;
@@ -136,7 +154,7 @@ export class KitUpdate {
         const deadline = AbortSignal.timeout(BOOTSTRAP_MS);
         let script;
         try {
-            const answer = await fetch(call.bootstrap, { signal: deadline });
+            const answer = await fetch(relayed(call.bootstrap), { signal: deadline });
             if (!answer.ok)
                 return { refused: `the Kit bootstrap could not be downloaded: ${answer.status}` };
             script = await bounded(answer.body, BOOTSTRAP_BYTES);

package/dist/web-wizard.js

@@ -1,4 +1,5 @@
-import { loginPath, onLoginPath, withoutProxy } from './clis.js';
+import { loginPath, onLoginPath } from './clis.js';
+import { childEnvironment } from './relay.js';
 import { killTree } from './scope.js';
 const TERMINAL = 'xterm-256color';
 const SIGNALLED = 128;
@@ -62,7 +63,7 @@ export class WebWizards {
                 name: TERMINAL,
                 ...run.size,
                 cwd: process.cwd(),
-                env: { ...withoutProxy(), PATH: path },
+                env: { ...childEnvironment(), PATH: path },
             });
         }
         catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentshouse/kit",
-  "version": "0.2.1-c03721a31074a",
+  "version": "0.2.1-c0535b8294007",
   "description": "Kit connects an Environment to agents.house.",
   "license": "MIT",
   "repository": {
@@ -12,28 +12,27 @@
     "kit": "dist/kit-main.js",
     "house": "dist/house-main.js"
   },
-  "exports": {
-    "./bootstrap": "./dist/bootstrap.json"
-  },
   "files": [
     "dist"
   ],
   "scripts": {
-    "build": "tsc -p tsconfig.build.json && node scripts/bootstrap-manifest.mjs",
+    "bootstrap-manifest": "node scripts/bootstrap-manifest.mjs",
+    "build": "tsc -p tsconfig.build.json",
     "engine": "mkdir -p tmp/engine && docker run --rm -v \"$PWD:/kit\" -w /kit alpine:3.24@sha256:294b683cb724975bec92580e1e685676bd4b50bda910ddb8c51d4cabeaec77e6 sh scripts/engine.sh tmp/engine",
     "follow-skills": "node scripts/follow-skills.mjs",
+    "release-files": "node scripts/release-files.mjs",
     "test": "tsc -p tsconfig.json && vitest run"
   },
   "dependencies": {
-    "@agentclientprotocol/sdk": "1.7.0",
-    "@agentshouse/mdmodel": "0.1.0-cabd61587647f",
-    "@agentshouse/skills": "0.1.0-c34ad2b295b4a",
+    "@agentclientprotocol/sdk": "2.0.1",
+    "@agentshouse/mdmodel": "0.1.0-c4f4d37bc9d6a",
+    "@agentshouse/skills": "0.1.0-c08575ab21b57",
     "@lydell/node-pty": "1.2.0-beta.15",
     "yaml": "2.9.1"
   },
   "peerDependencies": {
-    "@agentclientprotocol/claude-agent-acp": "0.85.1",
-    "@agentclientprotocol/codex-acp": "2.1.1"
+    "@agentclientprotocol/claude-agent-acp": "0.94.0",
+    "@agentclientprotocol/codex-acp": "2.2.2"
   },
   "peerDependenciesMeta": {
     "@agentclientprotocol/claude-agent-acp": {
@@ -44,10 +43,10 @@
     }
   },
   "devDependencies": {
-    "@types/node": "24.13.6",
+    "@types/node": "24.19.2",
     "@types/ws": "8.18.2",
     "typescript": "7.0.2",
-    "vitest": "5.0.1",
+    "vitest": "5.0.5",
     "ws": "8.22.0"
   },
   "packageManager": "npm@11.19.1",

package/dist/bootstrap.json

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