@agentshouse/kit 0.2.1-cca496635583e → 0.2.1-ccb257fa8a318

package/README.md

@@ -1,59 +1,60 @@
-# House Kit
+# Kit
 
-House Kit connects an Environment, a Linux computer or server, to [agents.house](https://agents.house). It runs
+Kit connects an Environment, a Linux computer or server, to [agents.house](https://agents.house). It runs
 your Agents' conversations through the agent CLIs you chose and gives each Agent the `house` command.
 
 ## Install
 
-Run `curl -fsSL agents.house/kit | sh`, or `irm agents.house/kit.ps1 | iex` on Windows, and again to update;
-options follow `sh -s --`. On macOS and Linux it installs House Kit natively under your own account, without an admin password,
-as a service that runs while you are logged in. `kit` and `house` are then on
-your login shell's `PATH`, and your workspace is `~/AgentsHouse` unless you
+Run `sh -c 'kit=$(curl -fsSL "$0") || { echo "Kit could not be downloaded; run this command again." >&2; exit 1; }; eval "$kit"' agents.house/kit`,
+or `& { try { $kit = irm agents.house/kit.ps1 } catch { throw 'Kit could not be downloaded; run this command again.' }; & ([scriptblock]::Create($kit)) @args }` on Windows, which run nothing of a failed download, and again to update; options follow `agents.house/kit`.
+On macOS and Linux it installs Kit natively under your own account, without an admin password, as a service that runs
+while you are logged in. `kit` and `house` are then on your login shell's `PATH`, and your workspace is `~/AgentsHouse` unless you
 pass `--workspace <path>`.
 
-Add `--container` to run House Kit in one Docker container instead, with your
+Add `--container` to run Kit in one Docker container instead, with your
 workspace mounted at `/agents/house`; your Agents then reach only that
-workspace. On Windows 11 the container is the one choice. Append a `kit` or
-`house` command to the container's options to run it in that container.
+workspace. On Windows 11 the container is the one choice. Append a `kit` or `house` command to the container's options to run it in that container.
 Running the command for the other choice on a connected computer asks you to
-confirm, then replaces its Environment, whose Agents end, with a new one.
+confirm, then replaces its Environment, whose Agents end, with a new one. Running it with a different `HOUSE_KIT_HOME`
+from the running Kit process asks you to confirm before it replaces that process, and leaves the earlier Kit home as it was.
 
 On your own Linux server, run the Linux command with `--linux` to
-install House Kit natively, with its workspace at `/agents/house`; `kit` and
+install 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
+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.
+each CLI older than Kit needs; add `--update-clis` to update every one to
+its latest release without asking. Kit also gives every Agent on the
+Environment the agent skills of `@agentshouse/skills`, at the version each Kit
+release installs. Add `--no-skills` to the command to leave them out; running it again without the flag brings them back.
 
 ## Commands
 
 `kit login` opens or prints a link you confirm in any browser, on this computer
 or another, continues on its own and keeps the Environment's credential in
-`~/.house-kit`, or in `$HOUSE_KIT_HOME` when it is set. `--environment <id>`
+`$HOUSE_KIT_HOME` when it is set, else in `~/.house-kit`, or in `house-kit-<uid>` under the temporary directory when your home is read-only. `--environment <id>`
 reconnects an Environment you already have; `--rooms <ref>[,<ref>...]` gives it
-only those Rooms and `--no-private` every Room but your Private Room;
-`--code <code>` connects immediately without a link.
+only those Rooms and `--no-private` every Room but your Private Room; `--code <code>` connects immediately without a link.
 A login also connects your own agent: outside an Agent conversation, `house <tool>` calls
-House as you and `git` clones and pushes your Apps at `<house>/app/` as you,
-until you revoke that connection on Connections. `house help` lists the Tools.
-`kit logout` disconnects this computer, stops House Kit and ends your own
-agent's connection, so `house` and `git` no longer act as you here; a later
-`kit login` reconnects the same Environment.
-
-`kit resident` keeps the Environment connected and, as it connects, copies each
-Room you chose for it as a Git repository in the workspace's `local-copies`.
-`house fetch` records House's changes on each copy's `refs/house/received`;
-rebase onto it, commit and run `house push --owner` in the copy, through the
-install command in the container. An Agent runs both, without `--owner`.
-
-House Kit turns each audio file of your message to an Agent into text on this
-computer before the Agent reads it. While transcription is on, the speech
-engine and model use about 425 MB in `~/.house-kit`; turning it off deletes them.
+House as you and `git` clones and pushes your Apps at `<house>/app/` as you, each through the Kit
+home `$HOUSE_KIT_HOME` names where it runs, until you revoke that connection on Connections. `house help` lists the Tools. Codex sessions started after a
+login run a lone `house` command outside their sandbox. `kit logout` disconnects this
+computer, stops the Kit process and ends your own agent's connection, so `house` and `git` no
+longer act as you here; a later `kit login` reconnects the same Environment, or connects
+this computer as a new one when House no longer holds it.
+In a container you do not control, such as ChatGPT's, `npm i -g @agentshouse/kit` and `kit chatgpt --key <key>` with a key made on Connections let `house <tool>` act as you, starting and configuring nothing else.
+
+`kit resident` keeps the Environment connected and, as it connects, copies the text of each Room you chose for it as a
+Git repository in the workspace's `local-copies`, and keeps a Room's copy as it is, no longer refreshing it, once the
+Room may no longer be copied here. `house fetch` does the same and records House's changes on each copy's
+`refs/house/received`; rebase onto it, commit and run `house push --owner` in the copy, through the install command in
+the container. An Agent runs both, without `--owner`. `house upload` and `house download` move a Room's other files straight between disk and House's store, and a broken upload resumes on its own.
+
+Kit turns each audio file your message to an Agent links into text on this computer before the Agent reads it, and keeps a message whose audio it cannot turn into text from starting. While transcription is on, the speech engine and model use about 425 MB beside the Environment's credential; turning it off deletes them.
+
+When you press Run on a Web Wizard's page, Kit runs its script with `bash` in a terminal on this computer, as you, in the home and directory it runs agent CLIs from, with your login shell's `PATH`; the page shows that terminal and takes your typing, and closing the page, or Kit losing its connection to House, ends the script and its child processes. Kit keeps nothing the script prints or you type. A script you keep as a function from a Web Wizard runs as you, from the same home, directory and `PATH`, when a Trigger of your Private Room or your agent runs it, with no terminal and nothing on its standard input, and when you press Run now on its page, in a terminal you can type into. Kit writes the run's input as JSON to a file only you can read, whose path is in `HOUSE_INPUT`, and deletes it when the run ends; it ends the script and its child processes at the run's time limit or when it loses its connection to House, and sends House the end of what the script printed, up to the run's output limit, without any line that holds a line you typed.
 
 ## License
 
-MIT. The skills come from [mattpocock/skills](https://github.com/mattpocock/skills); thank you, Matt Pocock.
+MIT.

package/dist/acp.js

@@ -1,46 +1,109 @@
 import { ndJsonStream, PROTOCOL_VERSION, } from '@agentclientprotocol/sdk';
 import { spawn } from 'node:child_process';
 import { Readable, Writable } from 'node:stream';
-import { CLIS, KIT_VERSION, 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,
     });
-    const stop = () => killTree(child);
-    signal?.addEventListener('abort', stop, { once: true });
-    child.on('exit', () => signal?.removeEventListener('abort', stop));
+    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 exited = new Promise((resolve) => {
-        child.on('error', (error) => resolve(`the CLI did not start: ${error.message}`));
-        child.on('exit', (code, signal) => {
-            const last = stderr.trim().split('\n').at(-1);
-            resolve(`the CLI exited with ${code ?? signal}${last ? `: ${last}` : ''}`);
-        });
-    });
     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;
-                events(read);
+                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('_'))) {
                     controller.enqueue(message);
                 }
             },
         })),
     });
