@agentshouse/kit 0.2.1-cca9e1f43de44 → 0.2.1-ccf188e02985d

package/README.md

@@ -1,26 +1,24 @@
 # 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
 
-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 "House 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 'House 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 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>`.
 
 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.
+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 another `HOUSE_KIT_HOME`
+than the installed Kit's asks you to confirm before it replaces that Kit, and leaves that Kit home as it was.
 
-On your own Ubuntu 26.04 server, run the Linux command with `--linux` to
+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`.
 
@@ -33,25 +31,29 @@ 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. It 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 that Git
-access; a later `kit login` reconnects the same Environment.
-
-`kit resident` keeps the Environment connected, and keeps the Rooms you chose
-for this Environment as Git repositories under `local-copies` in the
-workspace. Commit in one and run `house push --owner` there to send the
-commit to House; in the container, run it through the install command from the
-copy's directory. Inside an Agent conversation the Agent runs `house 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_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.
+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, 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 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, 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 erases a Room's copy, unpushed commits included, 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.
 
 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.
+engine and model use about 425 MB beside the Environment's credential; turning it off deletes them.
 
 ## License
 

package/dist/acp.js

@@ -1,44 +1,66 @@
 import { ndJsonStream, PROTOCOL_VERSION, } from '@agentclientprotocol/sdk';
-import { execFileSync, spawn } from 'node:child_process';
-import { readdirSync, readFileSync } from 'node:fs';
+import { spawn } from 'node:child_process';
 import { Readable, Writable } from 'node:stream';
 import { CLIS, KIT_VERSION, adapterCommand, withoutProxy } from './clis.js';
-export async function startAdapter(kind, cli, cwd, app, events = () => undefined, added = {}, signal) {
+import { killTree } from './scope.js';
+const RETIRED = 'the CLI was retired';
+export async function startAdapter(kind, cli, cwd, app, events = () => undefined, added = {}, signal, scope = null) {
     const adapter = CLIS[kind].adapter;
-    const child = spawn(adapter === null ? cli : adapterCommand(kind), CLIS[kind].args, {
+    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 },
         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 stderr = '';
     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 connection = app.connect({
         writable: stream.writable,
         readable: stream.readable.pipeThrough(new TransformStream({
             transform(message, controller) {
                 const read = message;
-                events(read);
+                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) => {
+            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(`the CLI exited with ${code ?? signal}${last ? `: ${last}` : ''}`);
+        });
+    });
+    const retire = () => {
+        owned = false;
+        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,103 +73,11 @@ export async function startAdapter(kind, cli, cwd, app, events = () => undefined
             },
             clientInfo: { name: '@agentshouse/kit', version: KIT_VERSION },
         });
-        return { child, connection, initialized, exited };
+        scope?.entered(child.pid);
+        return { connection, initialized, exited, lost, retire };
     }
     catch (error) {
-        child.kill('SIGKILL');
+        retire();
         throw error;
     }
 }
-const LISTING_BYTES = 1 << 28;
-function listed(options) {
-    return execFileSync('ps', [options, '-o', 'pid=,ppid=,command='], { encoding: 'utf8', maxBuffer: LISTING_BYTES })
-        .split('\n')
-        .flatMap((line) => {
-        const fields = /^\s*(\d+)\s+(\d+)\s?(.*)$/.exec(line);
-        return fields === null ? [] : [[Number(fields[1]), Number(fields[2]), fields[3]]];
-    });
-}
-function parents() {
-    const children = new Map();
-    const adopt = (pid, parent) => children.set(parent, [...(children.get(parent) ?? []), pid]);
-    if (process.platform === 'darwin') {
-        for (const [pid, parent] of listed('-Aww'))
-            adopt(pid, parent);
-        return children;
-    }
-    for (const entry of readdirSync('/proc')) {
-        if (!/^\d+$/.test(entry))
-            continue;
-        try {
-            const stat = readFileSync(`/proc/${entry}/stat`, 'utf8');
-            adopt(Number(entry), Number(stat.slice(stat.lastIndexOf(')') + 2).split(' ')[1]));
-        }
-        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) {
-    if (process.platform === 'darwin') {
-        return listed('-AEww')
-            .filter(([, , command]) => ` ${command} `.includes(` ${marker} `))
-            .map(([pid]) => pid);
-    }
-    return readdirSync('/proc')
-        .filter((entry) => {
-        try {
-            return /^\d+$/.test(entry) && readFileSync(`/proc/${entry}/environ`, 'utf8').split('\0').includes(marker);
-        }
-        catch {
-            return false;
-        }
-    })
-        .map(Number);
-}
-function commandLine(pid) {
-    try {
-        return readFileSync(`/proc/${pid}/cmdline`, 'utf8').split('\0').join(' ').trim();
-    }
-    catch {
-        return '';
-    }
-}
-export function processes(marker) {
-    const pids = marked(marker);
-    const tree = [...pids, ...descendants(pids)];
-    const commands = process.platform === 'darwin'
-        ? new Map(listed('-Aww').map(([pid, , command]) => [pid, command]))
-        : new Map(tree.map((pid) => [pid, commandLine(pid)]));
-    return new Set(tree.flatMap((pid) => (commands.get(pid) ? [`${pid} ${commands.get(pid)}`] : [])));
-}
-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,10 +1,16 @@
 import { client } from '@agentclientprotocol/sdk';
 import { readFile, realpath } from 'node:fs/promises';
-import { killTree, startAdapter } from './acp.js';
+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 { agentBase, kitHome } from './home.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;
@@ -21,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: [] });
@@ -87,8 +109,7 @@ async function offer(kind, cli, known, signal) {
         };
     }
     finally {
-        if (adapter !== undefined)
-            killTree(adapter.child);
+        adapter?.retire();
     }
 }
 function reported(kind, reading) {
@@ -97,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`;
@@ -119,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);
@@ -139,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)
@@ -178,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);
@@ -186,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();
     }
@@ -200,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) {
@@ -212,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;
@@ -229,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);
@@ -247,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)
+        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(),
+            ...(form === undefined ? {} : { form }),
             kit_version: KIT_VERSION,
+            wire: KIT_WIRE,
+            updates_itself: await updatesItself(),
             agent_base: agentBase(),
             agents,
             transcription: transcriptionReport(),

package/dist/api.js

@@ -1,8 +1,9 @@
 import { setTimeout as delay } from 'node:timers/promises';
-import { end, SIGN_IN_AGAIN } from './end.js';
+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;
@@ -19,7 +20,7 @@ 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) {
+export async function retrying(sent, signal, pause = retryDelay) {
     for (let attempt = 0;; attempt++) {
         try {
             return await sent();
@@ -28,8 +29,8 @@ export async function retrying(sent, signal) {
             if (!(error instanceof HouseRefusal) || retryable(error.text) !== true)
                 throw error;
         }
-        // A request House refused as retryable is sent again on the jittered curve.
-        await delay(retryDelay(attempt), undefined, { signal });
+        // 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) {
@@ -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 && tooOld(text))
+        updateRequired();
     if (!answer.ok)
         throw new HouseRefusal(path, answer.status, text);
     return JSON.parse(text);
@@ -54,7 +58,7 @@ async function enrolledPost(path, body, signal) {
     }
     catch (error) {
         if (error instanceof HouseRefusal && error.status === 401)
-            end(SIGN_IN_AGAIN);
+            await signInAgain(credential);
         throw error;
     }
 }