@agentshouse/kit 0.2.1-alpha.9 → 0.2.1-c073f4e9391b2

package/README.md

@@ -1,41 +1,59 @@
 # House Kit
 
-House 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.
+House 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
 
-Connect a computer from agents.house. It gives you the one command that
-installs House Kit on that computer and updates it when you run it again. On
-Linux, macOS and Windows 11 it runs House Kit in one Docker container with
-your workspace, `~/AgentsHouse` unless you pass `--workspace <path>`, mounted
-at `/agents/house`. Append a `kit` or `house` command to the same command to
-run it in that container.
+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
+pass `--workspace <path>`.
 
-On your own Ubuntu 26.04 server, run the Linux command with `--linux` to
+Add `--container` to run House 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.
+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.
+
+On your own Linux server, run the Linux command with `--linux` to
 install House Kit natively, with its workspace at `/agents/house`; `kit` and
 `house` are then on the server's `PATH`.
 
-House Kit 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.
+House Kit runs the agent CLIs your login shell finds and installs a missing one
+through that CLI's own installer. Running the command again offers to update
+each CLI older than House Kit needs; add `--update-clis` to update every one to
+its latest release without asking. House Kit also gives every Agent on the
+Environment a set of agent skills. Add `--no-skills` to the command to leave
+them out; running it again without the flag brings them back.
 
 ## Commands
 