-    void exited.then((cause) => connection.close(new Error(cause)));
+    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;
+            connection.close(new Error(cause));
+            resolve(cause);
+        };
+        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(silent ? SILENT : `the CLI exited with ${code ?? signal}${last ? `: ${last}` : ''}`);
+        });
+    });
+    const retire = () => {
+        owned = false;
+        over = true;
+        silence.stop();
+        if (retired)
+            return;
+        retired = true;
+        if (child.pid !== undefined)
+            killTree(child);
+        scope?.kill();
+        connection.close(new Error(RETIRED));
+    };
+    signal?.addEventListener('abort', retire, { once: true });
+    child.on('exit', () => signal?.removeEventListener('abort', retire));
     try {
         const initialized = await connection.agent.request('initialize', {
             protocolVersion: PROTOCOL_VERSION,
@@ -51,13 +114,17 @@ export async function startAdapter(kind, cli, cwd, app, events = () => undefined
                 session: { compaction: {}, notices: {} },
                 _meta: { jetbrains: { air: { version: 1, capabilities: CLIS[kind].air } } },
             },
-            clientInfo: { name: '@agentshouse/kit', version: KIT_VERSION },
+            clientInfo: { name: '@agentshouse/kit', version: KIT_RELEASE },
         });
         scope?.entered(child.pid);
-        return { child, connection, initialized, exited };
+        const turn = (opened) => {
+            open = opened;
+            watch();
+        };
+        return { connection, initialized, exited, lost, silent: () => silent, turn, retire };
     }
     catch (error) {
-        child.kill('SIGKILL');
+        retire();
         throw error;
     }
 }

package/dist/agents.js

@@ -1,11 +1,16 @@
 import { client } from '@agentclientprotocol/sdk';
 import { readFile, realpath } from 'node:fs/promises';
+import { setTimeout as delay } from 'node:timers/promises';
 import { startAdapter } from './acp.js';
-import { CLIS, KIT_VERSION, below, installAdapter, installCli, locate, run, versionOf } from './clis.js';
+import { CLIS, KIT_RELEASE, below, installAdapter, installCli, locate, run, versionOf } from './clis.js';
 import { agentBase, kitHome } from './home.js';
-import { killTree } from './scope.js';
+import { updatesItself } from './placement.js';
 import { holdTranscription, transcriptionReport } from './transcription.js';
+import { KIT_WIRE } from './wire.js';
+// Two quiet seconds let a fresh conversation start before background model discovery competes for its CPU.
+const MODEL_PROBE_QUIET_MS = 2_000;
 const SIGNED_OUT = { signed_in: false, models: [], modes: [] };
+const INSTALLING = { release: null, failure: null, installing: true, ...SIGNED_OUT };
 function select(options, category) {
     const option = options.find((candidate) => candidate.category === category);
     return option?.type === 'select' ? option : undefined;
@@ -22,6 +27,22 @@ function causeOf(error) {
 function logged(error) {
     process.stderr.write(`kit: ${causeOf(error)}\n`);
 }
+const LAPTOP_CHASSIS = new Set(['8', '9', '10', '14', '30', '31', '32']);
+const DESKTOP_CHASSIS = new Set(['3', '4', '5', '6', '7', '15', '16']);
+const SERVER_CHASSIS = new Set(['17', '18', '19', '20', '21', '22', '23', '24']);
+export function chassisForm(value) {
+    const chassis = value.trim();
+    if (LAPTOP_CHASSIS.has(chassis))
+        return 'laptop';
+    if (DESKTOP_CHASSIS.has(chassis))
+        return 'desktop';
+    if (SERVER_CHASSIS.has(chassis))
+        return 'server';
+    return undefined;
+}
+export function hostVm(version) {
+    return /docker desktop|microsoft|wsl|linuxkit/i.test(version);
+}
 async function models(kind, adapter, known) {
     const agent = adapter.connection.agent;
     const opened = await agent.request('session/new', { cwd: kitHome(), mcpServers: [] });
@@ -88,8 +109,7 @@ async function offer(kind, cli, known, signal) {
         };
     }
     finally {
-        if (adapter !== undefined)
-            killTree(adapter.child);
+        adapter?.retire();
     }
 }
 function reported(kind, reading) {
@@ -98,12 +118,14 @@ function reported(kind, reading) {
         release: reading.release,
         ...(reading.minimum === undefined ? {} : { minimum: reading.minimum }),
         failure: reading.failure,
+        ...(reading.installing === undefined ? {} : { installing: reading.installing }),
         signed_in: reading.signed_in,
         models: reading.models,
         modes: reading.modes,
         full_access: CLIS[kind].fullAccess,
     };
 }
+const NOT_READY = "the Agent's CLI is not ready on this computer";
 function tooOld(kind, release) {
     const cli = CLIS[kind];
     return `${cli.bin} ${release} is older than ${cli.minimum}, the oldest this Kit runs`;
@@ -120,18 +142,42 @@ async function operatingSystem() {
     const release = await readFile('/etc/os-release', 'utf8');
     return /^PRETTY_NAME="?([^"\n]*)"?$/m.exec(release)?.[1] ?? release;
 }