-`kit login` opens a link you confirm in your browser and keeps the
-Environment's credential in `~/.house-kit`, or in `$HOUSE_KIT_HOME` when it is
-set. Pass `--manual` to paste the code by hand on a machine without a browser,
-and `--environment <id>` to reconnect an Environment you already have.
-
-`kit resident` keeps the Environment connected, and keeps the Rooms you chose
-for this Environment as Git repositories under `/agents/house/working-copies`.
-Commit in one and run `house git push --owner` there to send the commit to
-House; on a computer, run it through the install command from the copy's
-directory. Inside an Agent conversation the Agent runs `house git push`.
+`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>`
+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.
+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. Codex sessions started after a
+login run a lone `house` command outside their sandbox. `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.
+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 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.
 
 ## License
 
-MIT
-
-The skills come from [mattpocock/skills](https://github.com/mattpocock/skills); thank you, Matt Pocock.
+MIT. The skills come from [mattpocock/skills](https://github.com/mattpocock/skills); thank you, Matt Pocock.

package/dist/abort.js

@@ -0,0 +1,9 @@
+export function unlessAborted(work, signal) {
+    return new Promise((resolve, reject) => {
+        const aborted = () => reject(signal.reason);
+        signal.addEventListener('abort', aborted, { once: true });
+        if (signal.aborted)
+            aborted();
+        work.then(resolve, reject).finally(() => signal.removeEventListener('abort', aborted));
+    });
+}

package/dist/acp.js

@@ -1,17 +1,21 @@
 import { ndJsonStream, PROTOCOL_VERSION, } from '@agentclientprotocol/sdk';
 import { spawn } from 'node:child_process';
-import { readdirSync, readFileSync } from 'node:fs';
 import { Readable, Writable } from 'node:stream';
-import { CLIS, KIT_VERSION, cliCommand, withoutProxy } from './clis.js';
-export const TURN_STARTED = 'kit/turn_started';
-export const TURN_ENDED = 'kit/turn_ended';
-export async function startAdapter(kind, cwd, app, jobs = () => undefined, added = {}) {
-    const child = spawn(cliCommand(kind), CLIS[kind].args, {
+import { CLIS, KIT_VERSION, adapterCommand, withoutProxy } from './clis.js';
+import { killTree } from './scope.js';
+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(), ...added },
+        env: { ...withoutProxy(), ...(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 stderr = '';
     child.stderr.on('data', (chunk) => {
         stderr = (stderr + chunk.toString('utf8')).slice(-4000);
@@ -28,16 +32,11 @@ export async function startAdapter(kind, cwd, app, jobs = () => undefined, added
         writable: stream.writable,
         readable: stream.readable.pipeThrough(new TransformStream({
             transform(message, controller) {
-                const notice = message;
-                const job = CLIS[kind].job(notice);
-                if (job !== null)
-                    jobs(job);
-                if (!notice.params?.update?.sessionUpdate?.startsWith('async_task_'))
+                const read = message;
+                events(read);
+                if (read.id !== undefined || (read.method !== 'session/update' && !read.method.startsWith('_'))) {
                     controller.enqueue(message);
-                if (CLIS[kind].turnStarted(notice))
-                    controller.enqueue({ jsonrpc: '2.0', method: TURN_STARTED });
-                if (CLIS[kind].turnEnded(notice))
-                    controller.enqueue({ jsonrpc: '2.0', method: TURN_ENDED });
+                }
             },
         })),
     });
@@ -49,10 +48,12 @@ export async function startAdapter(kind, cwd, app, jobs = () => undefined, added
                 fs: { readTextFile: false, writeTextFile: false },
                 terminal: false,
                 elicitation: { form: {} },
-                _meta: { jetbrains: { air: { version: 1, capabilities: ['asyncTasks'] } } },
+                session: { compaction: {}, notices: {} },
+                _meta: { jetbrains: { air: { version: 1, capabilities: CLIS[kind].air } } },
             },
             clientInfo: { name: '@agentshouse/kit', version: KIT_VERSION },
         });
+        scope?.entered(child.pid);
         return { child, connection, initialized, exited };
     }
     catch (error) {
@@ -60,61 +61,3 @@ export async function startAdapter(kind, cwd, app, jobs = () => undefined, added
         throw error;
     }
 }
-function parents() {
-    const children = new Map();
-    for (const entry of readdirSync('/proc')) {
-        if (!/^\d+$/.test(entry))
-            continue;
-        try {
-            const stat = readFileSync(`/proc/${entry}/stat`, 'utf8');
-            const parent = Number(stat.slice(stat.lastIndexOf(')') + 2).split(' ')[1]);
-            children.set(parent, [...(children.get(parent) ?? []), Number(entry)]);
-        }
-        catch { }
-    }
-    return children;
-}
-function descendants(roots) {
-    const children = parents();
-    const tree = [];
-    const pending = roots.flatMap((root) => children.get(root) ?? []);
-    while (pending.length > 0) {
-        const pid = pending.pop();
-        tree.push(pid);
-        pending.push(...(children.get(pid) ?? []));
-    }
-    return tree;
-}
-function killAll(pids) {
-    for (const pid of pids) {
-        for (const target of [-pid, pid]) {
-            try {
-                process.kill(target, 'SIGKILL');
-            }
-            catch { }
-        }
-    }
-}
-function marked(marker) {
-    return readdirSync('/proc')
-        .filter((entry) => {
-        try {
-            return /^\d+$/.test(entry) && readFileSync(`/proc/${entry}/environ`, 'utf8').split('\0').includes(marker);
-        }
-        catch {
-            return false;
-        }
-    })
-        .map(Number);
-}
-export function killTree(child) {
-    killAll([child.pid, ...descendants([child.pid])]);
-}
-export function killMarked(marker) {
-    const pids = marked(marker);
-    killAll([...pids, ...descendants(pids)]);
-}
-export function killDescendants() {
-    const pids = marked(`HOUSE_KIT_RESIDENT=${process.pid}`);
-    killAll([...pids, ...descendants([process.pid, ...pids])]);
-}

package/dist/agents.js

@@ -1,90 +1,303 @@
 import { client } from '@agentclientprotocol/sdk';
-import { readFile } from 'node:fs/promises';
+import { readFile, realpath } from 'node:fs/promises';
 import { startAdapter } from './acp.js';
-import { CLIS, KIT_VERSION, cliCommand, install, run } from './clis.js';
-import { kitHome } from './home.js';
-async function signedIn(kind) {
-    const probe = CLIS[kind].signedIn;
-    if ('command' in probe) {
-        return (await run(cliCommand(kind), probe.command, 30_000)).status === 0;
+import { CLIS, KIT_VERSION, below, installAdapter, installCli, locate, run, versionOf } from './clis.js';
+import { agentBase, kitHome } from './home.js';
+import { updatesItself } from './placement.js';
+import { killTree } from './scope.js';
+import { holdTranscription, transcriptionReport } from './transcription.js';
+import { KIT_WIRE } from './wire.js';
+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 choices(options).map((entry) => entry.value);
+}
+function causeOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function logged(error) {
+    process.stderr.write(`kit: ${causeOf(error)}\n`);
+}
+async function models(kind, adapter, known) {
+    const agent = adapter.connection.agent;
+    const opened = await agent.request('session/new', { cwd: kitHome(), mcpServers: [] });
+    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 { models: [], modes };
+    const offered = [];
+    for (const value of values(model.options)) {
+        if (select(options, 'model')?.currentValue !== value) {
+            try {
+                options = (await agent.request('session/set_config_option', { sessionId: opened.sessionId, configId: model.id, value })).configOptions;
+            }
+            catch (error) {
+                process.stderr.write(`kit: ${kind} refused its model ${value}: ${causeOf(error)}\n`);
+                offered.push({ model: value, efforts: known.find((entry) => entry.model === value)?.efforts ?? [] });
+                continue;
+            }
+        }
+        const effort = select(options, 'thought_level');
+        offered.push({ model: value, efforts: effort === undefined ? [] : values(effort.options) });
     }
+    return { models: offered, modes };
+}
+async function signedIn(kind, cli, known, signal) {
+    const probe = CLIS[kind].signedIn;
+    // A sign-in check that has not answered in half a minute counts as signed out rather than stalling the report.
+    if ('command' in probe)
+        return (await run(cli, probe.command, 30_000, false, signal)).status === 0;
+    return (await offer(kind, cli, known, signal)).signed_in;
+}
+function ended(signal) {
+    return new Promise((_, reject) => {
+        if (signal.aborted)
+            reject(signal.reason);
+        signal.addEventListener('abort', () => reject(signal.reason), { once: true });
+    });
+}
+async function offer(kind, cli, known, signal) {
+    const probe = CLIS[kind].signedIn;
+    // A sign-in check that has not answered in half a minute counts as signed out rather than stalling the report.
+    if ('command' in probe && (await run(cli, probe.command, 30_000, false, signal)).status !== 0)
+        return SIGNED_OUT;
+    let adapter;
     try {
-        const adapter = await startAdapter(kind, kitHome(), client({ name: '@agentshouse/kit' }));
-        adapter.child.kill('SIGKILL');
-        const method = adapter.initialized._meta?.[probe.initializeMeta];
-        return typeof method === 'string' && method.length > 0;
+        adapter = await startAdapter(kind, cli, kitHome(), client({ name: '@agentshouse/kit' }), () => undefined, {}, signal);
+        signal?.throwIfAborted();
+        if ('initializeMeta' in probe) {
+            const method = adapter.initialized._meta?.[probe.initializeMeta];
+            if (typeof method !== 'string' || method.length === 0)
+                return SIGNED_OUT;
+        }
+        return { signed_in: true, ...(await models(kind, adapter, known.models)) };
+    }
+    catch (error) {
+        if (!signal?.aborted)
+            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,
+            modes: known.modes,
+        };
     }
-    catch {
-        return false;
+    finally {
+        if (adapter !== undefined)
+            killTree(adapter.child);
     }
 }
+function reported(kind, reading) {
+    return {
+        kind,
+        release: reading.release,
+        ...(reading.minimum === undefined ? {} : { minimum: reading.minimum }),
+        failure: reading.failure,
+        signed_in: reading.signed_in,
+        models: reading.models,
+        modes: reading.modes,
+        full_access: CLIS[kind].fullAccess,
+    };
+}
+function tooOld(kind, release) {
+    const cli = CLIS[kind];
+    return `${cli.bin} ${release} is older than ${cli.minimum}, the oldest this Kit runs`;
+}
+async function sshHostKey() {
+    // Listing a local host key takes a moment, so ten seconds only bounds a stuck ssh-keygen.
+    const listed = await run('ssh-keygen', ['-l', '-E', 'sha256', '-f', '/etc/ssh/ssh_host_ed25519_key.pub'], 10_000);
+    return listed.status === 0 ? (/^\d+ (SHA256:\S+)/.exec(listed.output)?.[1] ?? null) : null;
+}
 async function operatingSystem() {
+    // sw_vers answers at once, so ten seconds only bounds a stuck call.
+    if (process.platform === 'darwin')
+        return `macOS ${(await run('sw_vers', ['-productVersion'], 10_000)).output.trim()}`;
     const release = await readFile('/etc/os-release', 'utf8');
     return /^PRETTY_NAME="?([^"\n]*)"?$/m.exec(release)?.[1] ?? release;
 }
 export class Agents {
-    desired = { agents: [], routes: [] };
+    desired = { agents: [], routes: [], transcribe: false };
     house;
     reading = Promise.resolve();
+    queues = new Map();
     installing = Promise.resolve();
-    releases = new Map();
-    reporting = null;
-    again = false;
-    constructor(house) {
+    readings = new Map();
+    reads = new Map();
+    sending = Promise.resolve();
+    sent = null;
+    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);
     }
-    installed() {
-        return this.installing.catch(() => undefined);
-    }
     route(agentId) {
         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;
-        const installing = this.installed()
-            .then(() => reading)
-            .then(({ agents }) => this.install(agents));
-        this.installing = installing;
-        if (this.reporting === null)
-            this.reporting = this.reports();
-        else
-            this.again = true;
-        return Promise.all([installing, this.reporting]).then(() => undefined);
-    }
-    async report() {
-        const agents = [];
-        for (const [kind, release] of this.releases) {
-            agents.push({ kind, release, signed_in: release !== null && (await signedIn(kind)) });
-        }
-        await this.house.deliver('/kit/agents/report', {
-            os: await operatingSystem(),
-            kit_version: KIT_VERSION,
-            agents,
+        reading
+            .then(({ agents, transcribe }) => Promise.all([
+            holdTranscription(transcribe)
+                .then((changed) => (changed ? this.report() : undefined))
+                .catch(logged),
+            Promise.all(agents.map((kind) => this.load(kind)))
+                .then(() => this.report())
+                .catch(logged),
+        ]))
+            .catch(() => undefined)
+            .finally(() => {
+            this.refreshing--;
+            this.changed();
         });
+        return reading.then(() => undefined);
+    }
+    cli(kind) {
+        return this.queue(kind, async () => {
+            const resolved = await this.resolve(kind);
+            if (!('cli' in resolved)) {
+                this.update(kind, resolved);
+                throw new Error(resolved.failure ?? tooOld(kind, resolved.release));
+            }
+            const { cli, release } = resolved;
+            const known = this.readings.get(kind);
+            const kept = known?.release === null || known?.minimum !== undefined ? SIGNED_OUT : (known ?? SIGNED_OUT);
+            if (known?.release !== release || known.minimum !== undefined) {
+                this.update(kind, { release, failure: null, signed_in: kept.signed_in, models: kept.models, modes: kept.modes });
+            }
+            const read = this.nextRead(kind);
+            offer(kind, cli, kept)
+                .then((offered) => {
+                const current = this.readings.get(kind);
+                if (this.reads.get(kind) === read && current?.release === release)
+                    this.update(kind, { ...current, ...offered });
+            })
+                .catch(logged);
+            return cli;
+        });
+    }
+    located(kind, signal) {
+        return this.queue(kind, () => this.ensure(kind, signal), signal);
     }
-    async install(kinds) {
-        const releases = new Map();
-        for (const kind of kinds)
-            releases.set(kind, await install(kind));
-        this.releases = releases;
+    async reread(kind) {
+        await this.examine(kind, this.readings.get(kind) ?? SIGNED_OUT, offer);
+        await this.report();
     }
-    async reports() {
+    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);
+        if (!signal.aborted)
+            await this.report();
+    }
+    report() {
+        const sending = this.sending.catch(() => undefined).then(() => this.send());
+        this.sending = sending;
+        return sending;
+    }
+    nextRead(kind) {
+        const read = (this.reads.get(kind) ?? 0) + 1;
+        this.reads.set(kind, read);
+        return read;
+    }
+    update(kind, reading) {
+        this.readings.set(kind, reading);
+        this.report().catch(logged);
+    }
+    queue(kind, work, signal) {
+        const queued = (this.queues.get(kind) ?? Promise.resolve()).then(() => {
+            signal?.throwIfAborted();
+            return work();
+        });
+        this.queues.set(kind, queued.catch(() => undefined));
+        return signal === undefined ? queued : Promise.race([queued, ended(signal)]);
+    }
+    async ensure(kind, signal) {
+        const failed = await installAdapter(kind, signal);
+        if (failed !== null)
+            throw new Error(failed);
+        const found = await locate(kind, signal);
+        if (found !== null)
+            return found;
+        const installing = this.installing.catch(() => undefined).then(() => installCli(kind, signal));
+        this.installing = installing;
+        const failure = await installing;
+        if (failure !== null)
+            throw new Error(failure);
+        const installed = await locate(kind, signal);
+        if (installed === null)
+            throw new Error(`the login shell does not find ${CLIS[kind].bin} after its install`);
+        return installed;
+    }
+    async resolve(kind, signal) {
+        let cli;
         try {
-            do {
-                this.again = false;
-                await this.installing;
-                await this.report();
-            } while (this.again);
+            cli = await realpath(await this.ensure(kind, signal));
         }
-        finally {
-            this.reporting = null;
+        catch (error) {
+            const failure = causeOf(error);
+            process.stderr.write(`kit: ${kind} did not install: ${failure}\n`);
+            return { release: null, failure, ...SIGNED_OUT };
         }
+        const release = await versionOf(cli, signal);
+        if (release === null)
+            return { release: null, failure: `${cli} --version names no version`, ...SIGNED_OUT };
+        const minimum = CLIS[kind].minimum;
+        if (below(release, minimum))
+            return { release, minimum, failure: null, ...SIGNED_OUT };
+        return { cli, release };
+    }
+    async examine(kind, known, read, signal) {
+        const current = this.nextRead(kind);
+        const resolved = await this.queue(kind, () => this.resolve(kind, signal), 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);
+    }
+    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);
+    }
+    async send() {
+        const agents = this.desired.agents.flatMap((kind) => {
+            const reading = this.readings.get(kind);
+            return reading === undefined ? [] : [reported(kind, reading)];
+        });
+        const hostKey = await sshHostKey();
+        const body = {
+            os: await operatingSystem(),
+            kit_version: KIT_VERSION,
+            wire: KIT_WIRE,
+            updates_itself: await updatesItself(),
+            agent_base: agentBase(),
+            agents,
+            transcription: transcriptionReport(),
+            ...(hostKey === null ? {} : { ssh_host_key: hostKey }),
+        };
+        const state = JSON.stringify(body);
+        if (state === this.sent)
+            return;
+        await this.house.deliver('/kit/agents/report', body);
+        this.sent = state;
     }
 }

package/dist/api.js

@@ -1,4 +1,9 @@
+import { setTimeout as delay } from 'node:timers/promises';
+import { signInAgain, updateRequired } from './end.js';
 import { readEnrolment } from './home.js';
+import { retryable } from './refusals.js';
+import { relayed } from './relay.js';
+import { KIT_WIRE, KIT_WIRE_HEADER, tooOld } from './wire.js';
 export class HouseRefusal extends Error {
     status;
     text;
@@ -8,24 +13,54 @@ export class HouseRefusal extends Error {
         this.text = text;
     }
 }
+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.
+    return Math.random() * Math.min(30_000, 1000 * 2 ** attempt);
+}
+export async function retrying(sent, signal, pause = retryDelay) {
+    for (let attempt = 0;; attempt++) {
+        try {
+            return await sent();
+        }
+        catch (error) {
+            if (!(error instanceof HouseRefusal) || retryable(error.text) !== true)
+                throw error;
+        }
+        // A request House refused as retryable is sent again after the caller's pause, the jittered curve unless it names its own.
+        await delay(pause(attempt), undefined, { signal });
+    }
+}
 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',
+            [KIT_WIRE_HEADER]: String(KIT_WIRE),
             ...(credential === undefined ? {} : { authorization: `Bearer ${credential}` }),
         },
         body: JSON.stringify(body),
         signal,
     });
     const text = await answer.text();
+    if (!answer.ok && tooOld(text))
+        updateRequired(house);
     if (!answer.ok)
         throw new HouseRefusal(path, answer.status, text);
     return JSON.parse(text);
 }
 async function enrolledPost(path, body, signal) {
     const { house, credential } = (await readEnrolment());
-    return post(house, path, body, credential, signal);
+    try {
+        return await post(house, path, body, credential, signal);
+    }
+    catch (error) {
+        if (error instanceof HouseRefusal && error.status === 401)
+            await signInAgain(credential);
+        throw error;
+    }
 }
 export const house = {
     post: enrolledPost,
@@ -35,10 +70,11 @@ export const house = {
                 return await enrolledPost(path, body);
             }
             catch (error) {
-                if (error instanceof HouseRefusal && error.status < 500)
+                if (finalRefusal(error))
                     throw error;
                 process.stderr.write(`kit: ${path} did not reach House: ${error.message}\n`);
-                await new Promise((resolve) => setTimeout(resolve, Math.min(30_000, 1000 * 2 ** attempt)));
+                // A delivery House did not take is sent again on the jittered curve for as long as it is still current.
+                await new Promise((resolve) => setTimeout(resolve, retryDelay(attempt)));
                 if (!current())
                     throw error;
             }