+async function hostForm() {
+    if (process.platform === 'darwin') {
+        const battery = await run('pmset', ['-g', 'batt'], 10_000);
+        return battery.status === 0 && battery.output.includes('InternalBattery') ? 'laptop' : 'desktop';
+    }
+    if (process.platform !== 'linux')
+        return undefined;
+    const [container, version, chassis] = await Promise.all([
+        readFile('/.dockerenv', 'utf8').then(() => true).catch(() => false),
+        readFile('/proc/version', 'utf8').catch(() => ''),
+        readFile('/sys/class/dmi/id/chassis_type', 'utf8').catch(() => ''),
+    ]);
+    if (container && hostVm(version))
+        return undefined;
+    return chassisForm(chassis);
+}
 export class Agents {
     desired = { agents: [], routes: [], transcribe: false };
     house;
     reading = Promise.resolve();
     queues = new Map();
     installing = Promise.resolve();
+    installs = new Map();
     readings = new Map();
     reads = new Map();
+    starts = 0;
     sending = Promise.resolve();
     sent = null;
-    constructor(house) {
+    refreshing = 0;
+    changed;
+    constructor(house, changed = () => undefined) {
         this.house = house;
+        this.changed = changed;
+    }
+    idle() {
+        return this.refreshing === 0;
     }
     read() {
         return this.reading.then(() => undefined, () => undefined);
@@ -140,35 +186,45 @@ export class Agents {
         return this.desired.routes.find((route) => route.agent_id === agentId);
     }
     refresh() {
+        this.refreshing++;
+        this.changed();
         const reading = this.read().then(async () => {
             this.desired = await this.house.deliver('/kit/agents/desired', {});
             return this.desired;
         });
         this.reading = reading;
-        return reading.then(({ agents, transcribe }) => {
+        reading
+            .then(({ agents, transcribe }) => Promise.all([
             holdTranscription(transcribe)
                 .then((changed) => (changed ? this.report() : undefined))
-                .catch(logged);
+                .catch(logged),
             Promise.all(agents.map((kind) => this.load(kind)))
                 .then(() => this.report())
-                .catch(logged);
+                .catch(logged),
+        ]))
+            .catch(() => undefined)
+            .finally(() => {
+            this.refreshing--;
+            this.changed();
         });
+        return reading.then(() => undefined);
     }
     cli(kind) {
+        this.starts += 1;
         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));
+                throw new Error(resolved.failure === null ? tooOld(kind, resolved.release) : NOT_READY);
             }
             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) {
+            if (known?.release !== release || known.minimum !== undefined || this.installs.has(kind)) {
                 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)
+            this.quietOffer(kind, cli, kept)
                 .then((offered) => {
                 const current = this.readings.get(kind);
                 if (this.reads.get(kind) === read && current?.release === release)
@@ -179,7 +235,8 @@ export class Agents {
         });
     }
     located(kind, signal) {
-        return this.queue(kind, () => this.ensure(kind, signal), signal);
+        const owner = {};
+        return this.queue(kind, () => this.ensure(kind, signal, owner).finally(() => this.settle(kind, owner)), signal);
     }
     async reread(kind) {
         await this.examine(kind, this.readings.get(kind) ?? SIGNED_OUT, offer);
@@ -187,7 +244,13 @@ export class Agents {
     }
     async recheck(kind, signal) {
         const known = this.readings.get(kind) ?? SIGNED_OUT;
-        await this.examine(kind, known, async (kind, cli) => ((await signedIn(kind, cli, known, signal)) ? { ...known, signed_in: true } : SIGNED_OUT), signal);
+        const owner = {};
+        try {
+            await this.examine(kind, known, async (kind, cli) => ((await signedIn(kind, cli, known, signal)) ? { ...known, signed_in: true } : SIGNED_OUT), signal, owner);
+        }
+        finally {
+            this.settle(kind, owner);
+        }
         if (!signal.aborted)
             await this.report();
     }
@@ -201,8 +264,18 @@ export class Agents {
         this.reads.set(kind, read);
         return read;
     }
-    update(kind, reading) {
+    hold(kind, reading) {
         this.readings.set(kind, reading);
+        this.installs.delete(kind);
+    }
+    update(kind, reading) {
+        this.hold(kind, reading);
+        this.report().catch(logged);
+    }
+    settle(kind, owner) {
+        if (this.installs.get(kind) !== owner)
+            return;
+        this.installs.delete(kind);
         this.report().catch(logged);
     }
     queue(kind, work, signal) {
@@ -213,13 +286,15 @@ export class Agents {
         this.queues.set(kind, queued.catch(() => undefined));
         return signal === undefined ? queued : Promise.race([queued, ended(signal)]);
     }
-    async ensure(kind, signal) {
+    async ensure(kind, signal, owner = {}) {
         const failed = await installAdapter(kind, signal);
         if (failed !== null)
             throw new Error(failed);
         const found = await locate(kind, signal);
         if (found !== null)
             return found;
+        this.installs.set(kind, owner);
+        this.report().catch(logged);
         const installing = this.installing.catch(() => undefined).then(() => installCli(kind, signal));
         this.installing = installing;
         const failure = await installing;
@@ -230,10 +305,10 @@ export class Agents {
             throw new Error(`the login shell does not find ${CLIS[kind].bin} after its install`);
         return installed;
     }
-    async resolve(kind, signal) {
+    async resolve(kind, signal, owner) {
         let cli;
         try {
-            cli = await realpath(await this.ensure(kind, signal));
+            cli = await realpath(await this.ensure(kind, signal, owner));
         }
         catch (error) {
             const failure = causeOf(error);
@@ -248,28 +323,40 @@ export class Agents {
             return { release, minimum, failure: null, ...SIGNED_OUT };
         return { cli, release };
     }
-    async examine(kind, known, read, signal) {
+    async examine(kind, known, read, signal, owner) {
         const current = this.nextRead(kind);
-        const resolved = await this.queue(kind, () => this.resolve(kind, signal), signal);
+        const resolved = await this.queue(kind, () => this.resolve(kind, signal, owner), signal);
         const reading = 'cli' in resolved ? { release: resolved.release, failure: null, ...(await read(kind, resolved.cli, known)) } : resolved;
         if (this.reads.get(kind) === current && !signal?.aborted)
-            this.readings.set(kind, reading);
+            this.hold(kind, reading);
+    }
+    async quietOffer(kind, cli, known) {
+        for (let seen = -1; seen !== this.starts;) {
+            seen = this.starts;
+            await delay(MODEL_PROBE_QUIET_MS);
+        }
+        return offer(kind, cli, known);
     }
     async load(kind) {
         const known = this.readings.get(kind);
         if (known !== undefined && known.failure === null && known.minimum === undefined)
             return;
-        await this.examine(kind, SIGNED_OUT, offer);
+        await this.examine(kind, SIGNED_OUT, (kind, cli, known) => this.quietOffer(kind, cli, known));
+        await this.report();
     }
     async send() {
         const agents = this.desired.agents.flatMap((kind) => {
-            const reading = this.readings.get(kind);
+            const reading = this.installs.has(kind) ? INSTALLING : this.readings.get(kind);
             return reading === undefined ? [] : [reported(kind, reading)];
         });
         const hostKey = await sshHostKey();
+        const form = await hostForm();
         const body = {
             os: await operatingSystem(),
-            kit_version: KIT_VERSION,
+            ...(form === undefined ? {} : { form }),
+            kit_release: KIT_RELEASE,
+            wire: KIT_WIRE,
+            updates_itself: await updatesItself(),
             agent_base: agentBase(),
             agents,
             transcription: transcriptionReport(),

package/dist/api.js

@@ -3,6 +3,7 @@ import { signInAgain } from './end.js';
 import { readEnrolment } from './home.js';
 import { retryable } from './refusals.js';
 import { relayed } from './relay.js';
+import { endUnserved, KIT_WIRE, KIT_WIRE_HEADER } from './wire.js';
 export class HouseRefusal extends Error {
     status;
     text;
@@ -16,7 +17,7 @@ export function finalRefusal(error) {
     return error instanceof HouseRefusal && retryable(error.text) === false;
 }
 export function retryDelay(attempt) {
-    // Full jitter, doubling from one second to a 30-second cap, spreads the Kits one outage dropped and retries within half a minute of House's return.
+    // Full jitter, doubling from one second to a 30-second cap, spreads the Kit processes one outage dropped and retries within half a minute of House's return.
     return Math.random() * Math.min(30_000, 1000 * 2 ** attempt);
 }
 export async function retrying(sent, signal, pause = retryDelay) {
@@ -37,12 +38,15 @@ export async function post(house, path, body, credential, signal) {
         method: 'POST',
         headers: {
             'content-type': 'application/json',
+            [KIT_WIRE_HEADER]: String(KIT_WIRE),
             ...(credential === undefined ? {} : { authorization: `Bearer ${credential}` }),
         },
         body: JSON.stringify(body),
         signal,
     });
     const text = await answer.text();
+    if (!answer.ok)
+        endUnserved(text);
     if (!answer.ok)
         throw new HouseRefusal(path, answer.status, text);
     return JSON.parse(text);

package/dist/app-git.js

@@ -1,15 +1,9 @@
-import { extname, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
 import { run } from './git.js';
 import { kitHome, readOwnAgent } from './home.js';
-import { quoted } from './shell.js';
+const HELPER = '!kit git-credential';
 function section(house) {
     return `credential.${new URL('/app/', house).href}`;
 }
-function helper() {
-    const main = fileURLToPath(new URL(`./kit-main${extname(fileURLToPath(import.meta.url))}`, import.meta.url));
-    return `!HOUSE_KIT_HOME=${quoted(resolve(kitHome()))} ${quoted(process.execPath)} ${quoted(main)} git-credential`;
-}
 async function configured(args) {
     try {
         return await run(kitHome(), ['config', '--global', ...args]);
@@ -20,30 +14,18 @@ async function configured(args) {
         throw error;
     }
 }
-async function forget(house) {
-    await configured(['--remove-section', section(house)]);
-}
-async function register(house) {
-    await forget(house);
-    for (const value of ['', helper()]) {
-        const ran = await configured(['--add', `${section(house)}.helper`, value]);
+export async function placeAppGit(ownAgent) {
+    if (ownAgent === null)
+        return;
+    await configured(['--remove-section', section(ownAgent.house)]);
+    for (const value of ['', HELPER]) {
+        const ran = await configured(['--add', `${section(ownAgent.house)}.helper`, value]);
         if (ran === null)
             return;
         if (ran.status !== 0)
             throw new Error(`git config failed: ${ran.stderr.trim()}`);
     }
 }
-export async function placeAppGit(before, after) {
-    if (before !== null && before.house !== after?.house)
-        await forget(before.house);
-    if (after !== null)
-        await register(after.house);
-}
-export async function forgetAppGit() {
-    const ownAgent = await readOwnAgent();
-    if (ownAgent !== null)
-        await forget(ownAgent.house);
-}
 export async function answerGitCredential(operation) {
     let asked = '';
     for await (const chunk of process.stdin)
@@ -55,8 +37,10 @@ export async function answerGitCredential(operation) {
         .filter((line) => line.includes('='))
         .map((line) => [line.slice(0, line.indexOf('=')), line.slice(line.indexOf('=') + 1)]));
     const ownAgent = await readOwnAgent();
-    if (ownAgent === null)
+    if (ownAgent === null) {
+        process.stderr.write(`kit: Kit home ${kitHome()} is not signed in; run kit login\n`);
         return;
+    }
     const house = new URL(ownAgent.house);
     if (attributes.get('protocol') !== house.protocol.slice(0, -1) || attributes.get('host') !== house.host)
         return;

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 {